Net Framework 7263v

int x; char letra; string mensaje; Object obj;  Asimismo podemos inicializar una variable asignándole un valor. int x = 45; string mensaje = “Hola”; Object obj = new Object()  En función de donde se localice una variable, puede ser de tres tipos:  Atributo. Se hallan dentro de la definición de una clase, es decir, de un objeto. Son permanentes hasta la destrucción de dicho objeto  Variable local. Se hallan dentro de un método. Se destruyen al finalizarlo.  Parámetro. Sólo pueden usarse dentro del método donde actúan.

32

Sintaxis básica Constantes  Una constante es una variable cuyo valor nunca varía y en consecuencia el compilador lo conoce de antemano y optimiza.  Las constantes se declaran al igual que las variables pero añadiendo la palabra const en su declaración y siempre asignándolas un valor. const double pi = 3.141596;  Las constantes son implícitamente estáticas.

33

Sintaxis básica Variables de sólo lectura  Debido a que las constantes son muy rígidas, C# permite declarar variables de sólo lectura, es decir, que nunca pueden ser sobrescritas.  Se declaran como variables añadiendo la palabra readonly.  No hace falta asignarles un valor directamente, pero entonces sólo se puede hacerlo en los constructores de los objetos.  El valor que almacenan se puede calcular en tiempo de ejecución

34

Sintaxis básica Operadores  Un operador es un símbolo formado por uno o más caracteres que permite realizar una determinada operación entre uno o más datos y produce un resultado.  Operadores aritméticos  Unarios: negativo (-) y positivo (+)  Binarios: suma (+), resta (-), producto (*), división (/) y módulo (%)  checked( [<expresiónAritmética>] ) y unchecked( [<expresiónAritmética>] ): calcula el resultado de expresiónAritmética y evalúa si se produce desbordamiento. En caso afirmativo se producen las siguientes situaciones:  Si es checked, se lanza un error de compilación si se tratan de constantes o una excepción en tiempo de ejecución de tipo System.OverflowException si son variables.  Si es unchecked, se trunca el resultado.

35

Sintaxis básica Operadores  Operadores lógicos  Unarios: not (!)  Binarios perezosos (no evalúan la condición cuando se deduce el resultado de un operando): and (&&), or (||) y xor (^^).  Binarios no perezosos (evalúan toda la condición): and (&), or (|) y xor (^)  Operadores relacionales  Igualdad (==), desigualdad (!=), mayor que (>), menor que (<), mayor o igual que (>=) y menor o igual que (<=).  Operadores de manipulación de bits  And (&), or (|), not (~), xor (^), desplazamiento hacia la izquierda N posiciones (<< ) e ídem hacia la derecha (>> )

36

Sintaxis básica Operadores  Operadores de asignación  El operador básico es (=) que, a parte de asignar, devuelve el valor asignado. La asignación es asociativa por la derecha.  Operadores compuestos: realizan una operación y asignan el resultado. Existen para la suma (+=), resta (-=), producto (*=), división (/=), módulo (%=), las operaciones bit a bit de and (&=), or (|=), xor (^=) y los desplazamientos de bits (<<= y >>=)  Operadores incrementales: realizan un incremento (++) o decremento (--) de una unidad en una variable. Si el operador se coloca antes del nombre de la variable devuelve el valor de la variable antes de incrementarla; si se hace después, se incrementa y devuelve el valor ya incrementado

37

Sintaxis básica Operadores Ejemplos de asignación: a = 56; //asign. básica b = 78 + a; //asign. básica c += 23; //asign. compuesta. Equivale a c i++; //Incremento. Equivale a i = i + d = i++; //Asigna e incrementa. Si i vale inicio, d vale 3. d = ++i; //Incrementa y asigna. Si i vale inicio, d vale 4

= c + 23 1 3 al 3 al

38

Sintaxis básica Operadores  Operadores con cadenas  Se usa (+) para concatenar (unir) cadenas. Se pueden concatenar cadenas con caracteres.  Ejemplo: “Hola” + “ Mundo” y “Hola Mund” + „o‟ devuelven “Hola Mundo”  Operadores de a objetos  Para acceder a los de un objeto se usa el operador punto (.) entre el nombre del objeto y el nombre del miembro.

39

Sintaxis básica Operadores  Operadores de conversión de tipos  Se usa (( ) <expresion>) seguido de una expresión para transformar ésta en el tipo que se halla encerrado entre paréntesis.  También se puede usar <expresion> as para tal acometido.  Las conversiones de tipos de menor capacidad a otros de mayor (por ejemplo, byte  int o int  long) son implícitas y no son necesarios operadores.  Ejemplos: int i = 4; double d = 8; d = i; //conversión implícita porque double es //más amplio que int i = (int)d; //conversión explícita. Se trunca valor. i = d as int //conversión explícita

el

40

Sintaxis básica Operadores  Operador condicional  Es el único de C# con tres operandos, cuya sintaxis es: ? <expresión1> : <expresión2>  Se evalúa . Si es cierta se devuelve el resultado de evaluar <expresión1> y si es falsa, <expresión2>  Ejemplo: max = (a>b)?a:b; pregunta si a es mayor que b y devuelve a en caso afirmativo y b en caso contrario.  No confundirlo con una sentencia if…else ya que el operador condicional siempre devuelve un valor, pero if…else no (aunque se puede usar de forma similar).  Es un operador asociativo por la derecha: a?b:c?d:e equivale a a?b:(c?d:e)

41

Sintaxis básica Control de flujo Sentencia condicional if if( ){ }else { } Ejemplo: if(a > b){ Console.WriteLine(“A gana”); } else { Console.WriteLine(“B gana”); }

if( ){ } else if( ) { } //N condiciones else if…

}

else if( ){ } else { }

42

Sintaxis básica Control de flujo Sentencia condicional switch - case switch(<expresión>){ case : break; case : break; //N valores… case : break; default: }

Ejemplo: switch(estado){ case 0: Console.WriteLine(“Estoy triste”); break; case 1: Console.WriteLine(“Estoy serio”); break; case 2: Console.WriteLine(“Estoy feliz”); break; default: Console.WriteLine(“No estoy”); } 43

Sintaxis básica Control de flujo Sentencias iterativas while y do - while while( ){ }

do{ while( );

Ejemplo:

Ejemplo:

int a = 10;

char c = „\0‟;

while(a > 0){ Console.WriteLine(a); a--; }

Do{ c = Console.Read(); }while(c != „q‟);

44

Sintaxis básica Control de flujo Sentencias iterativas for y foreach for(<declaración>; ; ){ }

foreach( in <array o colección>){ }

Ejemplo:

Ejemplo:

int[] v = {4,7,9,1,5,0};

int[] v = {4,7,9,1,5,0};

for(int i = 0; i < v.Length; i++){ Console.WriteLine(v[i]); }

foreach(int a in v){ Console.WriteLine(a); }

45

índice 1. ¿Qué es .NET Framework?

12. Uso de excepciones

2. Orígenes de C#

13. Estructuras de datos

3. Características de C#

14. Ficheros y Streams

4. Sintaxis básica

15. Multitarea en C#

5. Arrays

16. ADO.NET

6. Clases, objetos y constructores

17. Patrones de diseño

7. Interfaces

18. ASP.NET

8. Métodos, propiedades, eventos y delegados

19. AJAX

9. Estructuras y enumeraciones

21. Windows Comunication Foundation

10. Espacios de nombres

22. Enterprise Library

20. LINQ

11. Redefinición de operadores e indizadores 46

Arrays Conceptos y declaración  Una array es un conjunto ordenado de objetos del mismo tipo y tamaño fijo. Se trata como un objeto.  Se declara con la siguiente sintaxis: [] <nombreArray>;  Ejemplo: un array que almacenase enteros se declararía así int[] miArray;  No obstante, este array no almacena nada ya que su valor es null. Si se desea de verdad que almacene objetos hay que indicar cuál es su tamaño (cuántos objetos podrá almacenar), que se hace con la siguiente sintaxis: [] <nombreArray> = new [ ] int[] miArray = new int[50];

47

Arrays Conceptos y declaración  En el ejemplo anterior, todas las posiciones se inicializan al valor por defecto de cada tipo de datos (0 en el caso de enteros). Si queremos dar un valor a cada posición, hemos de usar la siguiente sintaxis: [] <nombreArray> = new []{valores} int[] miArray = new int[]{1,7,3,0}; Int[] miArray = {1,7,3,0};  Los arrays no pueden ser redimensionados.  Al declarar el tamaño de un array, se puede usar cualquier expresión avaluada como entera, no hace falta que sea un valor numérico constante. int n = 4; int[] miArray = new int[n+6];

48

Arrays a elementos  Se usa [<posiciónElemento>] detrás del identificador de array para acceder al elemento contenido en esa posición.  ¡Cuidado! En C#, los arrays se indizan desde 0, es decir, el primer elemento es el 0 y el último el N-1 vec[0] devuelve el primer elemento vec[9], devuelve el décimo elemento y vec[i], el i-1ésimo.  Hay que ir con precaución al acceder a los elemento de un array. Si se especifica una posición superior al número de elementos del array se lanza una excepción del tipo System.OutOfBoundsException.  Para saber el tamaño de un array, basta con consultar el atributo Length de éste. miArray.Length

49

Arrays Arrays dentados  Una array dentado es un array cuyos elementos son a su vez arrays.  Se pueden anidar tantos niveles de arrays como se desee, añadiendo corchetes por cada nuevo nivel.  No es necesario que cada array tenga el mismo tamaño que los demás.  Ejemplos de declaración y : int[][] miArray = new int[2][]; int[][] miArray = new int[2][]{new int[]{1,2},new int[]{3,4,5}} int[][] miArray = new int[][]{new int[]{1,2},new int[]{3,4,5}} int[][] miArray = {new int[]{1,2}, new int[]{3,4,5}} miArray [2][6] = miArray [i+2][3]  No se permite especificar el tamaño de cada dimensión en la declaración del array. Así la siguiente declaración no está permitida: int[][] miArray = new int[3][4]; 50

Arrays Arrays multidimensionales  Un array multidimensional es un array cuyos elementos se encuentran organizados siguiendo una estructura de varias dimensiones.  Se declaran de forma parecida a los de una sola dimensión, pero separando las dimensiones con comas (,). No es obligatorio indicar el tamaño en la declaración int[,] miArray; int[,] miArray = new int[3,4];  También podemos indicar en la declaración los elementos del array int[,] miArray = new int[3,3]{{1,2,3},{4,5,6},{7,8,9}}; int[,] miArray = {{1,2,3},{4,5,6},{7,8,9}};  El a un elemento se realiza indicando los índices miArray [1,2] = 45;

51

Arrays Arrays mixtos  Los arrays mixtos son arrays formados por la combinación de los arrays anteriormente citados.  Para declararlos y manipularlos basta solo combinar las notaciones ya vistas para los dentados y los multidimensionales.  Así declarar un array de arrays multidimensionales cuyos elementos son arrays simples de enteros sería así: int[][,][] miArray;

52

Arrays La clase System.Array  Todo array que definamos hereda directamente de System.Array y en consecuencia, dispone de los métodos y atributos definidos para esta clase.  Atributo Length  Atributo de sólo lectura que indica el número actual de elementos que contiene un array.  Si el array tiene más de una dimensión y/o nivel de anidación, Length indica el número total de elementos de todas sus dimensiones y niveles. int array[] = {1,2,3,4}; // Length = 4 int array[][] = {new int[]{1,2},new int[]{3,4,5}}; //Length = 5 int array[,] = {{1,2}, {3,4,5,6}}; //Length = 6

53

Arrays La clase System.Array  Atributo Rank  Atributo de sólo lectura que indica el número de dimensiones del array.  Obviamente, si el array no es multidimensional, vale 1. int array[] = {1,2,3,4}; // Rank= 1 int array[][] = {new int[]{1,2},new int[]{3,4,5}}; //Rank= 1 int array[,] = {{1,2}, {3,4,5,6}}; //Rank= 2  Método GetLength(int dimension)  Devuelve el número de elementos de la dimensión especificada.  Las dimensiones empiezan a contarse desde cero int array[,] = {{1,2}, {3,4,5,6}}; array.GetLength(0); //devuelve 2 array.GetLength(1); //devuelve 4

54

Arrays La clase System.Array  Método CopyTo(Array destino, int posición)  Copia todos los elementos del array origen en el de destino a partir de la posición pasada como parámetro.  Los dos arrays han de ser unidimensionales y no han de valer null.  EL array de destino ha de ser de un tipo compatible con el array origen.  El índice posición ha de estar dentro del rango de posiciones del array.  Si no se respetan estas restricciones, saltan diversas excepciones. int array1[] = {1,2,3,4}; int array2[] = {5,6,7,8}; array1.CopyTo(tabla2,0); //array2 := {1,2,3,4}  A parte de estos métodos, la clase System.Array dispone de otros métodos útiles tales como ordenaciones, búsquedas, etc.

55



2. Orígenes de C#




4. Sintaxis básica


5. Arrays

16. ADO.NET



7. Interfaces

18. ASP.NET


19. AJAX





20. LINQ


Clases, objetos y constructores Conceptos básicos  Un objeto es un agregado de datos y métodos que permiten manipular dichos datos.  Los programas son conjuntos de objetos que interactúan los unos con los otros.  Una clase es la definición de las características concretas de una determinada tipología de objetos. Es decir, cuáles son los datos y métodos de los que van a disponer todos los objetos de ese tipo  Hablar de clases equivale a hablar de tipos de datos.  Al ser C# un lenguaje orientado a objetos puro, siempre se trabaja con objetos y clases

57

Clases, objetos y constructores Sintaxis y definición class <nombreClase> { <> }  Los <> de una clase son los datos y métodos de los que van a disponer los objetos de la misma.  Ejemplo class MiClase { int a; double b; //más datos y métodos… }  En C# hay varios tipos de , pero ahora sólo vamos a considerar los atributos y los métodos.

58

Clases, objetos y constructores Atributos  Un atributo es un dato común a todos los objetos de una determinada clase. Se deben definir en la zona de declaración de y tienen la siguiente sintaxis: <nombreatributo>  Donde es un tipo simple u otro objeto y <nombreatributo> un identificador válido.  Ejemplo: class Persona { string Nombre; int Edad; string NIF; }

59

Clases, objetos y constructores Atributos  Para acceder a un atributo se utiliza la siguiente sintaxis: <nombreObjeto>.<nombreatributo>  Por ejemplo, para acceder al atributo Edad de un objeto Persona llamado p y cambiar su valor por 20 sería: p.Edad = 20;  En realidad <nombreObjeto> no tiene por qué ser necesariamente el identificador de un objeto. Una expresión que devuelva un referencia no nula de un objeto también es válida (en caso contrario se produciría una excepción).

60

Clases, objetos y constructores Atributos  Se puede inicializar un atributo en el momento de su declaración a través de una asignación: int valor = 9;  Si no se da un valor, el compilador asigna automáticamente un valor por defecto al atributo. Esto es debido a que C# no permite dejar atributos sin inicializar por motivos de seguridad.  Valores por defecto de C#: Enteros

0

Caracteres

„\0‟

Decimales

0.0

Cadenas

null

Lógicos

false

Objetos

null

61

Clases, objetos y constructores Métodos  Un método es un conjunto de instrucciones encapsuladas a las que se asocia un nombre. Se deben definir en la zona de declaración de y tienen la siguiente sintaxis: <nombreMétodo> ([<parámetros>]) {

}  Cada vez que se quieran ejecutar, basta con referenciarlas a través de dicho nombre en vez de tener que reescribirlas.  Dentro de un método es posible acceder con total libertad a los atributos de la clase donde está definido el método  Es preciso señalar que en C# los literales se tratan como objetos y como tales podemos invocar métodos sobre ellos.

62

Clases, objetos y constructores Métodos y parámetros  Los métodos pueden devolver un objeto como resultado de las instrucciones ejecutadas y el tipo de dato a devolver ha de ser el mismo que el indicado en . Si no se ha de devolver nada, se indica void, pero si se devuelve algo es obligatorio incluir la sentencia return al finalizar el método.  Opcionalmente pueden recibir un listado de objetos, <parámetros>, a los que podrá acceder durante la ejecución de las instrucciones. Al declarar un parámetro se ha de indicar el tipo y un nombre identificador.  Ejemplo: int maximo (int a, int b){ return a > b ? a : b; }

63

Clases, objetos y constructores Atributos estáticos  Un atributo estático de una determinada clase es un atributo cuyo valor es el mismo para todos los objetos de la clase, es decir, compartido para cualquier objeto que pertenezca a esta clase.  En consecuencia, estos atributos no están asociados a un objeto concreto sino a la clase en sí misma.  Se declaran como cualquier otro atributo pero añadiendo la palabra static al inicio: static int numero;  Los s a atributos estáticos son un poco diferentes respecto de los normales ya que en vez especificar el objeto hay que especificar la clase del objeto: int a = MiClase.numero;

64

Clases, objetos y constructores Métodos estáticos  El concepto y uso de métodos estáticos es análogo al de los atributos: son operaciones a nivel de clase.  Se declaran anteponiendo la palabra static antes del nombre del método.  Como son operaciones de clase, no pueden usarse atributos ni métodos no estáticos ya que estos corresponden a un objeto concreto.  Dentro de un método, todo miembro estático puede ser escrito directamente, sin anteponer el nombre de la clase. class C { static int a; int b; static void f(){ a = 6; //Sí! b = 4; //No! Estamos accediendo a un atributo no estático } } 65

Clases, objetos y constructores Uso de la palabra reservada this  Dentro de cualquier método de un objeto siempre es posible hacer referencia al propio objeto usando la referencia this.  Su uso principal es el de resolver ambigüedades cuando un parámetro u otro elemento tiene el mismo nombre que un atributo. class C { int a; C(int a){ a = a; parámetro this.a = a; } }

//No!

Ambigüedad

entre

atributo

y

//Ok!

66

Clases, objetos y constructores Concepto de constructor  Un constructor de un tipo de datos o clase es un método especial que contiene las instrucciones a ejecutar cada vez que se cree un nuevo objeto de ese tipo.  Se usan para tareas como inicialización de atributos sobre todo cuando éstos no son constantes o se requieren operaciones más complejas como aperturas de ficheros, a redes, etc.  Siempre se ejecutan después de haberse inicializado todos los atributos (de forma explícita o implícita a través de valores por defecto).  Tienen un gran diferencia respecto el resto de métodos: no se heredan.  Los constructores no devuelven el objeto en sí mismo, sino una referencia a él.

67

Clases, objetos y constructores Sintaxis de constructor  Los constructores tienen una sintaxis muy parecida a los métodos, salvo que el nombre ha de ser el mismo que el de la clase y nunca tienen valor de retorno (ni void): <nombreTipo> ([<parámetros>]) { }  Ejemplo: Persona(string Nombre){ //instrucciones… }  Al constructor se le llama en el momento de creación del objeto usando la directiva new: Persona p = new Persona();

68

Clases, objetos y constructores Sobrecarga y llamadas entre constructores  Se pueden definir varios constructores para una clase siempre y cuando difieran en número de parámetros y/o en tipos (por ejemplo no podemos tener dos constructores cuyos parámetros sean int e int respectivamente).  También se pueden realizar llamadas desde un constructor a otros constructores usando la partícula this(…) tras la definición del constructor: class A { A (int altura): this(altura,0.0){…} //llamamos al segundo constructor A (int altura, double peso){…} }  Si en vez de llamar a un constructor propio de la clase lo queremos hacer de su clase padre, hemos de usar base en vez de this.

69

Clases, objetos y constructores Constructor por defecto  Todas las clases deben tener constructor.  En caso que el programador no defina uno, el compilador crea uno por defecto con la siguiente signatura: public <nombreClase>():base(){}  Si el programador define un constructor, el compilador ignora añadir el constructor por defecto, por lo que se recomienda añadirlo manualmente en este caso.  Mucho cuidado con los temas de herencia dentro de los constructores. Dejar que una subclase tenga constructor por defecto y su clase base no, daría un error de compilación.

70

Clases, objetos y constructores Constructor de tipo  El constructor de tipo es similar a los normales, salvo que se usa en el ámbito estático. En su definición debe incluir el modificador static: static <nombreTipo>() { }  Estos constructores se llaman cuando la CLR carga por primera vez en memoria la información de la clase.  Destacar que no debe tener ningún parámetro ni inicializador

71

Clases, objetos y constructores Concepto de destructor  El destructor es un método sin parámetros que se invoca en el momento anterior a que el recolector de basura lo destruya y libere la memoria que ocupaba. Es útil para liberar recursos tales como ficheros o conexiones a bases de datos.  Sólo se llama cuando se detecta que no existen referencias a ese objeto ni en la pila, ni en memoria ni dentro de otros objetos.  Su sintaxis es la siguiente: ~ (){ }  Los destructores se ejecutan en cadena, es decir, tras la ejecución del destructor se ejecuta el de la clase base.  Si el programador no especifica uno, el compilador se encarga de crear uno por defecto

72



2. Orígenes de C#




4. Sintaxis básica


5. Arrays

16. ADO.NET



7. Interfaces

18. ASP.NET


19. AJAX





20. LINQ


Interfaces Concepto de interfaz  Una interfaz (o interface) es la definición de un conjunto de métodos u otros para los que no se da una implementación.  Su sintaxis es casi similar a la de una clase: <modificadores> interface <nombre>: { <> }  Una interfaz equivale a una clase abstracta cuyos métodos son todos abstractos y deben ser implementados en sus subclases.  La diferencia entre definir una interfaz y una clase abstracta con métodos abstractos radica en que las interfaces permiten herencia múltiple.

74

Interfaces Definición de una interfaz  Sólo se permiten declarar métodos, propiedades, indizadores y eventos. No se permiten ni atributos, ni constructores, ni destructores ni operadores.  Implícitamente, los se declaran como public y abstract. Por lo tanto el resto de modificadores no se permiten (tampoco static) salvo new (en el caso que se quiera ocultar la definición de la interfaz padre).  Las interfaces no iten estáticos. public interface IfaceA { int propiedad{get;} void comun(int x); } public interface IFaceB { int this[int i]{get; set;} void comun(int x); }

75

Interfaces Herencia  Cada interfaz puede heredar de varias interfaces (que se indicarían en la zona de herencia separadas entre comas) pero nunca de clases o estructuras.  Las clases también pueden heredar de varias interfaces junto con su clase padre.  Hay que asegurar entonces que se redefinen todos los declarados en las interfaces y declararlos como públicos (no hace falta usar el modificador override).  Se pueden usar los modificadores abstract y virtual en la redefinición de heredados de interfaz. Esto implicaría una redefinición en las clases hijas con la partícula override.

76

Interfaces Herencia public interface IfaceA { int A(); //No lleva public ni abstract (implícitos) } public interface IfaceB { int B(); } public class Cls: IfaceA, IfaceB { //Implem. de A. No lleva override (implícito) public int A(){ return 3; } //Implem. De B. Puede llevar virtual. public virtual int B(){ return 8; } }

77

Interfaces a  Se puede acceder a los de una interfaz implementados en una clase de la misma manera que accederíamos a los propios de la clase. Retomando el ejemplo anterior: Cls miCls = new Cls(); int k = miCls.A();  También es posible definir variables de tipo interfaz. Aunque no existen constructores, se pueden inicializar a través del polimorfismo. IfaceB ifB = new Cls();//Permitido porque Cls hereda de IfaceB int k = ifB.B();  A través de estas variables sólo se pueden acceder a los definidos en la interfaz, no aquellos otros definidos en la clase.

78

Interfaces Implementación explícita  Cuando una clase hereda de dos o más interfaces con un mismo miembro (por ejemplo, un método con mismo nombre y parámetros), su implementación valdrá para las todas las interfaces.  Sin embargo, también es posible dar una implementación diferente para cada una usando una notación explícita:  Se antepone al nombre el nombre de la interfaz seguido de punto (.).  No debe llevar el modificador public ni tampoco virtual ni abstact.  Para acceder a los implementados como explícitos en una clase no se puede acceder a través de un objeto de tipo clase, sino que se debe hacer como objetos de la interface. Así se deshacen las ambigüedades

79

Interfaces Implementación explícita public interface IfaceA { int F(); } public interface IfaceB { int F(); } public class Cls: IfaceA, IfaceB { void IfaceA.F(){ //implementación de F de IfaceA return 0; } void IfaceB.F(){ //implementación de F de IfaceB return 4; } } 80

Interfaces Implementación explícita

public class RunClass { public static void Main(){ Cls miCls = new Cls(); cls.F(); //Error! Ambigüedad entre implementaciones. IfaceA ia = miCls; int k = ia.F() //Se

ejecuta

la

implementación

para

IfaceA

} }

81



2. Orígenes de C#




4. Sintaxis básica


5. Arrays

16. ADO.NET



7. Interfaces

18. ASP.NET


19. AJAX





20. LINQ


Métodos, propiedades, eventos y delegados Parámetros por valor y por referencia  C# distingue dos tipos de datos  Tipos por valor: se accede directamente al valor del dato. Números (enteros y reales), booleanos, caracteres, estructuras y enumeraciones son tipos simples.  Tipos por referencia: se accede a los datos a través de una dirección de memoria (referencia o puntero). Todos los objetos excepto los citados anteriormente son de tipo por referencia.  A su vez, C# distingue dos tipos de paso de parámetros entre métodos.  Paso por valor: el parámetro es una copia del valor que almacena la variable donde está definido. Si se modifica el valor del parámetro dentro del método no se ve afectado el original. Es el paso por defecto.  Paso por referencia: el parámetro es la dirección de memoria donde está ubicada la variable. Si se modifica el valor del parámetro dentro del método se ve modificado a la vez en el original. Debe declararse explícitamente al declarar la cabecera del método mediante la palabra ref. 83

Métodos, propiedades, eventos y delegados Parámetros por valor y por referencia Paso de parámetros Por valor

Por valor

Por referencia

Tipo de datos

El parámetro es una copia del valor de un elemento. No se ve alterado el valor original.

El parámetro es una copia de la dirección de memoria. Se pueden modificar los atributos del objeto, pero no la referencia en sí misma

void f(int x){…}

void f(Object o){…}

El parámetro es una copia de la dirección de memoria de un elemento. El valor original cambia Por referencia al modificar el parámetro

void f(ref int x){…}

El parámetro es la dirección de memoria de una referencia (referencia de referencia). Se pueden modificar los atributos del objeto así como la dirección de memoria del objeto. void f(ref Object o){…} 84

Métodos, propiedades, eventos y delegados Parámetros de salida  Un parámetro de salida es aquél que debe ser modificado obligatoriamente en el cuerpo del método ya que se espera recoger un valor de él.  Dicha modificación ha de realizarse antes de cualquier lectura de su valor  Los parámetros de salida se pasan implícitamente por referencia ya sean de tipo valor o referencia.  Para declarar un parámetro de salida, basta con añadir la palabra out en la declaración del parámetro. Asimismo, se ha de usar esta palabra en cada llamada al método void f(int x, out int y, out object z){…} //definición int unX; int unY; Object unZ; f(unX, out unY, out unZ); //llamada

85

Métodos, propiedades, eventos y delegados Parámetros de salida  Se le pueden pasar como valores variables no inicializadas ya que garantizamos su inicialización al final del método.  A su vez no se permiten literales como parámetros de salida. public void f(out int x, out int y, out int z){...} int x = 5; int y; f(out x, out y, out 6); //x e y son correctos, pero 6 no!!  Los parámetros de salida permiten diseñar métodos que devuelvan múltiples objetos: un objeto se devolvería como valor de retorno y el resto, como parámetros de salida.

86

Métodos, propiedades, eventos y delegados Número de parámetros indefinido  C# permite métodos que puedan tomar un número indeterminado de parámetros, pero para ello es necesario cumplir ciertos requisitos:  El parámetro ha de ser una tabla unidimensional o dentada.  Ha de ser el último de la lista de parámetros del método y se le debe añadir la palabra reservada params en la definición.  Al llamar al método, los tipos de los parámetros han de ser del mismo tipo que la tabla. Si se desea un comportamiento genérico, basta con declarar una tabla de tipo Object (polimorfismo).  No se pueden usar los modificadores out ni ref con estos parámetros

87

Métodos, propiedades, eventos y delegados Número de parámetros indefinido public void f(char c, params int[] ps){...} f(„a‟); //Ok! Se pueden pasar 0 parám. indefinidos f(„b‟,1,4,5); //Ok! f(„c‟,3,“Hola”); //No! “Hola” es String y se espera int f(„d‟, new int[]{1,9,6}); //Ok!  Los métodos con parámetros indefinidos tienen la prioridad más baja cuando existe sobrecarga de métodos. public void g(int x, int y){…} public void g(params int[] ps){…} g(2,3); //el primer método tiene prioridad sobre el //segundo

88

Métodos, propiedades, eventos y delegados Sobrecarga con tipos de parámetros  Los modificadores ref y out forman parte de la signatura de un método.  En consecuencia, estos dos modificadores cuentan a la hora de sobrecargar métodos. public class Sobrecarga { public void f(int x){…} public void f(out int x){…} }  La clase es correcta ya que el compilador interpreta signaturas distintas para los dos métodos: el primero tiene un parámetro de entrada y el segundo, de salida.  Sólo hay una restricción: que la única diferencia entre la signatura de dos métodos sea que un determinado parámetro sea ref y el otro, out.

89

Métodos, propiedades, eventos y delegados Métodos externos  Un método externo es aquél cuya implementación no se da en el fichero fuente en el que se declara ya que está escrito en otro lenguaje de programación.  Debido a que su implementación es ajena al programa, el método no tiene cuerpo y hay que añadirle la palabra extern en su declaración extern <nombreMétodo>([<parámetros>]);  Los métodos externos no se pueden definir como abstractos a la vez, pero sí virtuales y con los modificadores de visibilidad vistos.  En el siguiente ejemplo se usa un método externo definido en un DLL del sistema que realiza una llamada a sistema para copiar un fichero origen en una de destino.

90

Métodos, propiedades, eventos y delegados Métodos externos // Aquí está definido DllImport using System.Runtime.InteropServices; public class Externo{ [DllImport(“kernel32”)] public static extern void CopyFile(string fuente, string destino); public static void Main(){ CopyFile(“fuente.dat”, “destino.dat”); } } 91

Métodos, propiedades, eventos y delegados Propiedades  Una propiedad es una fusión entre el concepto de atributo y el de método.  Externamente se accede a ella como si de un atributo visible se tratase, pero a nivel interno puede ejecutar código en cada asignación y/o lectura de su valor.  Las propiedades no almacenan datos, sino sólo se utilizan como si los almacenase.  En la práctica se usan para encapsular el a atributos privados y emularlos como si fueran públicos.  Cuando se asigna un valor, realizar una validación de datos y guardarlo en un atributo privado.  Cuando se lee el valor, se devuelve ese atributo privado.

92

Métodos, propiedades, eventos y delegados Propiedades <nombrePropiedad> { set { } get { } }  Al asignar un valor a la propiedad se ejecuta códigoEscritura y al leerla, códigoLectura.  En el fragmento set se incluye el parámetro implícito value, que es el valor que se solicita asignar. Es del mismo tipo de datos que la propiedad.  El fragmento get debe devolver una expresión del mismo tipo que la propiedad.  No es necesario definir en cada propiedad los dos bloques. Así podemos tener propiedades de sólo lectura o de sólo escritura. 93

Métodos, propiedades, eventos y delegados Propiedades private Date fnac; public Date fechaNacimiento{ //propiedad lect/escr set{ fnac = value; } get{ return fnac; } public int edad{ //propiedad solo lect get{ //coger fnac y hacer la diferencia en años respecto //la fecha actual de sistema. return diferencia; } } 94

Métodos, propiedades, eventos y delegados Modificadores de propiedades  Al igual que los atributos, las propiedades iten todos los modificadores de visibilidad de C# (public, private, protected e internal).  A su vez las propiedades se pueden definir como abstractas (abstract). Carecerían de cuerpo los bloques get y set y sería tarea de las subclases redefinirlas (override). public abstract int sueldo{ get; set; }  Se permiten otros modificadores de herencia y polimorfismo tales como virtual, new y sealed.

95

Métodos, propiedades, eventos y delegados e implementación de propiedades  El a una propiedad es análogo al de un atributo público del mismo tipo. //suponemos una propiedad x tipo int en una clase A A a = new A(); int b = a.x; //Lectura. Se ejecuta get a.x++; //Escritura. Se ejecuta set  La implementación interna de una propiedad consiste en que el compilador añade dos métodos con las instrucciones de los bloques get y set. Así, el ejemplo anterior se traduciría como: public int get_x(){…} y public void set_x(int value){…}  Mucho cuidado con definir métodos del estilo get_<prop> y set_<prop> ya que generarían un error de compilación si definimos una propiedad del mismo nombre.

96

Métodos, propiedades, eventos y delegados Delegados  Un delegado es un tipo de clase especial cuyos objetos almacenan una o más referencias a métodos de tal manera que a través del objeto sea posible ejecutar en cadena los métodos añadidos.  Resultan útiles en cualquier caso en el cual interesa pasar métodos como parámetros de otros métodos o bien cuando queramos tener objetos con métodos que cambien durante la ejecución del programa.  Son el mecanismo básico en el que se basa la escritura de aplicaciones con ventanas de la plataforma .NET. Por ejemplo, si tenemos un objeto de la clase Button (que simboliza los botones estándar de Windows), definimos un campo de tipo delegado que permita almacenar métodos que se ejecuten cuando hagamos clic en él.

97

Métodos, propiedades, eventos y delegados Declaración de delegados  Los delegados son de una clase y se declaran de la siguiente forma: <modifs> delegate ([<parámetros>]);

<nombreDelegado>

 Antes de definir un delegado hay que pensar qué tipo de métodos itirá, es decir, qué tipo de parámetros tendrán los métodos y cuál será su tipo de retorno (también es válido void).  Por ejemplo un delegado público llamado Deleg que ita métodos con un único parámetro entero y un valor de retorno string se define así: public delegate string Deleg(int val);  Los delegados son en el fondo clases especiales. Como clases que son pueden tener modificadores de visibilidad y su declaración, colocarse dentro o fuera de una clase.

98

Métodos, propiedades, eventos y delegados Uso de delegados  Crear un nuevo delegado se realiza con la palabra new (como los objetos) seguido de un único parámetro que es solamente del nombre de la función (sin parámetros). Delegado miDelegado = new Delegado(F); //F es un método  Si el método no es compatible con el delegado, se lanza una excepción en tiempo de ejecución durante la creación del delegado.  Finalmente, para ejecutar el método almacenado del delegado basta con invocarlo con los parámetros que ita. Si un delegado miDelegado itiera métodos con dos parámetros enteros, entonces se llamaría así: miDelegado(4,7);

99

Métodos, propiedades, eventos y delegados Uso de delegados public class A{ //1. Declaración del delegado public delegate void Mensajero(String mensaje); public void lanzarMensaje(String mensaje){ Console.WriteLine(mensaje); } public static void Main(){ //2. Instanciación del delegado con el método Mensajero mens = new Mensajero(lanzarMensaje); //3. Ejecución del delegado mens(“Hello, World!”); }

} 100

Métodos, propiedades, eventos y delegados Delegados múltiples  Los delegados pueden contener varias referencias a diferentes métodos.  Para añadir un nuevo método a la lista se usa el operador += seguido del new del objeto de tipo delegado con su función. Para quitarlo, basta con usar -= //suponemos que tenemos un delegado mens de la clase Mensajero deleg += new Mensajero(Console.WriteLine);  Al ejecutarse el delegado se invocarán los métodos en el orden al que fueron asignados secuencialmente.  Dentro de un delegado cabe cualquier tipo de método, ya sea estático o privado. En este último caso nos podemos encontrar que otra clase ajena ejecute el delegado. Esto no viola el principio de encapsulación ya que la clase no accede directamente al método, sino el delegado.  Si un delegado tiene asociado más de un método y éstos devuelven un valor, se devuelve el valor del último método invocado.

101

Métodos, propiedades, eventos y delegados Delegados múltiples public delegate void Trigonometric(double value); public void writeSin(double value){ Console.WriteLine(“sin({0})= {1}”,value,Math.Sin(value)); } public void writeCos(double value){ Console.WriteLine(“cos({0})= {1}”,value,Math.Cos(value)); } public void writeTan(double value){ Console.WriteLine(“tan({0})= {1}”,value,Math.Tan(value)); } public static void Main(){ Trigonometric td = new Trigonometric (writeSin); td += writeCos; td += writeTan; td(0.0); }

102

Métodos, propiedades, eventos y delegados Eventos  Un evento es análogo a lo que la propiedad es a la clase, es decir, permite controlar la forma a la que se accede a los delegados y dan la posibilidad de asociar código a ejecutar cada vez que se añada o quite un método del delegado.  Se declaran como un atributo pero anteponiendo la palabra event al nombre del tipo (que debe ser de tipo delegate) . <modificadores> event <nombreEvento>; public event Mensajero eventoMensaje;  Se les trata como delegados dentro de la clase donde están definidos, pero desde fuera deben cumplir ciertas restricciones:  Sólo de puede operar con ellos con += y -=.  No se permite llamar a los métodos almacenados desde él mismo. Así se obliga a que la llamada tenga que hacerse a través de un método definido en la clase donde proviene el evento y así dotarle de cierto control.

103



2. Orígenes de C#




4. Sintaxis básica


5. Arrays

16. ADO.NET



7. Interfaces

18. ASP.NET


19. AJAX





20. LINQ


Estructuras y enumeraciones Estructuras  Una estructura es un tipo especial de clase pensada para representar objetos ligeros, es decir, que ocupen poca memoria y deban ser manipulados con velocidad.  Las estructuras no derivan de ninguna clase (salvo System.ValueType) ni pueden ser derivadas de ella.  Al contrario de las clases, sus variables no almacenan ninguna referencia a zonas de memoria dinámica sino directamente referencias a los objetos. En consecuencia:  Las estructuras son de tipo valor.  En las asignaciones entre variables no se copian referencias, sino que se duplican los objetos enteros.  Las estructuras no iten valores null.  Se declaran igual que una clase, pero cambiando la palabra class por struct.

105

Estructuras y enumeraciones Estructuras struct Point { public double x; public double y; public Point(int x, int y){ this.x = x; this.y = y; } //más métodos… }  Otras diferencias respecto a las clases:  El método Equals() no compara referencias sino que mira que todos los campos de la estructura valen lo mismo.  El operador == no es en principio aplicable directamente, luego el programador debe redefinirlo explícitamente para que funcione.

106

Estructuras y enumeraciones Boxing y unboxing  Las estructuras derivan indirectamente de la clase Object. Por lo tanto, es posible aplicar polimorfismo y asignar una estructura a un objeto Object.  Aun y así, no se puede asignar directamente debido a diferencias semánticas y de almacenamiento que existen entre clases y estructuras.  Es por ese motivo que a los objetos de tipo valor se les ha de hacer una conversión a tipo referencia llamada boxing.  El proceso es sencillo: basta con crear una clase que haga de envoltura del tipo valor: public class T_box { T value; public T_box(T t){ value = t; } }

107

Estructuras y enumeraciones Boxing y unboxing  El boxing se hace de forma transparente al programador, ya que el compilador se encarga de crear la clase de envoltura.  El programador tan sólo realiza la asignación polimórfica y listo. Point p = new Point(0.0,1.0); //Point es una struct Object o = p; //equivale a Object o = new Point_Box(p);  El proceso de unboxing es análogo al anterior pero a la inversa, es decir, recupera la estructura encapsulada de dentro de la clase. Se realiza como un casting normal: Point p2 = (Point) o; //equivale a p2 = ((Point_Box)o).value  La comprobación de tipos en el unboxing es estricta: sólo se acepta que el tipo expecificado sea exactamente el mismo que el tipo original. int i = 123; Object obj = i; //boxing long l = (long) obj; //incorrecto. obj es en realidad un int long l = (long) (int) obj; //correcto. Doble conversión 108

Estructuras y enumeraciones Constructores de estructuras  Los constructores de estructuras difieren un poco respecto los constructores de clase:  No pueden llevar el inicializador base ya que no tienen mecanismo de herencia  No se pueden leer los atributos de una estructura sin haberlos inicializado antes. Por ese motivo el constructor se usa principalmente para tal efecto.  Toda estructura incluye un constructor sin parámetros que le da un valor por defecto a sus atributos. Nunca puede ser redefinido por el programador.

109

Estructuras y enumeraciones Enumeraciones  Una enumeración es un tipo de datos en el que los literales de los valores que pueden tomar sus objetos se indican explícitamente en la definición. enum <nombreEnumeración>: { } enum Tamaño { Pequeño, Mediano, Grande}  En realidad, las enumeraciones son estructuras que tienen como atributos campos estáticos, constantes, públicos y de alguna tipología de número entero (short, int, long, etc.)  Declarar enumeraciones y asignar sus elementos funciona como con cualquier otro atributo. Tamaño tam; //declaración tam = Tamaño.mediano //asignación

110

Estructuras y enumeraciones Uso de enumeraciones  Cada literal de la enumeración se representa a nivel interno como un número entero empezando desde 0.  Se puede cambiar esto asignando valores a los literales siempre que se respeten unas reglas:  El valor debe estar comprendido dentro del rango numérico itido del tipo.  Se pueden definir valores de otros literales o cualquier expresión con ellos siempre y cuando no hayan definiciones circulares.  El valor por defecto de una variable tipo enumeración es siempre 0.  Se pueden asignar a variables enteras literales de una enumeración; así: int a = Tamaño.pequeño int b = (Tamaño)1; Tamaño t = (Tamaño)4;

111

Estructuras y enumeraciones Uso de enumeraciones  Para forzar a una enumeración que sus literales no sean de tipo int hay que indicar en su declaración el tipo al que pertenecerán como si de una herencia se tratase: enum Tamaño:long { Pequeño, Mediano, Grande };  Al ser todas ellas de tipo entero, podemos aplicarles operaciones de enteros tales como aritméticas y lógicas. Sin embargo, existen ciertas restricciones:  Los operadores binarios + y – no pueden aplicarse entre dos enumeraciones. Al menos un operando ha de ser entero.  Los operadores |, & y ^ sólo pueden aplicarse entre operandos tipo enumeración

112



2. Orígenes de C#




4. Sintaxis básica


5. Arrays

16. ADO.NET



7. Interfaces

18. ASP.NET


19. AJAX





20. LINQ


Espacios de nombres Concepto de espacio de nombres  Un espacio de nombres o namespace es un modo de organizar las clases y otros tipos de datos análogo a la estructura de directorios y ficheros pero a nivel lógico.  La BCL de C# se encuentra organizada dentro de espacios de nombres, de modo que las clases más usadas se encuentran en el namespace System. Por ejemplo, las clases de a base de datos están en System.Data y las operaciones de entrada y salida, dentro de System.IO.  Para declarar un espacio de nombres se usa la siguiente sintaxis: namespace <nombreEspacio> { }  Donde pueden ser clases, interfaces, estructuras, delegados, etc. Los tipos definidos dentro de esta definición pasarán automáticamente a formar parte del espacio de nombres.

114

Espacios de nombres Concepto de espacio de nombres namespace MiEspacio{ public class MiClase{…} }  El verdadero nombre de una clase, que se denomina nombre completamente calificado, es el nombre de la clase precedido de la concatenación de espacios de nombres ordenados del más externo al más interno y separados por puntos. Así el ejemplo anterior resultaría MiEspacio.MiClase.  Gracias a los nombres completamente calificados resolvemos ambigüedades cuando tenemos dos clases que se llaman igual. Debido a que provienen de dos espacios distintos, pueden ser diferenciadas  Si se define una clase fuera de un espacio de nombre, ésta se asigna automática al espacio global.

115

Espacios de nombres Espacio de nombres anidados  C# permite incluir dentro de un espacio de nombres otros subespacios de nombres. Por ejemplo: namespace EspacioA { namespace EspacioB { public class C {…} } }  Luego, la clase C tiene como nombre calificado EspacioA.EspacioB.C.  Es posible compactar definiciones de nombres de espacios anidados usando puntos. Así, la siguiente definición equivale a la anterior: namespace EspacioA.EspacioB { public class C {…} }

116

Espacios de nombres Sentencia using  En principio si se desea acceder a una clase de un determinado espacio de nombres externo al actual, se ha de referir a dicha clase usando el nombre completamente calificado.  Retomando el ejemplo anterior, para declarar un objeto de la clase C dentro de un espacio diferente de EspacioA.EspacioB, habría que hacer: EspacioA.EspacioB.C objeto = new EspacioA.EspacioB.C();  Los espacios de nombres suelen ser largos y pesados de escribir. En este escenario entra la sentencia using, que funciona como mecanismo de importación de nombres, es decir, poder usar nombres de clases sin tener que escribir el nombre completamente calificado.  Estas sentencias deben ir dentro del namespace antes de cualquier definición de clase.

117

Espacios de nombres Sentencia using namespace EspA.EspB{ public class Cls1 {…} } namespace EspC { using EspA.EspB; //importamos el namespace EspA.EspB class Cls2 { Cls1 c; //Con using, no hemos de poner EspA.EspB.Cls1 } }

118

Espacios de nombres Espacios de nombres distribuidos  Se permite declarar varias definiciones del mismo espacio de nombres en un fichero o distintos. Esto es posible gracias a que el compilador las fusiona en una única definición de namespace e introduce todas las clases a la vez. namespace A { class B1 {…} } namespace A { class B2 {…} }  El compilador entonces, genera algo del estilo namespace A { class B1{…} class B2{…} }

119

Espacios de nombres Ambigüedades y alias  Es posible encontrarse con ambigüedades cuando tenemos dos clases del mismo nombre al usar sentencias using. //suponemos que en A y B existe una clase C using A; using B; public class Conflicto:C {…}  En este caso, el compilador lanza un error ya que no sabe si nos referimos a la clase A.C o a la A.B.  La primera aproximación válida es usar el nombre completamente calificado, pero se ha visto que es un procedimiento largo y tedioso.  La otra opción que permite C# es el uso de alias, es decir, nombres que actúan de sinónimos del nombre al que hacen referencia.

120

Espacios de nombres Alias  Los alias se declaran dentro de la sentencia using: using = <nombreClase o nombreNamespace>  Destacar que los alias pueden hacer referencia a nombres de clase o bien a otros espacios de nombres.  Así el error de compilación quedaría resuelto de la siguiente manera: using A; using B; using CdeB = B.C; public class Conflicto1:C {…} //el compilador escoge A.C public class Conflicto2:CdeB {…} //el compilador escoge B.C  ¡Cuidado! No se pueden definir alias que hagan referencia a otros alias. Provocaría un error de compilación. namespace N1.N2 {…} using A1 = N1; using A2 = A1.N2; // No! error de compilación. 121



2. Orígenes de C#




4. Sintaxis básica


5. Arrays

16. ADO.NET



7. Interfaces

18. ASP.NET


19. AJAX





20. LINQ


Redefinición de operadores e indizadores Concepto de redefinición  Se ha visto que C# cuenta con un buen número de operadores con una sintaxis clara e intuitiva para realizar las operaciones básicas aritmética, lógicas y propias del lenguaje.  El comportamiento de estos operadores viene predefinido dentro del lenguaje cuando se aplican a ciertos tipos de datos. Por ejemplo, el operador + entre dos int devuelve su suma, mientras que si son string devuelve su concatenación.  Sin embargo, también se permite que el programador pueda definir el significado de la mayoría de estos operadores cuando se apliquen a objetos de clases que él haya definido. A este proceso se le llama redefinición de operadores.

123

Redefinición de operadores e indizadores Utilidad de las redefiniciones  El objetivo de redefinir operadores es hacer más claro y legible el código, no hacerlo más corto. Supongamos que tenemos una clase Complejo que trata números complejos: Complejo c1 = new Complejo(1,3); //c1 = 1 + 3i Complejo c2 = new Complejo(2,-1); //c2 = 2 – i Complejo c3 = c1.suma(c2); //c3 = 2 + 2i Complejo c4 = c1 + c2; //c4 = 2 + 2i pero más legible  Es importante tener en cuenta que se debería dar un significado intuitivo a los operadores y muy parecido al que tienen en origen ya que de otra manera complicaría entender el código.  Es buena práctica definir un método que funcione de forma equivalente al operador para que lenguajes que no soporten redefinición puedan aplicar las operaciones.

124

Redefinición de operadores e indizadores Sintaxis básica y restricciones  Por regla general, toda redefinición de operador es un método estático y público cuyo nombre es el símbolo del operador a definir precedido de la palabra operator y cuyos parámetros son los operandos. public static operator <símbolo>([ ]){ }  No se permite que los operadores devuelvan void .  Dentro de los operandos al menos uno debe ser de la misma clase en la que se define el operador. Si el operador es unario, es obligatorio lo anterior.  No pueden alterarse las reglas de precedencia, asociatividad, ubicación y número de operandos.  No se permite definir nuevos operadores incluso como combinación de los ya existentes.

125

Redefinición de operadores e indizadores Sintaxis básica y restricciones public class Complejo { public float r; //parte real public float im; //parte imaginaria //constructor public Complejo(float r, float im) { this.r = r; this.im = im; } //operador de suma public static Complejo operator +(Complejo c1, Complejo c2){ return new Complejo (c1.r + c2.r, c1.im + c2.im); } //operador de producto public static Complejo operator *(Complejo c1, Complejo c2){ float r = c1.r * c2.r – c1.im * c2.im; float im = c1.r * c2.im + c1.im * c2.r; return new Complejo(r,im); } } 126

Redefinición de operadores e indizadores Redefinición de operadores unarios  Operadores redefinibles: ! + - ~ ++ -- true false  Sólo tienen un único parámetro, que ha de ser de la misma clase donde se define el operador.  Los operadores ++ y -- deben devolver un objeto del mismo tipo que el operando. Esta devolución se comporta de manera distinta dependiendo de la aplicación:  Si es de forma prefija, se devuelve la expresión de return.  Si es de forma postfija, el compilador ignora el return y devuelve el objeto original que se pasó como parámetro.  Es muy recomendable no modificar nada del parámetro original para no alterar el funcionamiento de este operador

127

Redefinición de operadores e indizadores Redefinición de los operadores true y false  Se usan cuando un objeto concreto representa el valor lógico cierto (true) o falso (false).  Su redefinición ha de devolver siempre un tipo bool.  Si se redefine uno de ellos, necesariamente el otro debe ser redefinido también.  Estos operadores no pueden usarse directamente en el código fuente, sino que se usan en expresiones condicionales como si de un valor booleano se tratase. public static bool operator false(Complejo cm){ return cm.r == 0.0 && cm.im == 0.0; } public static bool operator true(Complejo cm){ return cm.r != 0.0 || cm.im != 0.0; } //uso en una condicion Complejo num = new Complejo(1.0,1.0); if(num) return “El número no es cero”; 128

Redefinición de operadores e indizadores Redefinición de operadores binarios  Operadores redefinibles: + - * / % & | ^ << >> == != < > <= >=  Al menos un parámetro debe ser de la misma clase donde se ha redefinido el operador.  Si un operador tiene complementario, se han de redefinir ambos. Es decir, si se redefine , <= se debe redefinir también >=.  No se puede redefinir el operador de asignación, pero los operadores compuestos +=, -=, *=, etc. se redefinen implícitamente al redefinir +, -, *, etc. respectivamente.  Tampoco es posible redefinir los operadores && y ||, pero se simula redefiniendo los operadores true, false, & y |. Esta imposibilidad se debe al tratamiento perezoso que el compilador hacer con && y ||.

129

Redefinición de operadores e indizadores Concepto de indizador  Un indizador es la redefinición del operador de a tablas ([]) dentro de un tipo de datos definido por el .  Resultan útiles cuando disponemos de clases que almacenan colecciones de objetos y su se desea realizar como si de una tabla se tratara.  Los indizadores, como las propiedades, permiten ejecutar código cada vez que se desea leer y escribir un elemento de una posición concreta definida por los índices.  Los índices no tienen por qué ser valores enteros, pudiendo definirse varios en una misma clase, difiriendo en número de índices o en sus tipos.

130

Redefinición de operadores e indizadores Sintaxis de indizadores  A la hora de definir un indizador se usa una sintaxis parecida a la de las propiedades: <modificadores> this[<índices>]{ get{ } set{ } }  Donde tipoDatos es el valor de retorno e índices son los diferentes índices para acceder a los elementos.

131

Redefinición de operadores e indizadores Restricciones de a indizadores  Para su correcto funcionamiento, los indizadores deben cumplir ciertas restricciones:  El nombre que se le da al indizador ha de ser this, pues carece sentido dar otro nombre puesto que un indizador no se accede a través de su nombre sino aplicando el operador [] a un objeto.  No se iten los modificadores ref, out o params en la declaración de los índices y al menos ha de existir un parámetro índice.  No se pueden definir indizadores estáticos, sólo de objetos.  Para acceder a un indizador se utiliza exactamente la misma sintaxis que el a tablas excepto que los índices no tienen por qué ser valores enteros. //suponemos un indizador que acepta índices de tipo String t[“Pepe”] = t[“Juan”];

132



2. Orígenes de C#




4. Sintaxis básica


5. Arrays

16. ADO.NET



7. Interfaces

18. ASP.NET


19. AJAX





20. LINQ


Excepciones Concepto de excepción  Una excepción es un suceso anómalo que ocurre durante la ejecución de un programa e interrumpe el flujo normal de instrucciones.  Las posibles causas del lanzamiento de una excepción incluyen desde fallos de hardware (desbordamiento, divisiones por 0, etc.) hasta errores de programación ( fuera de rangos de una tabla, fallo de conexiones a bases de datos, etc.), siendo estos últimos las principales.  La gestión de excepciones es el mecanismo que usa y recomienda C# para el control de errores.

134

Excepciones Ventajas  El mecanismo clásico de gestión de errores consiste en que cada fragmento de código susceptible de error genere un código que debe tratar después el programador a través de sentencias if … else.  Las excepciones ofrecen usa serie de ventajas respecto al mecanismo anterior.  Claridad. El control de excepciones separa el código normal del código de control de errores en dos partes bien diferenciadas para separar ambas lógicas y hacer el programa menos lioso.  Más información. Las excepciones permiten especificar mensajes para indicar las causas del error y hacer más trazable el error.  Tratamiento asegurado. Se garantiza que en caso de error, la excepción será tratada y de no serlo, se abortará la ejecución del programa.

135

Excepciones Capturando excepciones  El control de excepciones se estructura en tres bloques:  Bloque try. Incluye las instrucciones normales de código. Si se detecta el lanzamiento de una excepción se interrumpe el flujo de ejecución y se pasa a ejecutar el bloque catch.  Bloque catch. Incluye las instrucciones que tratarán la excepción generada. Un bloque catch dispone siempre de una referencia a la excepción generada para poder acceder a información extra sobre la causa y la trazabilidad.  Bloque finally. Incluye instrucciones que se ejecutarán siempre, se haya producido una excepción o no. Es decir, si el bloque try no lanza excepción alguna se pasa a ejecutar finally y si se lanza, después del catch también se ejecutará finally. Se usa principalmente para liberar recursos o destruir objetos.

136

Excepciones Capturando excepciones public void division(int num, int den){ Console.WriteLine(“Inicio de programa”); try{ int result = num / den; Console.WriteLine(“El resultado es {0}”,result); }catch (DivideByZeroException ex) { Console.WriteLine(“Error! Se ha intentado dividir por 0”); }finally{ Console.WriteLine(“Fin de programa”); } }

137

Excepciones Capturando múltiples excepciones  C# ofrece la posibilidad de capturar múltiples excepciones en un único bloque try.  Para ello basta con definir varios bloques catch, uno por cada excepción que se desee tratar.  Los bloques catch se ejecutan en secuencia, de forma que es importante definir su orden, sobre todo cuando existe una jerarquía de excepciones ya que por polimorfismo una excepción padre puede capturar excepciones hijas.  Conviene siempre capturar primero las excepciones más concretas y dejar como últimas las más genéricas (siendo la más básica, System.Exception, la última)

138

Excepciones Capturando múltiples excepciones public void (int[] vec, int index){ try { Console.WriteLine(“El valor es {0}”, vec[index]); } catch (NullReferenceException re){ Console.WriteLine(“Error 1! ” + re.Message); } catch (IndexOutOfRangeException ie){ Console.WriteLine(“Error 2! ” + ie.Message); } }

139

Excepciones Lanzando excepciones  A parte de capturar excepciones, el lenguaje permite definir momentos en los cuales lanzar una excepción.  Para lanzar una excepción se usa la palabra throw seguida de una expresión que devuelta una referencia a una excepción. throw <expresionExcepción>  Resulta conveniente cuando se desea propagar una excepción para que en otra región de código (o clase) sea capturada. public double raizCuadrada(double num){ if(num < 0.0){ throw new ArgumentException(“Argumento negativo”); } return Math.sqrt(num); }

140

Excepciones Excepciones personalizadas  La BCL de C# incluye una colección extensa de excepciones que resuelven la mayoría de errores comunes cuando uno programa.  No obstante hay veces en que se desea una excepción personalizada dentro de un programa para tratar nuevas casuísticas de situaciones extrañas.  C# permite la creación de estas excepciones heredando de la clase base de excepciones System.Exception.  Se recomienda que el nombre de clase de la excepción indique la causa de su lanzamiento y que termine con el sufijo Exception para su rápida identificación.  Se deberían declarar dos constructores: el constructor vacío y otro con un parámetro string que simbolice el mensaje de error.

141

Excepciones Propagando excepciones  Si una excepción no se captura dentro de un método decimos que se propaga hacia niveles superiores. Es decir, se delega la responsabilidad de captura al método que llamó al método que generó excepción, y así sucesivamente.  Si una excepción no se captura en ningún método a través de un bloque try … catch se finaliza el hilo de ejecución y si este hilo es el principal, entonces se aborta el programa.  Las excepciones ofrecen una propiedad interesante llamada StackTrace que nos escribe la pila de llamadas a métodos desde Main() hasta aquél que generó la excepción y la línea donde se produjo. Esto es muy útil de cara a detectar errores de programación y corregirlos.

142



2. Orígenes de C#




4. Sintaxis básica


5. Arrays

16. ADO.NET



7. Interfaces

18. ASP.NET


19. AJAX





20. LINQ


Estructuras de datos Introducción  Las llamadas Colecciones son una agrupación de clases de .NET Framework que sirven para almacenar conjuntos de datos, siendo, cada instancia de estas clases, una colección de elementos.  Las colecciones permiten almacenar conjuntos de datos utilizando estructuras sin preocuparse de cómo estén implementadas, que es una forma útil de aplicar la reutilización.  Así se codifica más rápidamente y se obtiene un mayor rendimiento mejorando la velocidad de ejecución y reduciendo el consumo de memoria.  Se explicarán con más detalle:  Las interfaces de colección que describen las posibilidades de cada tipo  Las clases de implementación  Los enumeradores que permiten recorrer las colecciones

144

Estructuras de datos Ventajas  Las ventajas de utilizar colecciones son obvias:  No se necesita escribir una librería de utilidades para almacenar la información.  El API de colecciones está pensada para un gran rango de usos y está optimizada  Es extensible  Comienza a ser muy utilizada por la comunidad de programadores, estandarizando el modelo de desarrollo

145

Estructuras de datos Espacios de nombres  La plataforma .NET suministra tres espacios de nombres dedicados a las colecciones:  System.Collections. Contiene colecciones que almacenan referencias a objetos.  System.Collections.Generic. Alberga clases genéricas para guardar colecciones de tipos especificados.  System.Collections.Specialized. Contiene varias colecciones que soportan tipos específicos como strings y bits.

146

Estructuras de datos Interfaces  Todas las colecciones de .NET Framework implementan alguna combinación de las interfaces de colección.  Estas interfaces declaran operaciones que se aplican de modo genérico sobre varios tipos de colecciones.  Todas ellas están declaradas en el espacio System.Collections y tienen otras similares en System.Collections.Generic.  La implementación de estas interfaces se incluye dentro de la plataforma.

147

Estructuras de datos Interfaces Interfaz

Descripción

ICollection

La interfaz raíz de la jerarquía de colecciones de la cual heredan las interfaces IList y Dictionary. Contiene propiedades como Count, CopyTo

IList

Colección ordenada que se manipula como un array. Accede a sus elementos por medio de un índice entero. También permite búsquedas, inserciones, modificaciones, etc.

IDictionary

Colección de valores indexados por una clave (objeto arbitrario). Accede a los elementos por indexación y métodos para modificar la colección. La propiedad Keys contiene los objetos usados como índices y Values, los objetos almacenados.

IEnumerable

Un objeto puede ser enumerado. Esta interfaz sólo tiene un método, GetEnumerator, que devuelve un objeto IEnumerator. ICollection implementa IEnumerable, de modo que todas las clases de colección también. 148

Estructuras de datos Colecciones no genéricas  El espacio de nombres System.Collections es la fuente de las colecciones no genéricas.  Estas clases ofrecen implementaciones estándar de muchas estructuras de datos que almacenan referencias de tipo Object.  Se tratarán las clases ArrayList, HashTable, Stack y Queue.

149

Estructuras de datos Clases Clase

Implementa

Descripción

Array

IList

Clase base de los arrays convencionales.

ArrayList

IList

Imita los arrays convencionales con posibilidades de añadir o quitar datos.

BitArray

ICollection

Array de booleanos.

HashTable

IDictionary

Agrupación de parejas clave-valor.

Queue

ICollection

Colección de tipo FIFO (first-in first-out).

SortedList

IDictionary

Una HashTable que ordena datos por clave y se acceden a través de clave o índice.

Stack

ICollection

Una colección de tipo LIFO (last-in first-out). 150

Estructuras de datos Colecciones genéricas  Las colecciones de Object acaban resultando pesadas en el trato ya que es necesario hacer downcasting cada vez que se desea acceder a sus valores.  Además, estas colecciones son inseguras a nivel de tipos ya que podemos mezclar en ellas objetos de cualquier tipo (por ejemplo, int con boolean) con sus consecuentes excepciones en tiempo de ejecución.  Por estos motivos, C# introdujo en su versión de 2005 los tipos genéricos, pensados para hacer más robusta la programación genérica.  Para definir una clase con tipos genéricos, basta con encerrar entre < > identificadores que harán referencia al tipo. class Lista<X> {…} class Diccionario {…}

151

Estructuras de datos Tipos genéricos: definición y uso  Para definir una clase con tipos genéricos, basta con encerrar entre < > los identificadores que harán referencia a los tipos. class Lista {…} class Diccionario {…}  Para utilizar objetos tipo dentro de la clase hay que usar el identificador especificado en la definición. T varT; public void add(T t){…}  Cuando se desee usar un objeto de la clase genérica en otra región de código, habrá que especificar un tipo de datos concreto y existente. IList<string> lista = new ArrayList<string>();

152

Estructuras de datos Tipos genéricos: restricciones  A los tipos de una clase genérica se les pueden añadir ciertas restricciones:  De derivación. Los tipos pueden heredar de cualquier clase, interfaz u otro tipo. Así se restringe los tipos que puede tratar una clase genérica. Para indicarlo hay que añadir la palabra where en la definición de la clase indicando el tipo y el tipo base del cual hereda. class AVL where T: IComparable {…}  De construcción. No se pueden crear instancias del tipo con new salvo que se haga con el constructor por defecto. Hay que explicitarlo dentro de la cláusula where. class MyList where T: new() { T unT = new T();  Se permite la combinación de ambas restricciones.

153

Estructuras de datos Tipos genéricos: herencia y operadores  Los tipos genéricos iten herencia y la propagación de tipo es de dos maneras: definiendo un tipo concreto o bien definiendo el mismo que el de la clase base. public class ListaHija1 : ListaPadre {…} public class ListaHija2 : ListaPadre {…}  Se permiten declarar clases abstractas genéricas y con métodos virtuales. public abstract class ListaAbstracta {…}  C# permite también redefinir operadores en una clase de tipos genéricos. Esto no es válido para la versión 2.0 e inferiores. public class MiLista { public static operator +(MiLista l1, MiLista l2){…} }

154

Estructuras de datos Clases genéricas Clase

Implementa

Descripción

Dictionary

Colección genérica de parejas IDictionary clave-valor que se acceden por una clave.

SortedDictionary

IDictionary

Diccionario que ordena los datos por clave en un árbol binario.

LinkedList<E>

ICollection<E>

Lista doblemente enlazada

List<E>

Ilist<E>

ArrayList, ahora genérico.

SortedList

IDictionary

Lista ordenada por clave de tipo genérico.

Stack<E>

ICollection<E>

Pila genérica.

Queue<E>

ICollection<E>

Cola genérica. 155

Estructuras de datos Enumeradores  A la hora de recorrer una colección podemos optar por un mecanismo de enumeradores o iteradores, que permiten el secuencial a sus elementos.  Para poder usar un enumerador dentro de una colección es necesario que ésta implemente la interfaz IEnumerable, cuyo único método, GetEnumerator(), devuelve un objeto de la interfaz IEnumerator, que recorre la colección.  Es muy importante su uso debido a que la instrucción iterativa foreach hace uso de ellos de forma transparente y sencilla al programador, razón de más para definirlos en colecciones personalizadas.

156

Estructuras de datos Enumeradores  Es necesario que cada colección que use un enumerador cree la implementación interna de IEnumerator, que ha de tener los siguientes :  Un constructor con un parámetro cuyo tipo sea la colección para la que definimos el enumerador  Propiedad Current. Devuelve un objeto o tipo genérico que representa el elemento actual.  Método MoveNext. Avanza una posición dentro de la colección y devuelve un valor booleano indicando si existen más elementos.  Método Reset. Posiciona el iterador en el primer elemento de la colección.  Se recomienda que la clase que implementa IEnumerator sea una clase interna y privada de la colección.

157

Estructuras de datos ArrayList  La clase ArrayList imita la funcionalidad de los arrays convencionales y ofrece la posibilidad de redimensionar su tamaño a través de los métodos de su clase.  Todo ArrayList tiene un tamaño (el número de elementos que hay actualmente) y una capacidad (el número de elementos que puede llegar a tener sin redimensionar).  Si el tamaño de un ArrayList supera la capacidad, ésta última se dobla (se crea un nuevo ArrayList el doble de grande con los mismos elementos).

158

Estructuras de datos ArrayList Método / Propiedad

Descripción

int Add(Object)

Añade el objeto al ArrayList al final y devuelve un número entero indicando la posición.

int Capacity(get; set;)

Propiedad que establece o consulta el número de elementos que puede contener el ArrayList

void Clear()

Borra todos los elementos del ArrayList

bool Contains(Object)

Comprueba si existe un determinado objeto en el ArrayList

int Count(get;)

Propiedad de sólo lectura que obtiene el número de elementos contenidos realmente en el ArrayList. Capacity indica los que puede contener como máximo.

int IndexOf(Object)

Devuelve el índice del primer elemento del objeto especificado que se encuentre.

void Insert(int, Object)

Inserta un elemento en la posición indicada por el número

void Remove(Object)

Quita la primera ocurrencia de un objeto concreto del ArrayList 159

Estructuras de datos ArrayList string values[] = {“Senatvs”, “Popvlvs”, “Qve”, “Romanvs”} ArrayList listValues = new ArrayList(); foreach(string word in values){ listValues.add(word); } for(int i = 0; i < listValues.Count; i++){ Console.WriteLine(“Posicion {0} -> {1}”, i, listValues[i]); } Console.WriteLine(“La capacidad es de {0}”, listValues.Capacity);

160

Estructuras de datos Tablas Hash  Una tabla hash es una estructura de datos que mapea claves con valores y permite s eficientes a los datos.  Se usa cuando tenemos un volumen grande de datos y las búsquedas a éstos han de ser los más rápidas posibles.  A nivel interno, las tablas de hash son arrays de gran capacidad que transforman las claves en un índice entero del array a través de una función de hash.  Si dos claves tienen el mismo valor al aplicar la función de hash, se produce una colisión. Existen varias formas de tratarlas (listas, siguiente posición ,etc.)  El factor de carga es la relación máxima de elementos por sectores de almacenamiento.  Un factor de carga inferior implica una búsqueda más rápida a costa de un mayor consumo de memoria.

161

Estructuras de datos HashTable  La clase HashTable implementa este tipo de estructura de datos.  La función de Hash ya viene definida en todas las clases ya que la clase Object dispone del método GetHashCode.  La mayoría de las clases que son candidatas a ser usadas como claves en una HashTable sobreescriben este método para ofrecer una manera de efectuar cálculos eficientes de hashing para un tipo específico.  Se puede variar el factor de carga con un número proporcionado en el constructor de la clase.

162

Estructuras de datos HashTable Método / Propiedad

Descripción

HashTable()

Esta variedad del constructor crea un objeto HashTable con la capacidad inicial, factor de carga y comparador predeterminados.

int Count(get;)

Propiedad que obtiene el número de elementos de la HashTable.

Object Item[Object(set;get;)]

Obtiene o establece el valor asociado a la clave especificada.

ICollection Keys(get;)

Propiedad que obtiene una ICollection con las claves de la HashTable.

ICollection Values()

Propiedad que obtiene una ICollection con los valores de la HashTable.

void Add(Object, Object)

Añade un elemento con la clave y valor indicados como argumentos.

void Remove(Object)

Borra el elemento cuya clave coincida con la especificada.

Boolean Contains(Object)

Determina si la HashTable contiene una clave específica. 163

Estructuras de datos Stack  La clase Stack (pila) representa una colección sencilla de objetos en la que se aplica el algoritmo LIFO (last-in first-out).  Sólo se pueden añadir y sacar objetos por un único punto de entrada llamado cima.  Para sacar un objeto por debajo de la cima se debe sacar previamente todos aquellos que están por encima.

164

Estructuras de datos Stack Método / Propiedad

Descripción

Stack()

El constructor está sobrecargado tres veces. Esta variante crea un Stack vacío con una capacidad inicial predeterminada de 10 elementos.

int Count(get;)

Propiedad que obtiene el número de elementos de la pila.

Object Pop()

Quita y devuelve el objeto situado en la cima de la pila. Causa una InvalidOperationException si está vacía.

void Push(Object)

Inserta un elemento al principio del Stack.

bool Contains(Object)

Comprueba si un dato está en la colección. La búsqueda es lineal.

Object Peek()

Devuelve el objeto situado en la cima de la pila sin eliminarlo.

165

Estructuras de datos Stack public static void Main(){ // Crea e inicializa un nuevo Stack. Stack miPila = new Stack(); miPila.Push(“Hola”); miPila.Push(“Mundo”); miPila.Push(“!”); // Muestra propiedades y valores de la pila. Console.WriteLine( “MiPila” ); Console.WriteLine( "\tCuenta: {0}”, miPila.Count ); Console.Write( "\tValores:” ); MuestraValores( miPila ); } public static void MuestraValores( IEnumerable miColeccion ) { foreach ( Object obj in miColeccion ) Console.Write( “ {0}”, obj ); }

166

Estructuras de datos SortedDictionary  Un diccionario es el término general para una colección que almacena pares de clave y valor.  Las tablas de hash son un modo de implementar un diccionario, pero no el único. .NET Framework ofrece varias implementaciones de diccionario, tanto genéricas como no genéricas y todas implementan la interfaz IDictionary.  Una clase del grupo de las genéricas muy usada es SortedDictionary .  En lugar de una tabla hash, utiliza un árbol binario que está ordenado por las claves.  Los métodos de esta clase son similares a los de la clase Hashtable.

167

Estructuras de datos SortedDictionary Método / Propiedad

Descripción

int Count(get;)

Devuelve el número de entradas incluidas en el diccionario.

ICollection Keys

Obtiene una colección con todas las claves del diccionario.

Icollection<E> Values

Obtiene una colección con todos los valores del diccionario.

void Add(K,E)

Agrega un elemento al diccionario y lo ordena según su clave.

bool TryGetValue(K, out E)

Comprueba si la clave existe y en caso afirmativo devuelve su valor asociado.

bool ContainsKey(K)

Comprueba si el parámetro clave está en el diccionario.

bool ContainsValue(E)

Comprueba si el parámetro valor está en el diccionario

bool Remove(K)

Quita la primera aparición del elemento que se indique. Si no se encuentra devuelve false. 168

Estructuras de datos SortedDictionary public static void Main( string[] args ) { // creamos un nuevo Sorted Dictionary con lo que teclee el SortedDictionary<string,int> dicc = new SortedDictionary <string,int>(); Console.WriteLine( “Teclea una frase: " ); string frase = Console.ReadLine(); // Partimos la frase en palabras (array) string[] pals = Regex.Split (frase, @"\s+"); foreach (string palabra in pals) { if (dicc.ContainsKey(palabra)) // Si aparece la palabra… ++dicc [palabra]; // sumamos al número de repeticiones else // Añadimos nueva palabra y su núm. Ocurrencias dicc.Add( palabra, 1 ); // Muestra el contenido del Sorted Dictionary DisplayDictionary( dicc); } 169

Estructuras de datos LinkedList<E>  La clase LinkedList implementa una lista doblemente enlazada.  Permite recorrerla hacia delante y hacia atrás con nodos de la clase genérica LinkedListNode.  Cada nodo contiene la propiedad Value (valor almacenado) y las propiedades de sólo lectura Previous y Next.  La propiedad Previous obtiene una referencia al nodo precedente de la lista enlazada o null si el nodo es el primero de la lista. Similarmente, Next obtiene la referencia al siguiente dato de la lista o null si es el último.

170

Estructuras de datos LinkedList<E> Método / Propiedad

Descripción

int Count(get;)

Devuelve el número de entradas incluidas en la lista.

LinkedListNode<E> First(get;) LinkedListNode<E> Last(get;)

Obtiene el primer y el último nodo de la lista respectivamente.

void AddAfter(nodo, nodoNuevo) void AddBefore(nodo, nodoNuevo)

Añade un nuevo nodo antes o después del nodo indicado.

void AddFirst(nodo) void AddLast(nodo)

Añade un nuevo nodo al principio o al final de la lista.

bool Find(E) Bool FindLast(E)

Encuentra la primera o la última ocurrencia del valor especificado.

void RemoveFirst() void RemoveLast()

Borra el primer o último nodo de la lista

void Remove(nodo)

Borra el nodo especificado de la lista.

void Clear()

Borra todos los nodos de la lista y la deja vacía. 171

Estructuras de datos LinkedList<E> // Creamos y manipulamos una lista enlazada public static void Main(string[] args){ readonly string[] colores = { “negro”, “amarillo”, “verde", “azul”, “violeta”, “plata” }; LinkedList<string> lista = new LinkedList<string>(); // añade elementos a la primera lista enlazada foreach ( string color in colores ){ lista1.AddLast( color ); } // escribimos la lista original Console.WriteLine(lista); //realizamos unos cambios lista.AddFirst(“oro”); lista.RemoveLast(); Console.WriteLine(lista); Console.WriteLine(“Contiene plata? {0}”,lista.Find(“plata”); } 172



2. Orígenes de C#




4. Sintaxis básica


5. Arrays

16. ADO.NET



7. Interfaces

18. ASP.NET


19. AJAX





20. LINQ


Ficheros y Streams Persistencia de datos  Las variables y colecciones sólo almacenan datos de forma temporal.  Los datos se pierden cuando la variable está fuera de ámbito o bien cuando el programa termina.  En contrapartida, los ficheros permiten retener esos datos ya que se almacenan en un medio físico (disco, cinta, etc.). Estos datos se suelen llamar datos persistentes.  Por esas dos razones es muy necesario que el programador conozca cómo el lenguaje en el que programa accede y manipula los ficheros del sistema.

174

Ficheros y Streams Ficheros en C#  C# contempla cada fichero como una secuencia de bytes.  Cuando un fichero se abre, se crea un objeto y un flujo (secuencia o stream) se asocia con ese objeto. Estos objetos facilitan la comunicación entre un programa y un fichero o dispositivo.  Cuando se ejecuta un programa, el entorno de ejecución crea un objeto consola (Console) con tres flujos:  Console.out es la salida estándar asociada a la pantalla.  Console.in es la entrada estándar asociada al teclado.  Console.error es la salida de mensajes de error, asociada también a la pantalla.

175

Ficheros y Streams Clases básicas  El espacio System.IO contiene una buena cantidad de métodos para leer y escribir archivos.  File y Directory manipulan con utilidades los ficheros y directorios del sistema de archivos.  Path es una clase de métodos estáticos que ofrece utilidades para el manejo de la ruta de un archivo. Sus métodos se basan en operaciones sobre string que contienen la ruta.  La clase abstracta Stream ofrece la funcionalidad para representar streams como bytes. Las clases FileStream, MemoryStream y BufferedStream heredan de Stream y añaden algunas características propias.  FileStream se usa para escribir y leer datos de ficheros.

176

Ficheros y Streams Ficheros y directorios  Básicamente hay cuatro clases para manejar los directorios (carpetas) y ficheros (archivos) de un disco duro.  Directory es una clase de métodos estáticos y por lo tanto pueden usarse sin necesidad de instanciar ningún objeto. Todos los métodos requieren especificar la ruta sobre la cual se trabajará.  DirectoryInfo, al contrario, es una clase de instancia, es decir, que necesita de objetos para poder operar. Para operar con un directorio hay q indicarle su ruta en el constructor del objeto.  File y FileInfo son análogas a Directory y DirectoryInfo respectivamente pero orientada al trato de ficheros.  Se recomienda que si se va a usar varias veces el a ficheros no se implemente a través de las clases estáticas.

177

Ficheros y Streams La clase File Método / Propiedad

Descripción

AppendText

Devuelve un StreamWriter que añade texto a un fichero existente o creado

Copy

Copia un fichero en otro nuevo.

Create

Crea un fichero y devuelve su FileStream asociado

CreateText

Crea un fichero de texto devolviendo un StreamWriter.

Delete

Borra el fichero indicado.

Exist

Devuelve true si el fichero especificado existe y false si no

GetCreationTime

Devuelve un objeto DateTime con la fecha de creación del fichero

GetLastAccessTime

Devuelve un DateTime con la fecha del último al fichero

GetLastWriteTime

Devuelve un DateTime con la fecha de la última modificación

Move

Mueve un fichero a otra ubicación dada como argumento

Open

Devuelve un FileStream con los permisos de lectura/escritura indicados.

OpenRead/Text/Write

Devuelven un FileStream, StreamReader o FileStream respectivamente. 178

Ficheros y Streams La clase Directory Método / Propiedad

Descripción

CreateDirectory

Crea un directorio y devuelve su objeto DirectoryInfo asociado.

Delete

Borra el directorio indicado.

Exists

Devuelve true si existe el directorio especificado.

GetDirectories

Devuelve un array de string con los nombres de los subdirectorios del directorio indicado.

GetFiles

Devuelve un array de string con los nombres de los ficheros del directorio.

GetCreationTime

Devuelve un objeto DateTime representando la fecha y hora de creación del directorio.

GetLastAccessTime

Devuelve un DateTime con la fecha del último .

GetLastWriteTime

Devuelve un DateTime con la fecha del último cambio hecho en el directorio.

Move

Mueve el directorio a otro lugar. 179

Ficheros y Streams Secuencias  Las clases de secuencia o streams proporcionan un mecanismo para hacer referencia a un espacio de datos, los cuales de normal se leen y almacenan uno detrás de otro.  Comparten una base común llamada Stream que está definida en el espacio de nombres System.IO y que contiene propiedades y métodos que permiten a los programas trabajar con secuencias de datos.  Existen varias clases que derivan de ella y proporcionan una implementación específica usada para un entorno particular.  Sólo iten a datos a nivel de byte con métodos como Read() o Write(); sin embargo, trabajar a tan bajo nivel puede no ser lo mejor.

180

Ficheros y Streams La clase FileStream Método / Propiedad

Descripción

FileStream

Constructor sobrecargado. Todos deben especificar un string que contenga la ruta del fichero y un modo de apertura (abrir, abrir y crear, append, etc.). Es recomendable indicar también el tipo de (lectura, escritura o ambas).

Read

Lee un bloque de bytes de la secuencia y escribe los datos en un búfer dado.

ReadByte

Lee un byte del archivo y avanza la posición de lectura un byte.

Write

Escribe un bloque de bytes en esta secuencia mediante el uso de datos de un búfer.

WriteByte

Escribe un byte en la posición actual de la secuencia de archivo.

Close

Cierra la secuencia actual y libera todos los recursos (como sockets e identificadores de archivo) asociados a ésta.

Seek

Establece la posición actual de esta secuencia actual en el valor dado.

Flush

Al sobrescribir en una clase derivada, borra todos los búferes de esta secuencia y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. 181

Ficheros y Streams Clases lectoras y escritoras  Para paliar el inconveniente de tratar con bytes en los streams existen clases lectoras y escritoras que permiten leer y escribir datos de mayor nivel en secuencias.  La mayoría de estas clases tienen asociado un objeto Stream que se pasa en el constructor como parámetro.  Una característica que tienen es que los respectivos métodos Read() y Write() están sobrecargados para poder aceptar otros datos como int, long o double.  Sus implementaciones al final convierten los tipos de datos en una secuencia de bytes que se pasa al objeto Stream.

182

Ficheros y Streams Las clase BinaryReader y BinaryWriter Método / Propiedad

Descripción

BinaryReader BinaryWriter

Constructores de ambas clases. Necesitan un Stream o un string con la ruta del fichero.

BaseStream

Propiedad que devuelve la secuencia asociada al lector/escritor.

Close

Cierra el lector/escritor y libera todos los recursos.

Read

Lee un conjunto de caracteres y los almacena en un array

ReadBoolean ReadChar ReadByte ReadDecimal ReadDouble ReadInt16/32/64 ReadString

Lee un dato de la secuencia y lo transforma en un tipo básico.

ReadBytes ReadChars

Lee N bytes de la secuencia actual en un array de bytes y hace avanzar la posición actual en N bytes.

Write

Escribe un valor en la secuencia actual. 183

Ficheros y Streams La clase StreamReader y StreamWriter Método / Propiedad

Descripción

StreamReader StreamWriter

Constructores de ambas clases. Necesitan un Stream o un string con la ruta del fichero.

BaseStream

Propiedad que devuelve la secuencia asociada al lector/escritor.

Read

Lee el siguiente carácter o conjunto de caracteres de la secuencia de entrada.

ReadBlock

Lee el número máximo de caracteres especificado por la variable count de la secuencia actual y escribe los datos en buffer, empezando en index.

ReadLine

Lee una línea de caracteres de la secuencia actual y devuelve los datos como un string.

ReadToEnd

Lee la secuencia desde la posición actual hasta el final de la secuencia.

Write

Escribe en la secuencia.

WriteLine

Escribe algunos datos que especifican los parámetros sobrecargados, seguidos de un terminador de línea.

184

Ficheros y Streams Ejemplo using System.IO; public class Cuenta { int numero; string titular; double saldo; public Cuenta(int num, string tit, double sald){ numero = num; titular = tit; saldo = sald; }

}

185

Ficheros y Streams Ejemplo // escritura de fichero Cuenta[] cuentas; //suponemos que la tabla ya tiene valores try { // creamos un stream de escritura en el fichero FileStream fs = new FileStream(“cuentas.dat”, FileMode.OpenOrCreate, FileAccess.Write); // creamos un escritor y asociamos su stream de escritura StreamWriter sw = new StreamWriter(fs); foreach(Cuenta cnt in cuentas){ // escribimos cada cuenta en una línea sw.WriteLine(“{0},{1},{2}”, cnt.numero, cnt.titular, cnt.saldo); } fw.close(); } catch (IOException ioe){ ConsoleWriteLine(“Error en la escritura de ficheros”); }

186

Ficheros y Streams Ejemplo // lectura de fichero try { // creamos un stream de lectura en el fichero FileStream fs = new FileStream(“cuentas.dat”, FileMode.Open, FileAccess.Read); // creamos un lector y asociamos su stream de lectura StreamReader sr = new StreamReader(fs); String currentLine = sr.ReadLine(); while (currentLine != null){ String[] values = currentLine.split(„,‟) Console.WriteLine(“{0} {1} {2}”, values[0], values[1], values[2]); currentLine = sr.ReadLine(); } sr.close(); } catch (IOException ioe){ ConsoleWriteLine(“Error en la lectura de ficheros”); } 187

Ficheros y Streams Serialización  En el ejemplo anterior hemos visto cómo leer y escribir datos de tipos simples en ficheros.  El problema de operar de forma anterior es que no guardamos el tipo de datos en los ficheros.  Por ejemplo, nadie nos dice que al leer un 3 este dato sea un int, un decimal o un string.  En consecuencia, el programador debe saber de antemano los tipos de datos y la codificación interna del fichero lo que a veces es imposible.  A veces es más sencillo leer o escribir directamente objetos y los lenguajes de programación soportan este mecanismo, llamado serialización.

188

Ficheros y Streams Serialización  La serialización consiste en transformar un objeto en una secuencia de bytes conservando datos y a la vez los tipo de éstos.  Después de que un objeto serializado se haya grabado en algún fichero, podrá leerse del fichero y deserializarlo, es decir, que el tipo de información y los bytes que representan el objeto y sus datos puedan utilizarse para reconstruir el objeto en memoria.  Además, la serialización es importante porque se puede usar para trasmitir objetos entre aplicaciones a través de una red.

189

Ficheros y Streams Serialización de clases  Para declarar una clase como serializable hay que añadir el atributo [Serializable] o implementar la interfaz ISerializable en su definición. [Serializable] class SerialA { class Serial B:A, ISerializable { int x; Serial A a; } }  Hay que asegurar que cada atributo de clase está también serializado.  Los tipos simples y los string están ya serializados.  Los tipos referencia deben ser también serializables así como sus clases base.  Los arrays son también serializables por defecto, pero puede que sus objetos no lo sean.

190

Ficheros y Streams Formateadores binarios  Para realizar la serialización se utiliza un formateador binario BinaryFormatter ubicado en System.Runtime.Serialization.Formatters.Binary.  El método Serialize de dicha clase lleva a cabo la serialización propiamente dicha (grabar el objeto en disco), indicando como parámetros el stream donde se va a grabar el objeto y el objeto en sí.  La parte complementaria consiste en reconstruir el objeto del stream en otro o en el mismo programa. El proceso es ahora inverso al anterior. En primer lugar se crea una secuencia de lectura asociada al archivo que contiene objetos. A continuación se vuelve a usar el formateador con el método Deserialize, que devuelve un object al que hay aplicarle downcasting.

191

Ficheros y Streams Formateadores binarios using System.Runtime.Serialization.Formatters.Binary; class A { int a; double d; string msg; } // Serialización BinaryFormatter bf = new BinaryFormatter(); FileStream fs = new FileStream(“miFichero.txt”, FileMode.OpenOrCreate, FileAccess.Write); bf.Serialize(fs, new A(5, 7.2, “Buenos días”)); // Deserialización BinaryFormatter bf = new BinaryFormatter(); FileStream fs = new FileStream(“miFichero.txt”, FileMode.Open, FileAccess.Read); A miA = (A) bf.Deserialize(fs); Console.WriteLine(“Valores de miA: {0}, {1}, {2}”, miA.a, miA.d, miA.msg); 192



2. Orígenes de C#




4. Sintaxis básica


5. Arrays

16. ADO.NET



7. Interfaces

18. ASP.NET


19. AJAX





20. LINQ


Multitarea en C# Introducción  Los ordenadores actuales pueden efectuar operaciones concurrentemente, siendo habitual en un sistema, por ejemplo, que se compile un programa, imprimir un fichero y recibir mensajes de correo sobre una red, todo simultáneamente.  Irónicamente, la mayoría de los lenguajes de programación más antiguos no permiten a los programadores especificar actividades concurrentes. Más bien, los lenguajes ofrecen solamente un conjunto de sentencias de control que posibilitan a los programadores ejecutar una acción a la vez, procediendo a la siguiente acción después de que haya terminado la primera.  Históricamente, el tipo de concurrencia ejecutada en los computadores de hoy, se ha implementado generalmente por llamadas a primitivas del sistema, disponibles sólo a programadores de alta experiencia en la programación de sistemas.

194

Multitarea en C# Introducción  La librería de clases de .NET Framework ofrece un conjunto de primitivas para la gestión de la concurrencia.  Para llevar a cabo esta tarea se designan porciones de programa que se pueden ejecutar paralelamente con otras. Cada porción se denomina hijo de ejecución o thread.  Esta forma de multitarea está disponible a todos los lenguajes de programación de .NET (incluyendo C#, Visual Basic y Visual C++) ubicado en el espacio System.Threading.  Un ejemplo del uso que se hace de la multitarea está en el propio comportamiento del recolector de basura (garbage collector) del CLR.  Un hilo se ejecuta en segundo plano recogiendo las referencias de memoria dinámica que han dejado de usarse.

195

Multitarea en C# Introducción  Algunas aplicaciones pueden sacar partido del multiprocesamiento:  Aplicaciones con procesos largos. Los procesos duraderos pueden ejecutarse en un segundo plano.  Aplicaciones de sondeo y escucha. Se pueden aprovechar las esperas en rutinas como conectarse a un servidor, esperar por ver el contenido de un buzón de correo, etc.  Aplicaciones gráficas con botón Cancelar. En realidad, el propio GUI tiene este rasgo de comportamiento que convierte una buena aplicación en una aplicación destacable.

196

Multitarea en C# Declaración de threads  Para poder usar threads son necesarios los siguientes ingredientes:  Un método que devuelva void y que no tenga ningún parámetro o que tenga un único de tipo object.  Un delegado al que se le asignará el método anterior. Dependiendo de los parámetros del método se usarán los siguientes delegados:  ThreadStart para los métodos sin parámetros.  ParametrizedThreadStart para los métodos con parámetro object. Si se desean múltiples parámetros se deben encapsular en una colección, array o estructura.  Un objeto de la clase Thread. El delegado se le tiene que pasar en el constructor con el método ya asignado.

197

Multitarea en C# Declaración de threads public void metodo(){ Console.WriteLine(“Ejecutado metodo()”); } public void metodo2(object o){ Console.WriteLine(“Ejecutado metodo2({0})”, o.ToString()); } //Delegado sin parámetros ThreadStart ts1 = new ThreadStart(this.metodo); //Delegado parametrizado ParametrizedThreadStart ts2 = new ParametrizedThreadStart(this.metodo2); //Declaramos los threads Thread thread1 = new Thread(ts1); Thread thread2 = new Thread(ts2); // Ejecutamos los threads thread1.Start(); thread2.Start(“Hola! Soy un hilo parametrizado”);

198

Multitarea en C# Ciclo de vida

199

Multitarea en C# Ciclo de vida  Unstarted. El hilo aún no ha sido ejecutado. Es el estado inicial al crear una nueva instancia de Thread.  El hilo permanece en estado Unstarted hasta que el programa llame al método Start, que pone al hilo en estado Running, e, inmediatamente devuelve el control a la parte del programa que llamó a Start.  Running. El hilo se halla en ejecución.  El hilo se ejecuta en estado Running sólo cuando el sistema operativo le asigne procesador.  Cuando un hilo Running recibe un procesador la primera vez, comienza la ejecución del método indicado en su delegado ThreadStart.

200

Multitarea en C# Ciclo de vida  Stopped. La ejecución ha terminado de forma satisfactoria o bien el ha pedido explícitamente que el hilo aborte su ejecución.  Un hilo Running entra al estado Stopped (o Aborted) cuando su delegado ThreadStart finaliza, lo que suele indicar que el hilo ha completado su tarea.  Un programa puede forzar a un hilo que entre al estado Stopped llamando al método Abort del objeto hilo. Lanzará una excepción.  Cuando un hilo está en estado Stopped y no hay referencias a ese objeto, el recolector de basura puede borrar el objeto de memoria.  Blocked. Al hilo les es imposible usar el procesador aunque haya uno libre. Es un estado conceptual.  Suele suceder cuando el hilo se halla esperando la finalización de una operación de E/S del sistema operativo.

201

Multitarea en C# Ciclo de vida  Suspended. La ejecución del hilo se ha suspendido explícitamente por el programador. Se puede volver activarse y pasar al estado Running.  WaitSleep. El hilo se halla esperando a que un recurso se libere, está dormido o bien espera el final de ejecución de otro hilo. Al salir de este estado vuelve a estar activo como Running.  Si un hilo encuentra código que no puede ejecutar (normalmente porque no se satisface una condición), se llama al método Wait. Una vez así, un hilo retornará de nuevo a Running cuando otro hilo invoque el método Pulse (o PulseAll) de la clase Monitor.  Un hilo en ejecución puede llamar al método Sleep y se quedará durmiendo durante un número de milisegundos (parámetro) y luego despertará. Mientras duermen los hilos no pueden usar procesador, incluso si lo hubiese disponible.

202

Multitarea en C# Ciclo de vida  WaitSleep (continuación).  Si un hilo no puede continuar ejecutándose (es dependiente) a menos que otro hilo termine, el hilo dependiente puede llamar al método de Thread para juntar los dos hilos. Cuando se han juntado, el dependiente abandona el estado WaitSleep y recupera su estado Running cuando el otro hilo finalice su ejecución (entrando a Stopped).  Cualquier hilo que entre al estado WaitSleep por la llamada del método Wait de Monitor o llamando al método Sleep de Thread, también dejará el estado WaitSleep y regresará al estado Running si el hilo que está durmiendo o esperando se interrumpe por otro hilo en el programa que invoque su método Interrupt, de la clase Thread. Esto ocasiona una excepción ThreadInterruptionException sobre el hilo interrumpido.

203

Multitarea en C# Prioridades y planificación  Cada hilo tiene una prioridad en el rango comprendido entre  ThreadPriority.Highest (la más alta)  ThreadPriority.AboveNormal  ThreadPriority.Normal  ThreadPriority.BelowNormal (prioridad establecida por defecto)  ThreadPriority.Lowest  El S.O. Windows soporta el concepto de timeslicing, que hace posible que hilos de igual prioridad compartan la U, puedan alternar su ejecución y ninguno monopolice su uso.  Cada hilo recibe un breve tiempo de la U, denominado quantum, durante el cual el hilo puede ejecutarse. Al finalizar el quantum, el hilo ejecutable se desaloja del procesador (incluso si el hilo no ha finalizado su tarea), y su lugar lo ocupa el siguiente hilo de igual prioridad, si hay alguno.

204

Multitarea en C# Prioridades y planificación  La tarea del scheduler (o planificador) es mantener en ejecución todos los hilos empezando con los de prioridad más alta de forma que asegura que todos aquellos de un mismo nivel de prioridad consumen un quantum en un ciclo Round-Robin. Hilos preparados

Prioridad Highest

A

Prioridad AboveNormal

C

B

Prioridad Normal Prioridad BelowNormal

D

Prioridad Lowest

G

E

F

205

Multitarea en C# Prioridades y planificación  La prioridad de un hilo puede ser ajustada con la propiedad Priority, que acepta como valores los de la enumeración ThreadPriority antes citada.  Un hilo se ejecuta hasta que muere, se bloquea por E/S (u otra razón), llama a Sleep, Wait (de Monitor) o , es desalojado por otro hilo de prioridad superior o su quantum expira.  Un hilo de prioridad más alta que el que se está ejecutando puede llegar a ejecutarse (y por lo tanto, desalojar al primer hilo ejecutable) cuando  Este hilo estaba durmiendo y se despierta.  Al completar una E/S.  Otro hilo ejecuta los métodos Pulse o PulseAll que hacen liberar a otro hilo.  Si continua su ejecución (método Resume) tras hallarse suspendido.  Si completa la espera porque otro de alta prioridad estaba esperando ().

206

Multitarea en C# Sincronizando threads  A veces, múltiples hilos en ejecución operan sobre datos compartidos de forma que varios de ellos pueden leer esa información de modo simultáneo sin mayor problema.  Sin embargo, cuando esos datos se modifican por uno o más threads, los resultados pueden ser indeterminados. Si un hilo está en el proceso de actualizar el dato y otro intenta actualizarlo también, el dato reflejará sólo el último cambio.  Este problema se agrava cuando la información motivo de la actualización es una estructura de datos como un array, manipulada por varios threads, por ejemplo. Cada thread puede atacar a la vez un array pudiendo sobrescribir algunos datos.

207

Multitarea en C# Sincronizando threads  Para prevenir este fallo, se puede dar a un hilo el exclusivo en su código para acceder a los datos compartidos. Durante ese tiempo, otros hilos que intenten manipular los datos, deberán esperar. Cuando el hilo con el exclusivo complete su operación sobre los datos, los otros hilos que esperaban podrán entonces acceder.  De esta manera, cada hilo que accede a los datos compartidos, evita que todos los otros hilos hagan lo mismo a la vez. Este proceso se denomina sincronización de hilos o exclusión mutua.

208

Multitarea en C# Abrazos mortales  A veces es frecuente incurrir en el siguiente error común por un mal diseño de la multitarea.  Ocurre cuando un hilo en espera no puede continuar debido a que está esperando, directa o indirectamente, un segundo hilo, y éste segundo está esperando al primero. Esta situación anómala se denomina abrazo mortal o deadlock.  Si múltiples hilos esperan por un objeto compartido, otro hilo independiente podría llamar a PulseAll (o Pulse) como forma segura de que todos los hilos que esperan tengan la oportunidad de hacer su tarea. Si no se hace así, el aplazamiento indefinido puede dar lugar al abrazo mortal.

209



2. Orígenes de C#




4. Sintaxis básica


5. Arrays

16. ADO.NET



7. Interfaces

18. ASP.NET


19. AJAX





20. LINQ


ADO.NET Introducción  Como sabemos, una base de datos es una colección de datos relacionados.  Un SGBD (sistema gestor de base de datos) o DBMS (database management system) ofrece los mecanismos para almacenar, organizar, recuperar y modificar los datos a los s que lo requieran.  Hoy por hoy, las bases de datos más populares son las de estructura relacional y el lenguaje SQL es el más ampliamente utilizado con bases de datos relacionales para ejecutar consultas.

211

ADO.NET Introducción  Un lenguaje de programación se conecta e interactúa con una base de datos relacional por medio de un software que facilita la comunicación entre el SGBD y el programa. C# se comunica con la base de datos y manipula la información a través de ADO.NET.  La versión actual de ADO.NET es la 2.0.  Sin embargo, como se verá más adelante, mucho del trabajo que se requiere para comunicar con una base de datos usando ADO.NET 2.0 lo lleva a cabo el IDE por sí mismo.  Es más habitual trabajar con herramientas, asistentes, etc., lo que simplifica el proceso de conectar y manipular una base de datos.  Es más fácil trabajar con ADO.NET 2.0 que con el antiguo ADO.NET.

212

ADO.NET Modelo de objetos  El modelo de objetos ADO.NET ofrece un API para el a base de datos por parte de programas.  ADO.NET se creó por el marco .NET para reemplazar al Microsoft‟s ActiveX Data ObjectsTM (tecnología ADO).  Las características visuales del IDE y sus herramientas simplifican el proceso de utilizar una base de datos en los proyectos.  Aunque no se necesite trabajar directamente con muchos objetos de ADO.NET para desarrollar aplicaciones simples, el conocimiento básico de cómo funciona el modelo ADO.NET es importante para comprender el a orígenes de datos con C#.

213

ADO.NET Espacios de nombres  Existen tres nombres de espacios propios de ADO.NET:  System.Data  Espacio de nombres raíz. Contiene las clases que tratan los datos de forma independiente al SGBD.  System.Data.OleDb  Contiene las clases para conectarse a cualquier fuente de datos usando la tecnología ADO.NET 1.0  System.Data.SqlClient  Contiene clase optimizadas para una conexión a un SGBD Microsoft SQL Server

214

ADO.NET Conexiones  OleDbConnection y SqlConnection  Representan conexiones a una fuente de datos. Mientras que la primera representa una conexión a una fuente de datos genérica, la segunda es específica y optimizada para SQL Server.  Estas clases llevan la pista de la ubicación de la fuente de datos y contienen valores que indican cómo debe ser accedida.  Las conexiones deben abrirse y cerrarse.  Al usar una conexión es necesario especificar explícitamente una propiedad llamada ConnectionString. Esta cadena de conexión nos indica el lugar donde está ubicada la fuente de datos así como el , contraseña. Etc. Veámoslo en la siguiente tabla.

215

ADO.NET Conexiones Parámetro

Descripción

Provider

El nombre o marca comercial del proveedor a utilizar (Jet, SQL u otros)

DataSource

Nombre de la fuente de datos (la base de datos) a la que nos conectaremos

UID

Un nombre de válido

PWD

de para el

DRIVER

Nombre del controlador utilizado como intermediario por la base de datos. No se requiere si un DSN ya lo tiene especificado

SERVER

Nombre de la red del servidor de base de datos.

 Por ejemplo, aquí se muestra un ejemplo de una cadena de conexión para una base de datos Microsoft Access (usado con OleDbConnection): “Provider=Microsoft.Jet.OLEDB.4.0; Data Source=C:\\Tfnos.mdb”  Otro ejemplo con una conexión a SQL Server (usado con SqlConnection): “server=localhost; uid=itsMe; pwd=1234; database=northwind”

216

ADO.NET Objetos  DataTable  Representa una tabla de datos. Contiene todos los valores de una tabla así como los metadatos (información de columnas, claves primarias y foráneas, etc.)  DataRow  Representa una fila (registro) de una tabla. Una DataTable contiene una colección de DataRow.  DataColumn  Representa una columna de una tabla. Contiene los metadatos de dicha columna. Una DataTable contiene una colección de DataColumn.  DataRelation  Representa una relación de clave foránea entre dos tablas. Se ha de especificar las dos columnas de las tablas que participan en la relación.

217

ADO.NET Dataset  La clase DataSet consiste en una caché de datos que un programa almacena temporalmente en la memoria local.  Está formada por un conjunto de DataTables y sus relaciones. La estructura de un DataSet imita la estructura relacional de una base de datos.  Un DataSet puede representar desde una tabla hasta toda un esquema de base de datos, aunque se recomienda un término intermedio.

218

ADO.NET Modelo desconectado  La ventaja de la clase DataSet respecto a trabajar en sincronía con la base de datos es que se desconecta del origen de datos cuando la aplicación no necesita una conexión persistente con la fuente de datos.  El programa se conectará a la fuente de datos para llenar el DataSet con datos, pero se desconecta de la fuente inmediatamente tras recuperar los datos de la misma.  A partir de entonces, el programa emplea la información almacenada en el DataSet accediendo a esta caché local de datos en lugar de los originales.  Si el programa hace cambios en los datos del DataSet se volverá a reconectar al origen para efectuar la actualización y volver a desconectar rápidamente.  Así el programa no requiere una conexión continuamente activa (persistente).

219

ADO.NET Comandos y adaptadores  Junto con los DataSet se conjugan otros dos tipos de objetos para tratar más amigablemente con las bases de datos.  Los comandos (Command) son objetos que envían instrucciones a la base de datos, ya sean consultas de SQL (select, insert, update, delete u otras) o bien procedimientos almacenados.  Se suelen crear implícitamente al general el DataSet aunque también se pueden explicitar  Los adaptadores (Adapter) hacen de puente y de canal de comunicación entre el origen de datos y el DataSet desconectado.  Desacoplan el DataSet de la base de datos permitiendo múltiples orígenes de datos en un único DataSet.

220

ADO.NET Comandos y adaptadores  Los adaptadores se encargan de crear y gestionar la conexión (objeto Connection) con la fuente de datos origen.  Suelen estar asociados a una tabla de la base de datos  Por este motivo contienen cuatro comandos (objetos Command) para representar las consultas select, insert, update y delete relacionadas con la tabla.  Al crear un adaptador se piden dos parámetros:  Una cadena de conexión para conectarse a la fuente de datos.  Una consulta Sql que representa la instrucción select sobre la tabla (se generará un comando).  Para asociar un DataSet y rellenarlo con los datos se debe invocar el método Fill() del adaptador.

221

ADO.NET El componente DataGrid  Un DataGrid es una componente visual que permite de forma rápida modificar los registros de una tabla (es muy similar a la edición de tablas con Access).  Crear un DataGrid y asociarlo a una tabla es muy sencillo  Buscar DataGridView en el Cuadro de Herramientas  Datos  Arrastrarlo al formulario para crearlo  En la vista de Orígenes de datos, buscar la tabla que se quiera asociar al DataGrid.  Arrastrar la tabla y soltarla dentro del DataGridView. Éste último cambiará sus columnas por las de la tabla.

222

ADO.NET El componente DataGrid  BindingSource  Funciona como puente entre la fuente de datos (DataSet) y el componente gráfico (en este caso un DataGrid).  Desacopla la lógica de datos de la manera de representarlo (interfaz gráfica)  Funciona de controlador entre el DataGrid y su navegador  BindingNavigator  Navegador situado encima del DataGrid. Permite avanzar y retroceder entre registros, así como crear y eliminarlos y aceptar cambios. Es la lógica de control del DataGrid.  A nivel de implementación no se comunica directamente con DataGridView, sinó que lo hace a través del BindingSource.

223

ADO.NET Arquitectura de comunicación basedatos.mdb

Ejecuta comandos SQL contra…

TableAdapter Actualiza la BD con los datos actuales en…

Pone los resultados de las consultas de la BD en…

DataSet Contiene…

datos

Encapsula…

BindingSource Aplica cambios a los datos basados en la entrada de a través de…

DataGridView

Muestra los datos desde…

Navega / Manipula los datos a través de…

BindingNavigator 224

ADO.NET Añadiendo nuevas consultas  El TableAdapter contiene dos métodos que tratan la consulta SELECT * FROM  Fill(dt) rellena un DataTable dt que responde a la query anterior.  GetTable() devuelve una DataTable cuyos datos son los proporcionados por la consulta anterior.  Pero se pueden especificar más consultas a parte de las proporcionadas. El asistente de consultas lo permite y facilita. Hay que seguir los siguientes pasos:  Explorador de soluciones  EmpleadosDataSet.xsd. Clic derecho  Ver diseñador. Se mostrará un diagrama con las entidades y relaciones del DataSet.  Seleccionar un TableAdapter. Clic derecho  Agregar consulta…  Seleccionamos Usar Instrucciones SQL. Ahora escogemos el tipo de consulta a realizar (SELECT, INSERT, etc.)  Escribimos la consulta o bien la generamos al estilo de Access.

225

ADO.NET Añadiendo nuevas consultas  Una vez creada la consulta, le damos un nombre y finalizamos.  El nombre que le hemos dado a la consulta sirve para nombrar los métodos que se han creado de forma automática.  Si se trata de una select, genera dos métodos: un Fill(…) y un Get(…)  Si se trata de otra operación (insert, update, delete), genera un método respecto a la operación.  Estos métodos se usarán a conveniencia del invocándolos desde eventos u otros métodos.

226



2. Orígenes de C#




4. Sintaxis básica


5. Arrays

16. ADO.NET



7. Interfaces

18. ASP.NET


19. AJAX





20. LINQ


Patrones de diseño Introducción  Los patrones de diseño (Design Patterns) son la base para la búsqueda de soluciones a problemas comunes en el desarrollo de software y otros ámbitos referentes al diseño de interacción o interfaces.  Un patrón de diseño es una solución a un problema de diseño no trivial.  Es efectiva. Ya se resolvió el problema satisfactoriamente en ocasiones anteriores).  Es reutilizable. Se puede aplicar a diferentes problemas de diseño en distintas circunstancias.  No son bibliotecas de clases, sino más bien un esqueleto básico que cada desarrollador adapta a las peculiaridades de su aplicación.

228

Patrones de diseño Introducción  Los patrones se describen en forma textual, acompañada de diagramas y pseudocódigos.  En este curso veremos su representación en UML.  Tuvieron un gran éxito a partir de la publicación del libro Design Patterns escrito por el GoF (Gang of Four: Gamma, Helm, Johnson, Vlissides), en el que se recogían 23 patrones de diseño clasificados en tres categorías.

229

Patrones de diseño Niveles de patrones  En Pattern Oriented Software Architecture, Volume 1 ([Buschmann96]), se define una taxonomía como la que se muestra en la siguiente figura. Los patrones en cada grupo varían respecto a su nivel de detalle y abstracción.

 Es importante destacar que esta división no es absoluta ni totalmente comprensiva, dado que no incluye a otros patrones de amplia aceptación y utilización como los de análisis, integración de aplicaciones, pruebas, etc.

230

Patrones de diseño Ventajas  Son soluciones concretas. Un catálogo de patrones es un conjunto de recetas de diseño. Aunque hay clasificaciones de patrones, cada uno es independiente del resto.  Son soluciones técnicas. Dada una determinada situación, los patrones indican cómo resolverla mediante orientación a objetos. Hay patrones específicos para un determinado lenguaje y otros más generales.  Se aplican en situaciones muy comunes. Los patrones de diseño proceden de la experiencia y han demostrado su utilidad resolviendo problemas que aparecen frecuentemente en el diseño orientado a objetos

231

Patrones de diseño Ventajas  Son soluciones simples. Indican cómo resolver un problema particular utilizando un pequeño número de clases relacionadas de forma determinada. No indican cómo diseñar un determinado sistema sino sólo aspectos puntuales del mismo.  Facilitan la reutilización de las clases y el propio diseño. Los patrones favorecen la reutilización de clases ya existentes y la programación de clases reutilizables. La propia estructura del patrón es reutilizada cada vez que se aplica.

232

Patrones de diseño Inconvenientes  El uso de un determinado patrón no se refleja claramente en el código. A partir de la implementación es difícil determinar qué patrón de diseño se ha utilizado.  Referencias a self (o this). Muchos patrones utilizan la delegación de operaciones y esto provoca el problema del self. ¿Y yo quién era..?  Es difícil reutilizar la implementación de un patrón. Las clases del patrón son roles genéricos, pero en la implementación aparecen clases concretas.  Los patrones suponen una sobrecarga de trabajo a la hora de implementar. Se usan más clases, es necesario delegar mensajes, etc.

233

Patrones de diseño Objetivos  Un patrón de diseño describe una estructura recurrente de componentes que se comunican para resolver un problema general de diseño en un contexto particular.  Nombra, abstrae e identifica los aspectos clave de una estructura de diseño común, siendo así útiles para crear un diseño orientado a objetos reusable.  Identifica las clases e instancias participantes, sus roles, colaboraciones y la distribución de responsabilidades.

234

Patrones de diseño Elementos clave  Nombre  Permite describir, en una o dos palabras, un problema de diseño junto con sus soluciones y consecuencias.  Al dar nombres a los patrones estamos incrementando nuestro vocabulario de diseño, lo cual nos permite diseñar y comunicarnos con un mayor nivel de abstracción (en lugar de hablar de clases individuales nos referimos a colaboraciones entre clases).  Problema  Describe cuándo aplicar el patrón.  Explica el problema y su contexto.  A veces incluye condiciones que deben darse para que tenga sentido la aplicación del patrón.

235

Patrones de diseño Elementos clave  Solución  Describe los elementos que constituyen el diseño, sus relaciones, responsabilidades y colaboraciones.  La solución no describe un diseño o implementación en concreto, sino que es más bien una plantilla que puede aplicarse en muchas situaciones diferentes.  Consecuencias  Los resultados, así como ventajas e inconvenientes de aplicar el patrón

236

Patrones de diseño Clasificación según propósito  Patrones de creación.  Se refieren a la creación de instancias de las clases.  Ejemplo: el patrón Singleton.  Patrones estructurales  Se refieren a las relaciones entre clases u objetos  Ejemplo: los patrones Adaptador, Puente y Decorador  Patrones de comportamiento  Se refieren a la interacción y cooperación entre clases (algoritmos, etc.)  Ejemplo: Los patrones Estado e Iterador

237

Patrones de diseño Patrones según su ámbito  Patrones de clases  Se refieren a relaciones de herencia (estáticas) entre clases y subclases  Ejemplo: el patrón Adaptador (versión para clases)  Patrones de objetos  Se refieren a relaciones de uso (dinámicas) entre objetos  Ejemplo: el patrón Estado, el patrón Singular.

238

Patrones de diseño Clasificación final

De creación Clase

Ámbito

Objeto

Factory Method

Estructurales

Adapter (de clase)

De comportamiento

Interpreter Template Method

Abstract Factory

Adapter (de objetos)

Chain of Responsability

Builder

Bridge

Command

Prototype

Composite

Iterator

Singleton

Decorator

Mediator

Facade

Memento

Flyweight

Observer

Proxy

State Strategy Visitor

Tabla 1: Clasificación de patrones de diseño del GoF. 239



2. Orígenes de C#




4. Sintaxis básica


5. Arrays

16. ADO.NET



7. Interfaces

18. ASP.NET


19. AJAX





20. LINQ


ASP.NET Introducción  ASP.NET es un framework para aplicaciones web usado por programadores para construir sitios web dinámicos, aplicaciones web y servicios web.  Es la tecnología sucesora de ASP (Active Server Pages) y está construido sobre el CLR (Common Language Runtime), permitiendo a los programadores crear código ASP.NET utilizando cualquier lenguaje de programación itido por el .NET Framework.

241

ASP.NET Arquitectura

Global.asax Webconfig.xml

WebForms BIN INTERNET

Comp.

Base de datos Servicios WEB 242

ASP.NET Formularios Web 

Se dividen en varios archivos:  Diseño  Código  Diseñador

243

ASP.NET Páginas maestras  Permiten estructurar el contenido del sitio Web y agrupar funcionalidades comunes. Contienen regiones donde serán cargadas las páginas de contenido.  Hay que tener en cuenta:  Cada página de contenido se asigna que se carga un contenido se invoca también a los métodos de la MasterPage.  Cada vez que se carga un contenido se invoca también a los métodos de la MasterPage.  La página que se renderiza es el resultado de la unión del código de la Master y el conjunto de formularios mostrados

244

ASP.NET Páginas maestras  La página maestra tiene el siguiente aspecto:

Definición de la página maestra Código HTML común Definición del „hueco‟ contenedor

 La página maestra tiene su propia directiva de definición.

 El contentPlaceHolder define el „hueco‟ contenedor de las páginas que serán cargadas con esta Master. Una Master puede contener varios contentPlaceHolder.  Inicialmente un formulario sólo puede cargarse en una Master o cambiar su Master en tiempo de ejecución 245

ASP.NET Páginas maestras  El formulario Web tiene el siguiente aspecto: Página maestra “Padre” Fichero de clase Clase de la página de contenido Referencia a la clase maestra Identificador del receptáculo de contenido

 Cada formulario Web define en su directiva Page la referencia a la Master.

 El contentPlaceHolderID define el „hueco‟ donde será mostrada la página.  Las referencias a la clase maestra permiten hacer referencia a objetos de esta página.  Si una Master tiene varios huecos y la página no rellena todos ellos se respeta el contenido que exista en la Master. 246

ASP.NET Páginas maestras  Si una Master tiene varios huecos y la página no rellena todos ellos se respeta el contenido que exista en la Master.

247

ASP.NET Flujo de ejecución con páginas maestras  El orden de ejecución con páginas maestras se inicia en la página Web para continuar ejecutando el código de la página maestra

248

ASP.NET Modelo Code Inline  El modelo code inline o modelo de código interno es aquél código, incrustado directamente en la página ASP.NET. <%@ Page Language="C#" %> <script runat="server" language="C#"> void Click(Object sender, EventArgs e) { Etiqueta.Text = Texto.Text.ToString(); }

Net Framework 7263v

Overview 26281t

More details 6y5l6z

Related Documents 3h463d

Net Framework 7263v

.net Framework 4v3yd

Net Framework Cleanup Tool 116z1u

Net Compact Framework 3c5ct

Dot Net Framework(ppt) 2s1m2l

.net Framework 2.0. Zaawansowane Programowanie 352x5v

More Documents from "Jorge Herrero Fernández" 3r1762

4p345f

Ibm Cognos 10 Active Report Cookbook 2q3j3

Consolo La Soledad 23596l

4p345f

Temis.pdf h6t3c

Criteria For Judging 3q6430