2 CsCaracteristicasGenerales PDF

Cursos de Verano 2002
UNIVERSIDAD DE OVIEDO
Cod. 1728.61
PLATAFORMA .NET Y
SERVICIOS WEB
Caractersticas Generales de C#
Benjamn Lpez Prez
benja@lsi.uniovi.es
Dpto. de Informtica
OOTLab - Laboratorio de Tecnologas de Orientacin a Objetos
http://www.ootlab.uniovi.es
Contenidos
1.
2.
3.
4.
5.
6.
7.
Generalidades
Tipos
Expresiones
Declaraciones
Sentencias
Clases y estructuras
Cdigo Inseguro

Caractersticas generales de C#
Benjamn Lpez Prez
OOTLab
OOTLab
Origen y necesidad de un nuevo lenguaje

Creadores: Anders Hejlsberg y Scott Wiltamuth
Necesidad:
Especfico para .NET

Orientado a componentes
Notas:
Sintaxis de C/C++/Java con facilidad de VB

BCL programada en C# -> depurado y optimizado
Benjamn Lpez Prez
OOTLab
OOTLab
Caractersticas de C#
Sencillez
Autocontenido (sin IDLs, ficheros de cabecera,...)
Sin elementos inneccesarios (::, macros, etc.)
Tipo bsicos de tamao fijo
Modernidad
Tipos bsicos para decimales, cadenas y lgicos
Soporte extensible para colecciones
Orientado a objetos
Sin funciones ni variables globales
Herencia simple
Encapsulacin con public,protected,private e internal.
Redefinibildad explcita (menos errores y ms eficiente)

Benjamn Lpez Prez
OOTLab
OOTLab
Orientado a componentes
De base soporta propiedades, atributos y eventos
Seguridad de tipos
Control de conversiones
Control de inicializacin de variables
Control de ndices en accesos a tablas
Control de desbordamientos
Control de tipos en punteros a funcin
Control en parmetros mltiples
Gestin automtica de memoria
Recolector de basura
Liberacin recursos determinista con using

Benjamn Lpez Prez
OOTLab
OOTLab
Instrucciones seguras
Slo condiciones lgicas

Sin traspasos implcitos entre casos de switch
Sistema de tipos unificados
Clase padre comn System.Object

Boxing y unboxing para homogeneidad y eficiencia
Tipos bsicos de tamao fijo
Extensibilidad de operadores
Redefiniciones inteligentes y consistentes

Indizadores
Extensibilidad de tipos bsicos
Posibilidad de paso por referencia para eficiencia

Benjamn Lpez Prez
OOTLab
OOTLab
Extensibilidad de modificadores
Atributos
Versionable
Redefinir virtual con override
Ocultar con new
Compatible
Con funciones nativas (ej: Win32) con Pinvoke

Con objetos COM con tlbimp y regasm
Con controles ActiveX con aximp y regasm

Benjamn Lpez Prez
OOTLab
OOTLab
Introduccin a C#
1.
2.
3.
4.
5.
6.
Generalidades
Tipos
Expresiones
Declaraciones
Sentencias
Clases y Estructuras
C# Avanzado
7.
8.
9.
10.
11.
12.
13.
14.
Herencia
Interfaces
Delegados
Excepciones
Namespaces y Ensamblados
Atributos
Threads
Comentarios XML
Referencias:
B.Albahari, P.Drayton, B.Merrill: C# Essentials. O'Reilly, 2001
S.Robinson et al: Professional C#, Wrox Press, 2001
Documentacin en lnea en el CD .NET SDK

Benjamn Lpez Prez
OOTLab
OOTLab
Muy similar a Java
70% Java, 10% C++, 5% Visual Basic, 15% nuevo
Como en Java
Como en C++
Orientacin a Objetos (herencia

simple)
Interfaces
Excepciones
Threads
Namespaces (como Paquetes)
Fuertemente tipado
Reflexin
Carga dinmica de cdigo
...
(Operador) Sobrecarga
Aritmtica punteros en cdigo
inseguro
Algunos detalles sintcticos

Benjamn Lpez Prez
OOTLab
OOTLab
Nuevas caracterticas de C#
Nuevo (comparado con Java)
"Simplificaciones Sintcticas"
Programacin basada en componentes

- Propiedades
- Eventos
Delegados
Indizadores
Sobrecarga de operadores
Sentencias foreach
Boxing/unboxing
Atributos
...
Referencias y parametros de salida

Objetos en el stack (structs)
Arrays Rectangulares
Enumeraciones
Sistema de tipos Unificado
goto
Versionado

Benjamn Lpez Prez
OOTLab
OOTLab
Hola Mundo
Fichero Hola.cs
using System;
class Hola {
static void Main() {
Console.WriteLine("Hola Mundo");
}
utiliza el namespace System

el punto de entrada se debe llamar Main
la salida va a la consola
el nombre de fichero y de la clase
no tienen por que ser iguales
}
Compilacin (en la ventana de consola)
csc Hola.cs
Ejecucin
Hola Mundo

Benjamn Lpez Prez
OOTLab
OOTLab
Estructura de los Programas en C#

Programa
Fich. F1.cs
namespace A {...}
clase X {...}
Fich. F2.cs
namespace B {...}
clase Y {...}
Fich. F3.cs
namespace C {...}
clase Z {...}
Si no se especifica namespace => namespace por defecto annimo

Los Namespaces pueden contener tambin estructuras, interfaces,
delegados y enumerados
Namespace puede ser "reabierto" en otros ficheros
Caso ms simple: clase nica, fichero nico, namespace por defecto
Benjamn Lpez Prez
OOTLab
OOTLab
Un Programa formado por 2 Ficheros

Contador.cs
class Contador {
int val = 0;
public void Add (int x) { val = val + x; }
public int Val () { return val; }
}
Prog.cs
Compilacin
csc Contador.cs Prog.cs
=> genera Prog.exe
Ejecucin
Prog
using System;
class Prog {
static void Main() {
Contador c = new Contador();
c.Add(3); c.Add(5);
Console.WriteLine("val = " +
c.Val());
}
}
Trabajando con DLLs

csc /target:library Contador.cs
=> genera Contador.dll
csc /reference:Contador.dll Prog.cs
=> generat Prog.exe
Benjamn Lpez Prez
OOTLab
OOTLab
1.
2.
3.
4.
5.
6.
7.
Generalidades
Tipos
Expresiones
Declaraciones
Sentencias
Cdigo Inseguro
Sistema de tipos Unificado

Tipos
Tipos Value
Tipos Simples
bool
char
sbyte
short
int
long
Enums
byte
float
ushort double
decimal
uint
ulong
Tipos Reference
Structs
Clases
Punteros
Interfaces Arrays Delegados
Tipos Definidos por el usuario
Todos los tipos son compatibles con object

- Pueden ser asignados a variables del tipo object
- Todas las operaciones del tipo object son aplicables a ellos

Benjamn Lpez Prez
OOTLab
OOTLab
Tipos Value vs. Tipos Reference

Tipos Value
Tipos Reference
variable contiene
almacenada en
inicializacin
asignacin
valor
stack
0, false, '\0'
copia el valor
referencia
heap
null
copia la referencia
ejemplo
int i = 17;
int j = i;
string s = "Hola";
string s1 = s;
17
s
Hola

17
s1
Benjamn Lpez Prez
OOTLab
OOTLab
Tipos Simples
sbyte
byte
short
ushort
int
uint
long
ulong
float
double
decimal
bool
char
Forma Larga
en Java
Rango
System.SByte
System.Byte
System.Int16
System.UInt16
System.Int32
System.UInt32
System.Int64
System.UInt64
System.Single
System.Double
System.Decimal
System.Boolean
System.Char
byte
--short
--int
--long
--float
double
--boolean
char
-128 .. 127
0 .. 255
-32768 .. 32767
0 .. 65535
-2147483648 .. 2147483647
0 .. 4294967295
-263 .. 263-1
0 .. 264-1
1.5E-45 .. 3.4E38 (32 Bit)
5E-324 .. 1.7E308 (64 Bit)
1E-28 .. 7.9E28 (128 Bit)
true, false
Carcter Unicode

Benjamn Lpez Prez
OOTLab
OOTLab
Compatibilidad entre Tipos Simples

decimal
double
Slo con
type cast
float
long
int
short
sbyte
ulong
uint
ushort
byte
char

Benjamn Lpez Prez
OOTLab
OOTLab
Enumeraciones
Lista de constantes con nombre
Declaracin (directamente en un namespace)
enum Color {rojo, azul, verde} // valores: 0, 1, 2
enum Acceso {personal=1, grupo=2, todos=4}
enum Acceso1 : byte {personal=1, grupo=2, todos=4}
Uso
Color c = Color.azul;
// ctes. de enumeracin deben de estar cualificadas
Acceso a = Acceso.personal | Acceso.grupo;

if ((Acceso.personal & a) != 0) Console.WriteLine("acceso autorizado");

Benjamn Lpez Prez
OOTLab
OOTLab
Operaciones con Enumeraciones

Comparar
+, ++, -&
|
~
if (c == Color.rojo) ...
if (c > Color.rojo && c <= Color.verde) ...
c = c + 2;
c++;
if ((c & Color.rojo) == 0) ...
c = c | Color.azul;
c = ~ Color.rojo;
El compilador no comprueba si el resultado es un valor de

enumeracin vlido.
Nota
Enumeraciones no pueden asignarse a int (excepto despus de un
type cast).
Tipos Enumeraciones heredan de object (Equals, ToString, ...).
La clase System.Enum proporciona operaciones para enumeraciones
(GetName, Format, GetValues, ...).
Benjamn Lpez Prez
OOTLab
OOTLab
Arrays
Arrays Unidimensionales
int[] a = new int[3];
int[] b = new int[] {3, 4, 5};
int[] c = {3, 4, 5};
UnaClase[] d = new UnaClass[10];
UnaStruct[] e = new UnaStruct[10];
// Array de referencias
// Array de valores (directam. en el array)
int long = a.Length; // numero de elementos en a

Benjamn Lpez Prez
OOTLab
OOTLab
Arrays Multidimensionales
Dentado (como en Java)
a[0][1]
int[][] a = new int[2][];

a[0] = new int[3];
a[1] = new int[4];
a[0]
a[1]
int x = a[0][1];
int len = a.Length; // 2
len = a[0].Length; // 3
Rectangular (ms compacto, acceso ms eficiente)

int[,] a = new int[2, 3];
a[0, 1]
int x = a[0, 1];

int len = a.Length;
// 6
len = a.GetLength(0); // 2
len = a.GetLength(1); // 3

Benjamn Lpez Prez
OOTLab
OOTLab
Clase System.String
Puede usarse como el tipo estndar string
string s = "Alfonso";
Nota
Strings son inmutables (usar StringBuilder para modificar strings)
Concatenar con +: "Don " + s
Indexar: s[i]
Longitud de String: s.Length
Strings son tipos reference => semntica de reference en asignaciones
Comparacin de valores con == y != : if (s == "Alfonso") ...
Clase String define varias operaciones tiles:
CompareTo, IndexOf, StartsWith, Substring, ...

Benjamn Lpez Prez
OOTLab
OOTLab
Structs
Declaracin
struct Punto {
public int x, y;
public Punto (int x, int y) { this.x = x; this.y = y; }
public void MoverA (int a, int b) { x = a; y = b; }
}
// campos
// constructor
// mtodos
Uso
Punto p = new Punto(3, 4);
p.MoverA(10, 20);

// constructor inicializa el objecto en el stack

// llamada a mtodo
Benjamn Lpez Prez
OOTLab
OOTLab
Clases
Declaracin
class Rectangulo {
Punto origen;
public int ancho, alto;
public Rectangulo() { origen = new Punto(0,0); ancho = alto = 0; }
public Rectangulo (Punto p, int an, int al) { origen = p; ancho = an; alto = al; }
public void MoverA (Punto p) { origen = p; }
}
Uso
Rectangulo r = new Rectangulo(new Punto(10, 20), 5, 5);
int area = r.ancho * r.alto;
r.MoverA(new Punto(3, 3));

Benjamn Lpez Prez
OOTLab
OOTLab
Diferencias entre Clases y Structs

Clases
Structs
Tipos Reference
(objetos almacenados en la heap)
Tipos Value
(objetos almacenados en el stack)
Soporta herencia
No tienen herencia
(todas las clases se derivan de object) (pero es compatible con object)
Pueden implementar interfaces
Pueden implementar interfaces
Pueden tener un destructor
No permiten destructores

Benjamn Lpez Prez
OOTLab
OOTLab
Boxing y Unboxing
Tipos Value (int, struct, enum) son compatibles con object tambin
Boxing
La asignacin
object obj = 3;
envuelve el valor 3 en un objeto heap

obj
3
Unboxing
La asignacin
int x = (int) obj;
desenvuelve el valor de nuevo

Benjamn Lpez Prez
OOTLab
OOTLab
Boxing/Unboxing
Permite la implementacin de contenedores genricos de tipos
class Cola {
...
public void Meter(object x) {...}
public object Sacar() {...}
...
}
Esta Cola puede usarse para tipos reference y tipos value

Cola q = new Cola();
q.Meter(new Rectangulo());
q.Meter(3);
Rectangulo r = (Rectangulo) q.Sacar();
int x = (int) q.Sacar();

Benjamn Lpez Prez
OOTLab
OOTLab
1.
2.
3.
4.
5.
6.
7.
Generalidades
Tipos
Expresiones
Declaraciones
Sentencias
Cdigo Inseguro
Operadores y sus Prioridades

Primario
Unario
Multiplicativo
Aditivo
Desplazam.
Relacional
Igualdad
AND Lgico
XOR Lgico
OR Lgico
AND Condicional
OR Condicional
Condicional
Asignacin
(x) x.y f(x) a[x] x++ x-- new typeof sizeof checked unchecked
+ - ~ ! ++x --x (T)x
* / %
+ << >>
< > <= >= is as
== !=
&
^
|
&&
||
c?x:y
= += -= *= /= %= <<= >>= &= ^= |=
Operadores del mismo nivel se evalan de izda. a dcha.

Benjamn Lpez Prez
OOTLab
OOTLab
Comprobacin de Overflow
Por defecto el Overflow no se comprueba
int x = 1000000;
x = x * x;
// -727379968, no error
La comprobacin de Overflow tiene que activarse

x = checked(x * x);
// System.OverflowException
checked {
...
x = x * x;
...
}
// System.OverflowException
La comprobacin de Overflow puede activarse en opciones del compilador

csc /checked Test.cs
Benjamn Lpez Prez
OOTLab
OOTLab
typeof y sizeof
typeof
Devuelve el descriptor del Type para un tipo dado.
(el descriptor del Type de un objeto o se obtiene con o.GetType()).
Type t = typeof(int);
Console.WriteLine(t.Name);
// Int32
sizeof
Devuelve el tamao en bytes de un tipo.
Slo se puede aplicar a tipos value.
Slo se puede utilizar en un bloque unsafe (el tamao de las structs
pueden depender del sistema).
Debera compilarse con csc /unsafe xxx.cs
unsafe {
Console.WriteLine(sizeof(int));
Console.WriteLine(sizeof(MiTipoEnum));
Console.WriteLine(sizeof(MiTipoStruct));
}
Benjamn Lpez Prez
OOTLab
OOTLab
1.
2.
3.
4.
5.
6.
7.
Generalidades
Tipos
Expresiones
Declaraciones
Sentencias
Cdigo Inseguro
Declaracin de Espacio
rea del programa a la que pertenece la declaracin
Las Entidades pueden ser declaradas en un...
ENTIDAD
DECLARACIN DE
-
namespace:
class, interface, struct:
enum:
bloque:
clases, interfaces, structs, enums, delegados

campos, mtodos, propiedades, eventos, indizadores, ...
enumeracin de constantes
variables locales
Reglas de mbito
- Un nombre no puede declararse dos veces en el mismo espacio de declaracin.
- Las Declaraciones pueden ocurrir en un orden arbitrario.
Excepcin: variables locales deben declararse antes de ser usadas
Reglas de Visibilidad
- Un nombre slo es visible dentro de su espacio de declaracin
(variables locales son visibles slo despus del punto de su declaracin).
- La visibilidad puede ser restringida por modificadores (private, protected, ...)

Benjamn Lpez Prez
OOTLab
OOTLab
Namespaces
Fichero: X.cs
namespace A {
... Classes ...
... Interfaces ...
... Structs ...
... Enums ...
... Delegates ...
namespace B { // nombre completo: A.B
...
}
}
Fichero: Y.cs
namespace A {
...
namespace B {...}
}
namespace C {...}
Namespaces con igual nombre en diferentes ficheros constituyen un

nico espacio de declaracin.
Namespaces anidados constituyen un espacio de declaracin dentro de
si mismo.

Benjamn Lpez Prez
OOTLab
OOTLab
Uso de otros Namespaces

Color.cs
namespace Util {
public enum Color {...}
}
Figuras.cs
namespace Util.Figuras {
public class Rect {...}
public class Circulo {...}
}
Triangulo.cs
namespace Util.Figuras {
public class Triangulo {...}
}
using Util.Figuras;
class Test {
Rect r;
// sin cualificacin (por el uso de Util.Figuras)
Triangulo t;
Util.Color c; // con cualificacin
}
Namespaces externos
Deben ser importados (ej. using Util;)
o especificarse el nombre cualificado (ej. Util.Color)
La mayora de los programas necesitan el namespace System =>
using System;
Benjamn Lpez Prez
OOTLab
OOTLab
Bloques
Varias clases de bloques
void foo (int x) {

// bloque de mtodo
... variables locales ...
{
// bloque anidado

}
for (int i = 0; ...) {
// bloque sentencias estructuradas
}
}
Nota
El espacio de declaracin de un bloque incluye los espacios de
declaracin de los bloques anidados.
Parmetros formales pertenecen al espacio de declaracin del bloque
del mtodo.
La variable de bucle en una sentencia for pertenece al bloque de esta.
La declaracin de una variable local debe ser anterior a su uso.
Benjamn Lpez Prez
OOTLab
OOTLab
Declaracin de Variables Locales

void foo(int a) {
int b;
if (...) {
int b;
// error: b ya declarada en el bloque exterior
int c;
// bien de momento, pero espera ...
int d;
...
} else {
int a;
// error: a ya declarada en un bloque exterior
int d;
// correcto: no hay conflicto con d del bloque anterior
}
for (int i = 0; ...) {...}
for (int i = 0; ...) {...} // correcto: no hay conflicto con i del bucle previo
int c;
// error: c ya declarada en este espacio de declaracin
}

Benjamn Lpez Prez
OOTLab
OOTLab
1.
2.
3.
4.
5.
6.
7.
Generalidades
Tipos
Expresiones
Declaraciones
Sentencias
Cdigo Inseguro
Sentencias Simples
Sentencia vaca
;
// ; es un terminador, no un separador
Asignacin
x = 3 * y + 1;
Llamada a mtodo
string s = "a,b,c";
string[] partes = s.Split(',');
// invoca un mtodo de objeto (no-esttico)
s = String.Join(" + ", partes);
// invoca un mtodo de una clase (esttico)

Benjamn Lpez Prez
OOTLab
OOTLab
Sentencia if
if ('0' <= ch && ch <= '9')
val = '0' - ch;
else if ('A' <= ch && ch <= 'Z')
val = 10 + 'A' - ch;
else {
val = 0;
Console.WriteLine(carcter invalido {0}", ch);
}

Benjamn Lpez Prez
OOTLab
OOTLab
Sentencia switch
switch (country) {
case "Germany": case "Austria": case "Switzerland":
language = "German";
break;
case "England": case "USA":
language = "English";
break;
case null:
Console.WriteLine("no country specified");
break;
default:
Console.WriteLine("don't know language of {0}", country);
break;
}
Tipo de la expresin switch

numrica, char, enum o string (null correcto como etiqueta case).
Terminacin de la case
Cada secuencia de sentencias en una casedebe terminarse con break
(or return, goto, throw).
Si no concuerda ninguna etiqueta case default
Si no se especifica default contina despues de la sentancia switch
Benjamn Lpez Prez
OOTLab
OOTLab
switch con Gotos

Ej. para la implementacin de un autmata
b
a
0
c
2
int estado = 0;
int ch = Console.Read();
switch (estado) {
case 0:
if (ch == 'a') { ch = Console.Read(); goto case 1; }
else if (ch == 'c') goto case 2;
else goto default;
case 1:
if (ch == 'b') { ch = Console.Read(); goto case 1; }
else if (ch == 'c') goto case 2;
else goto default;
case 2:
Console.WriteLine(entrada vlida");
break;
default:
Console.WriteLine(carcter illegal {0}", ch);
break;
}
Benjamn Lpez Prez
OOTLab
OOTLab
Bucles
while
while (i < n) {
suma += i;
++;
}
do while
do {
suma += a[i];
i--;
} while (i > 0);
for
for (int i = 0; i < n; i++)
suma += i;

Forma abreviada de
int i = 0;
while (i < n) {
suma += i;
i++;
}
Benjamn Lpez Prez
OOTLab
OOTLab
Sentencia foreach
Para iterar sobre colecciones y arrays
int[] a = {3, 17, 4, 8, 2, 29};
foreach (int x in a) suma += x;
string s = "Hola";
foreach (char ch in s) Console.WriteLine(ch);
Cola q = new Cola();
q.Sacar("John"); q.Sacar("Alice"); ...
foreach (string s in q) Console.WriteLine(s);

Benjamn Lpez Prez
OOTLab
OOTLab
Saltos
break;
Para salir de un bucle o sentancia switch.

No existe break con etiqueta como en Java (usar goto en su lugar).
continue;
Continua con la siguiente iteracin del bucle.
goto case 3:
Se usa en una sentencia switch para saltar a una etiqueta case
miLab:
...
goto miLab;
Salta a la etiqueta miLab.

Restriciones:
- no salta dentro de un bloque
- no salta fuera de un bloque de finalizacin de una sentencia try

Benjamn Lpez Prez
OOTLab
OOTLab
Sentencia return
Retorna de un mtodo void
void f(int x) {
if (x == 0) return;
...
}
Retorna un valor de un mtodo funcin

int max(int a, int b) {
if (a > b) return a; else return b;
}
class C {
static int Main() {
...
return CodigoError; // El mtodo Main puede ser declarado como una funcin;
}
// el cdigo de error devuelto puede ser revisado con
// variable errorlevel de DOS
}
Benjamn Lpez Prez
OOTLab
OOTLab
1.
2.
3.
4.
5.
6.
7.
Generalidades
Tipos
Expresiones
Declaraciones
Sentencias
Cdigo Inseguro
Contenidos de Clases o Estructuras

class C {
// para programacin orienta a objetos
... campos, constantes ...
... mtodos ...
... constructores, destructores ...
... propiedades ...
... eventos ...
// para programacin basada en componentes
... indizadores ...

... sobrecarga de operadores ...
... tipos anidados (clases, interfaces, structs, enums, delegados) ...
}

Benjamn Lpez Prez
OOTLab
OOTLab
Clases
class Stack {
int[] values;
int top = 0;
public Stack(int size) { ... }
public void Push(int x) {...}
public int Pop() {...}
}
Objetos se almacen en la heap (las clases son referencias a tipos)

Objetos deben ser creados con new
Stack s = new Stack(100);
Las clases pueden heredar de una clase (herencia nica de cdigo)

Las clases pueden implementar mltiples interfaces (herencia de tipos
mltiple)

Benjamn Lpez Prez
OOTLab
OOTLab
Structs
struct Punto {
int x, y;
public Punto(int x, int y) { this.x = x; this.y = y; }
public MoverA(int x, int y) {...}
}
Structs son almacenados en la stack no en la heap (structs son tipos value)

+ eficiente, menor consumo de memoria, no son liberados por el recolector de
basura.
- existen mientras lo haga su contenedor
(no adecuados para estructuras de datos dinmicas)
Pueden ser creados con new
Punto p;
Point q = new Punto();
// los campos de p no se inicializan
Los campos deben ser inicializados en su declaracin

struct Punto {
int x = 0;
}
// error de compilacin
No pueden ser declarados constructores sin parmetros

No pueden heredar ni ser heredados, pero pueden implementar interfaces

Benjamn Lpez Prez
OOTLab
OOTLab
1.
2.
3.
4.
5.
6.
7.
Generalidades
Tipos
Expresiones
Declaraciones
Sentencias
Cdigo Inseguro

Benjamn Lpez Prez
OOTLab
OOTLab
Cdigo Inseguro
1.
2.
3.
4.
5.
6.
7.
Conceptos bsicos
Compilacin de cdigo inseguro
Marcacin de contextos inseguros
Definicin de punteros
Manipulacin de punteros
Operadores de cdigo inseguro
Fijacin de objetos en memoria

Benjamn Lpez Prez
OOTLab
OOTLab
Conceptos bsicos
Puntero: Variable que almacena una
direccin de memoria. NO deriva de
System.Object
Cdigo inseguro: El que usa punteros. Se
marca con unsafe

Benjamn Lpez Prez
OOTLab
OOTLab
Compilacin de cdigo inseguro

Compilacin en lnea de comandos:
csc cdigoInseguro.cs /unsafe
Compilacin con Visual Studio.NET:
View Property Pages

Configuration options Build Allow
unsafe code blocks
Benjamn Lpez Prez
OOTLab
OOTLab
Marcacin de contexto inseguro

Mtodo 1: Marcacin de bloque inseguro
Sintaxis: unsafe <instrucciones>
Ejemplo: class A
{
public static void Main()
{
unsafe { int * a;}
}
}

Benjamn Lpez Prez
OOTLab
OOTLab

Mtodo 2: Marcacin de miembro inseguro

Sintaxis: unsafe <miembro>
Ejemplo: class A
inocuo
{
public unsafe int * X;
public unsafe int * Y;
public static unsafe void Main()
{
int * a;
}
}
Benjamn Lpez Prez
OOTLab
OOTLab

Mtodo 3: Marcacin de tipo
inseguro
Sintaxis: unsafe <tipo>
Ejemplo: unsafe class A
{
public int * X;
public int * Y;
public static void Main() {
int * a;
}
}
Benjamn Lpez Prez
OOTLab
OOTLab
Definicin de punteros
Sintaxis bsica: <tipo> * <nombre>;
Ejemplos:
int * pi;
int *pi, pj; // Ambos son int *
int[ ] * pTabla;
int ** punteroApuntero;
void * pCualquierCosa;
Notas:
<tipo> almacenable en pila completo
Campos slo admiten multidefinicin si se aplica
unsafe globalmente al tipo al que pertenezcan
null por defecto
Benjamn Lpez Prez
OOTLab
OOTLab
Manipulacin de punteros (operador &)

Significado:
Sintaxis:
Ejemplos:
Obtiene direccin de objeto

&<objeto>
int x = 10;
int * px = &x;
px = &x;
Notas:
Admite variables no inicializadas
No admite constantes ni variables readonly
Benjamn Lpez Prez
OOTLab
OOTLab
Manipulacin de punteros (operador *)

Significado:
Sintaxis:
Ejemplos:
Obtiene contenido apuntado

*<puntero>
int x = 10;
int * px = &x;
Console.WriteLine(*px);
Notas:
No admite punteros void *
No admite punteros a null. SUELE producir
System.NullReferenceException
Benjamn Lpez Prez
OOTLab
OOTLab
Manipulacin de punteros (operador ->)

Significado:
Sintaxis:
Ejemplos:
Llama a miembros apuntado

<puntero>-> <miembro>
DateTime d = DateTime.Now;
DateTime * p = &d;
Console.Write(d->Year); // 2001
Notas:
No admite punteros null ni void * (se basa en *)
Equivalente P->M a (*P).M

Benjamn Lpez Prez
OOTLab
OOTLab
Manipulacin de punteros (operadores
relacionales e =)
Operador =: Asigna direcciones

Operadores <,>,>=,<=,==,!=: Comparan direcciones
Ejemplo:
int x = 10, y = 10;
int * px = &x,* py = &y;

Console.Write(px==py);
px = py;
*px = 11;
Console.Write(px==py);
Console.Write(*py);

// False
//True;
// 11
Benjamn Lpez Prez
OOTLab
OOTLab
Manipulacin de punteros (aritmtica de punteros)

Operadores +,-,++,--: Incrementan o decrementan
direcciones segn tamao puntero.
Operador []: P[i] equivale a *(P+i)
Ejemplos:
// p apunta a tabla de 100 enteros
for (int i=0; i<100; i++)
Console.Write((*p)++);
for (int i=0; i<100; i++)
Console.Write(*(p+i));
for (int i=0; i<100; i++)
Console.Write(p[i]);

Benjamn Lpez Prez
OOTLab
OOTLab
Manipulacin de punteros (conversiones)

Entre punteros vale cualquiera explcita
void * lo almacena todo (object de punteros)
Entre enteros refieren a direcciones memoria
Ejemplos:
int * pi = (int *) 2 ;
void * pv= pi;
char * pc = (char *) pv;
Console.WriteLine((long) pc);

Benjamn Lpez Prez
OOTLab
OOTLab
Operadores de cdigo inseguro (sizeof)

Significado:
int con n de bytes del operando
Sintaxis:
sizeof(<tipoPuntero>)
Notas:
Optimizado para tipos constantes
Incluye
padding
Tipo
byte, byte, bool
short, ushort, char
int, uint, float
long, ulong, double
Resultado
1
2
4
8
Benjamn Lpez Prez
OOTLab
OOTLab
Operadores de cdigo inseguro (stackalloc)

Significado: reserva espacio en pila y devuelve
puntero a su comienzo
Sintaxis: stackalloc <tipo>[<tamao>]
Ejemplo: int * pt = stackalloc int[100];
Notas:
NO crea tablas
No inicializa memoria
Slo para inicializar punteros locales
No hay memoria -> System.StackOverflowException
Cdigo: stackalloc.cs

Benjamn Lpez Prez
OOTLab
OOTLab
Ejemplo stackalloc.cs en lnea

class Stackalloc
{
public unsafe static void Main()
{
int * pt = stackalloc int[100];
for (int i=0; i<100; i++)
pt[i] = i;
for(int i=0; i<100; i++)
System.Console.WriteLine(pt[i]);
}
}

Benjamn Lpez Prez
OOTLab
OOTLab
Fijacin de objetos en memoria

Problema: Al apuntar a objetos en memoria
dinmica (campos de clases, statics, tablas)
no debera moverlos el recolector de basura.
Solucin: Fijarlos con fixed
Problema: Ralentiza creacin y destruccin
de objetos
Solucin: Usar fixed lo mnimo imprescindible
Benjamn Lpez Prez
OOTLab
OOTLab
Fijacin de objetos en memoria (fixed)

Sintaxis: fixed(<tipo> <declaraciones>)
<instrucciones>
Significado: Fija direcciones de inicializacin de
punteros de declarados en <declaraciones>
durante la ejecucin del bloque de <instrucciones>
Notas:
Permite apuntar a tablas
Los punteros fijados no pueden modificarse
No fija direcciones nulas (NullReferenceException)
Slo un <tipo>, pero se permite anidamiento
Benjamn Lpez Prez
OOTLab
OOTLab
Fijacin de objetos en memoria (ejemplo fixed)

class Ejemplo
{
public static unsafe void Main() {
int[] tOrigen = new int[100], tDestino = new int[100];
fixed (int * pOrigen = tOrigen, pDestino=tDestino)
{
for (int i=0;i<100;i++)
pDestino[i] = pOrigen[i];
}
}
}
Cdigo: fixed.cs

Benjamn Lpez Prez
OOTLab
OOTLab
Resumen de C#
Familiar
Seguro
Fuertemente tipado
Comprobaciones en
tiempo de ejecucin
Control de versiones

Expresivo
Orientado a objetos (clases, interfaces, ...)
Orientado a componentes (propiedades,
eventos, ensamblados, ...)
Sistema de tipos uniforme (boxing /
unboxing)
Enumeraciones
Delegados
Indizadores
Parmetros ref y out
Value objects en el stack
Threads y sincronizacin
Excepciones
Atributos definidos por el usuario
Reflexin
...
Benjamn Lpez Prez
OOTLab
OOTLab
Caractersticas Generales de C#
presentacin
FinFin
dedelalapresentacin

Benjamn Lpez Prez
OOTLab
OOTLab

2 CsCaracteristicasGenerales PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

2 CsCaracteristicasGenerales PDF

Cargado por

Copyright:

Formatos disponibles

Cursos de Verano 2002

Cursos de Verano 2002

Origen y necesidad de un nuevo lenguaje

Especfico para .NET

Sintaxis de C/C++/Java con facilidad de VB

Cursos de Verano 2002

De base soporta propiedades, atributos y eventos

Gestin automtica de memoria

Cursos de Verano 2002

Slo condiciones lgicas

Sistema de tipos unificados

Clase padre comn System.Object

Redefiniciones inteligentes y consistentes

Extensibilidad de tipos bsicos

Posibilidad de paso por referencia para eficiencia

Cursos de Verano 2002

Con funciones nativas (ej: Win32) con Pinvoke

Cursos de Verano 2002

Cursos de Verano 2002

Orientacin a Objetos (herencia

Cursos de Verano 2002

Programacin basada en componentes

Referencias y parametros de salida

Cursos de Verano 2002

utiliza el namespace System

Cursos de Verano 2002

Estructura de los Programas en C#

Si no se especifica namespace => namespace por defecto annimo

Un Programa formado por 2 Ficheros

Trabajando con DLLs

Sistema de tipos Unificado

Interfaces Arrays Delegados

Tipos Definidos por el usuario

Todos los tipos son compatibles con object

Cursos de Verano 2002

Tipos Value vs. Tipos Reference

Cursos de Verano 2002

Cursos de Verano 2002

Compatibilidad entre Tipos Simples

Cursos de Verano 2002

// ctes. de enumeracin deben de estar cualificadas

Acceso a = Acceso.personal | Acceso.grupo;

Cursos de Verano 2002

Operaciones con Enumeraciones

El compilador no comprueba si el resultado es un valor de

int long = a.Length; // numero de elementos en a

Cursos de Verano 2002

int[][] a = new int[2][];

Rectangular (ms compacto, acceso ms eficiente)

int x = a[0, 1];

Cursos de Verano 2002

Cursos de Verano 2002

Cursos de Verano 2002

// constructor inicializa el objecto en el stack

Cursos de Verano 2002

Diferencias entre Clases y Structs

Pueden implementar interfaces

Pueden tener un destructor

Cursos de Verano 2002

envuelve el valor 3 en un objeto heap

desenvuelve el valor de nuevo

Cursos de Verano 2002

Esta Cola puede usarse para tipos reference y tipos value