Lenguaje de Programación C# Javier Segovia

Origen y necesidad de un nuevo lenguaje Creadores: Anders Hejlsberg y Scott Wiltamuth Necesidad: Específico para .NET Orientado a componentes Notas: Sintaxis de C/C++/Java con facilidad de VB BCL programada en C# -> depurado y optimizado Javier Segovia

Características de C# Sencillez Modernidad Orientado a objetos Autocontenido (sin IDLs, ficheros de cabecera,...) Sin elementos inneccesarios (::, macros, etc.) Tipo básicos de tamaño fijo Modernidad Tipos básicos para decimales, cadenas y lógicos Soporte extensible para colecciones Orientado a objetos Sin funciones ni variables globales Herencia simple Encapsulación con public,protected,private e internal. Redefinibildad explícita (menos errores y más eficiente) Javier Segovia

Características de C# Orientado a componentes Seguridad de tipos Soporte para propiedades, atributos y eventos Seguridad de tipos Control de conversiones Control de inicialización de variables Control de índices en accesos a tablas Control de desbordamientos Control de tipos en “punteros a función” Gestión automática de memoria Recolector de basura Javier Segovia

Características de C# Instrucciones seguras Sólo condiciones lógicas Sin traspasos implícitos entre casos de switch Sistema de tipos unificados Clase padre común System.Object Boxing y unboxing para homogeneidad y eficiencia Tipos básicos de tamaño fijo Extensibilidad de operadores Redefiniciones inteligentes y consistentes Indizadores Extensibilidad de tipos básicos Posibilidad de paso por referencia para eficiencia Javier Segovia

Hola Mundo using System; class HolaMundo Todo el código escrito en C# se ha de escribir dentro de una definición de clase, y lo que en la línea {su definición estará comprendida en estala llave : y su correspondiente llave de cierre public static void Main() se define un método de nombre {comienzo método Console.WriteLine(“¡Hola Mundo!”); }fin método } solicita la ejecución del método WriteLine() de la clase Console definida en el espacio de nombres System pasándole como parámetro la cadena de texto con el contenido ¡Hola Mundo! Javier Segovia

1.SINTAXIS BASICA Case-sensitive El lenguaje C# distingue entre mayúsculas y minúsculas, es decir, es case.sensitive En C# existe una regla a la hora de utilizar las mayúsculas y minúsculas, los métodos y las clases tienen la primera letra de cada una de sus partes en mayúscula. Los tipos simples del lenguaje C# se escriben con todas sus letras en minúscula. Javier Segovia

1.SINTAXIS BASICA Delimitador de setencias Comentarios Una sentencia se delimita por un punto y coma (;). Comentarios De una única línea: // antes del texto del comentario, sin ningún indicador de fin de comentario. varias líneas, en este caso el comentario irá entre los delimitadores /* */. Javier Segovia

1.SINTAXIS BASICA Bloques: C# utiliza las llaves ({} la primera de inicio y la otra de fin de bloque) para determinar los bloques dentro de un programa. Todo lo que se encuentra entre estas dos llaves se considera un bloque. Los bloques pueden y suelen anidarse Javier Segovia

2.DEFINICION VARIABLES Sintaxis básica: <tipo> <nombre> = <valorInicial>; Ejemplos: Persona p; int a = 5; Persona p = new Persona(“Juan”, 22); int a = 5, b, c =2; Persona p, q; Notas: Parámetros no compactables, sin <valorInicial>, separados por , y sin ; Valor defecto campos: null o cero de su tipo Valor defecto variables locales: ninguno Javier Segovia

2.DEFINICION VARIABLES Declaración de variables Para declarar una variable, primero indicamos el tipo de la variable y a continuación aparece el nombre de la variable. Si la variable posee algún modificador de acceso o de otro tipo, este modificador aparecerá antes del tipo de la variable. Javier Segovia

Tipos básicos Manipulación especial: System.Int32 x = 123; x = x + 5; System.Char c = ‘A’; c++; Alias: int x = 123; x = x + 5; char c = ‘A’; c++; Notas: Uso común. Muy optimizados Tamaño prefijado Javier Segovia

Tipos básicos sbyte (System.SByte) Enteros 8 bits con signo Rango: [-128, 127] Valores: Literales enteros (por defecto 0) byte (System.Byte) Enteros 8 bits sin signo Rango: [0, 255] Javier Segovia

Tipos básicos (II) short (System.Int16) Enteros 16 bits con signo Rango: [-32.768, 32.767 ] Valores: Literales enteros (por defecto 0) ushort (System.UInt16) Enteros 16 bits sin signo Rango: [0, 65.535] Javier Segovia

Tipos básicos (III) int (System.Int32) Enteros 32 bits con signo Rango: [-2.147.483.648, 2.147.483.647] Valores: Literales enteros (por defecto 0) uint (System.UInt32) Enteros 32 bits sin signo Rango: [0, 4.294.967.295] Javier Segovia

Tipos básicos (IV) long (System.Int64) Enteros 64 bits con signo Rango: [-9.223.372.036.854.775.808, 9.223.372.036.854.775.807] Valores: Literales enteros (por defecto 0L) ulong (System.Int64) Enteros 64 bits sin signo Rango: [0, 18.446.744.073.709.551.615] Valores: Literales enteros (por defecto 0UL) Javier Segovia

Tipos básicos (V) float (System.Float) Reales 32 bits con 7 dígitos de precisión Rango: [±1.5×10-45, ±3.4×1038] Valores: Literales reales (por defecto 0.0F) double (System.Double) Reales 64 bits con 15-16 dígitos de precisión Rango: [±5,0×10-324, ±1,7×10308] Valores: Literales reales (por defecto 0.0D) Javier Segovia

Tipos básicos (VI) decimal (System.Decimal) Reales 128 bits con 28-29 dígitos de precisión Rango: [1.0×10-28, 7.9×1028] Valores: Literales reales (por defecto 0.0M) char (System.Char) Caracteres Unicode 16 bits Rango: [‘\u0000’, ‘\uFFFF’ ] Valores: Literales carácter (por defecto ‘\0’) Javier Segovia

Tipos básicos (VII) string (System.String) Cadenas caracteres Unicode Rango: Cualquier longitud Valores: Literales de cadena (por defecto “”) bool (System.Boolean) Valores lógicos Rango: false, true Valores: Literales lógicos (por defecto false) Javier Segovia

Tipos básicos (VII) object (System.Object) Clase base Rango: Cualquier objeto Valores: objetos (por defecto null) Javier Segovia

1.SINTAXIS BASICA Ambito: El ámbito se refiere a la longevidad de las variables. Una variable existe sólo dentro del bloque donde ha sido declarada, eliminándola el compilador una vez que se sale de dicho bloque. Cuando una variable sale de ámbito, es eliminada y la memoria que ésta ocupaba es liberada por el recolector de basura (garbage collector). Javier Segovia

Categoría del Operador Operadores Categoría del Operador Operadores Primarios (x), x.y, f(x), a[x], x++, x--, new, typeof, sizeof, checked, unchecked Unarios +, -, !, ~, ++x, --x, (T)x Multiplicativos *, /, % Aditivos +, - De desplazamiento <<, >> Relacionales <, >, <=, >=, is Igualdad = =

1.SINTAXIS BASICA Operadores AND Lógico & XOR Lógico ^ OR Lógico | AND Condicional && OR Condicional || Condicional ?: Asignación =, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=

1.SINTAXIS BASICA Inicialización Para inicializar objetos se utiliza el operador de asignación (=) Javier Segovia

Tablas Concepto: Secuencia ordenada de objetos Características: Índice entero e iniciado en 0 Acceso controlado  OutOfBoundsException Tamaño variable (>=0) pero fijo Unidimensionales o multidimensionales Tablas dentadas Multiples tipos de objetos en tablas object Derivan de System.Array (sellada) Javier Segovia

Tablas (unidimensionales) Concepto: Único índice Ejemplos definición: int[] t = new int[5] {1,2,3,4,5}; int[] t = new int[] {1,2,3,4,5}; int[] t = {1,2,3,4,5}; int[] t = new int[5]; int[] t; Ejemplos manipulación: int[] t; t = new int[100]; t[10] = 19: t[9] = t[10] + t[8]; Javier Segovia

Tablas (multidimensionales) Concepto: Objetos distribuidos en varias dimensiones Ejemplos definición: int[,] t = new int[2,3] {{1,2,3}, {4.5.6}}; int[,] t = new int[,] {{1,2,3}, {4.5.6}}; int[,] t = {{1,2,3},{4,5,6}}; int[,] t = new int[2,3] int[,] t; Ejemplos manipulación: int[,] t = new int[3,3]; t[1,2]++; Javier Segovia

Tablas (dentadas) Concepto: Tablas de tablas Ejemplos definición: int[][] t = new int[2][] {new int[] {1,2}, new int[] {3,4,5}}; int[][] t = new int[][] {new int[] {1,2}, new int[] {3,4,5}}; int[][] t = {new int[] {1,2}, new int[] {3,4,5}}; int[][] t = {{1,2}, {3,4,5}} // ERROR COMÚN int[][] t = {new int[2], new int[3]}; int[][] t = new int[2][] ; int[][] t = new int[2][3] // ERROR COMÚN int[][] t; Javier Segovia

La clase System.Array Base: System.Object Algunos miembros: int Length // Sólo lectura int Rank; // Sólo lectura int GetLength (int dimensión) void CopyTo(Array destino, int posición) // destino ha de ser unidimensional Otros miembros: Ordenación, busquedas... Notas: Sellada Javier Segovia

2. INSTRUCCIONES Instrucción: Acción a realizar en el código de un método Bloque de instrucciones: Lista de instrucciones a ejecutar unas tras otra definida con la sintaxis: { <listaInstrucciones> } Notas: Variables declaradas en bloque sólo visibles en él En adelante, <instrucciones>=bloque instrucciones Javier Segovia

2. INSTRUCCIONES Instrucción nula: ; Asignación: <destino> = <fuente>; Llamada: <objetoOTipo>.<método>(<valores>); Definición variable: <tipo> <nombre> = <valorInicial>; Javier Segovia

Instrucciones condicionales (if) Sintaxis: if (<condición>) <instruccionesIf> else <instruccionesElse> Notas: <condición> ha de devolver bool Similar a operador ternario ? Javier Segovia

Instrucciones condicionales (switch) Sintaxis: switch (<expresión>) { case <caso1>: <instrucciones1> <siguiente1> case <caso2>: <instrucciones2> <siguiente2> default: <instruccionesDefecto> <siguienteDefecto> } Javier Segovia

Instrucciones condicionales (switch II) Ha de incluirse al menos un caso o default default en cualquier sitio, aunque evaluado como última alternativa <siguientei>puede ser: goto <casoi>;  Seguir por el bloque case <casoi> goto default;  Seguir por el bloque default break;  Finalizar la ejecución del switch Fácil reordenación Casos constantes y de tipos básicos enteros, char, string o enumeraciones No vale repetir valores en casos Javier Segovia

Instrucciones iterativas (while) Sintaxis: while (<condición>) <instrucciones> Notas: <instrucciones> puede ser una sola instrucción <condición> ha de devolver cierto Puede abortarse bucle con break; en <instrucciones> Puede pasarse a siguiente iteración con continue; Javier Segovia

Instrucciones iterativas (do while) Sintaxis: do <instrucciones> while (<condición>) Notas: Diferencia con while: se evalúa la condición DESPUES de ejecutar las instrucciones Igual por lo demás a while Javier Segovia

Instrucciones iterativas (for) Sintaxis: for (<inicialización>, <condición>, <incremento>) <instrucciones> Notas: Separar con , en <inicialización> e <incremento> <instrucciones> puede ser una única instrucción <condición> ha de ser de tipo bool Admite también break; y continue; Otros usos de <inicialización> e <incremento> Javier Segovia

Instrucciones iterativas (foreach) Sintaxis: foreach(<tipo> <nombre> in <colección>) <instrucciones> Notas: <colección> == null  NullReferenceException <tipo> compatible con colección <nombre> de sólo lectura Recorre tablas multidimensionales en orden Recorre objetos IEnumerable y patrón colección Javier Segovia

Instrucciones iterativas (foreach con IEnumerable) interface IEnumerable { IEnumerator GetEnumerator(); } Notas: Reset() coloca antes de principio de colección MoveNext() indica si quedan más elementos interface IEnumerator { void Reset(); bool MoveNext(); object Current {get;} } Javier Segovia

Instrucciones iterativas (foreach con patrón colección) Añadir GetEnumerator() que devuelva objeto con: Current: Devuelve elemento actual bool MoveNext() Devuelve bool que indica si quedan elementos Notas: Se usa patrón colección en vez de IEnumerable si se implementan ambos Código: Colecciones.cs Javier Segovia

Intrucciones de excepciones Excepción: Objeto que informa de mensaje de error. Derivan de System.Exception y por convenio acaban en Exception Ejemplos: Nombre (+ Exception) Causa DivideByZero División por 0 IndexOutOfRange Índice fuera de rango InvalidCastException Conversión inválida OverflowException Desbordamiento OutOfMemory Memoria agotada StackOverflow Pila desbordada Argument Argumento mal ArgumentNull Argumento nulo ArgumentOutOfRange Argumento fuera de rango Javier Segovia

Instrucciones de excepción (I) Miembros de System.Exception: string Message (virtual get;) exception InnerException {virtual get;} exception GetBaseException() string StackTrace {virtual get;} MethodBase Target {virtual get;} string HelpLink {virtual set;} Exception SetLink(string dirección) Javier Segovia

Intrucciones de excepción (crear nuevas excepciones) Derivar de System.Exception Darle nombre acabado en Exception Implementar constructores de System.Exception: Exception() Exception(string msg) Exception(string msg, Exception causante) Javier Segovia

Instrucciones de excepción (intrucción throw) Significado: Lanza una excepción Sintaxis: throw <objetoExcepción>; Ejemplo: throw new PruebaException(); Notas: Lanza System.NullReferenceException si es null el <objetoExcepción> especificado Relanza dentro de bloques catch <objetoExcepción> opcional en bloques catch Javier Segovia

Intrucciones de excepción (instrucción try) Significado: Gestiona tratamiento excepciones Sintaxis: try <instruccionesTry> catch (<tipoExcepción1> <obj1>) <instruccionesCatch1> ... finally <instruccionesFinally> Código: Excepciones.cs Javier Segovia

Instrucciones de excepción (instrucción try II) Notas: Al menos un catch o finally catch evaluados en orden No vale catch más prioritario que siguientes Si no se trata excepción en hilo se aborta hilo Si se aborta Main Fin aplicación y mensaje error Se continua tras el try que trate la excepción Finally siempre se ejecuta, tanto si se sale del try para buscar en padre como si se sale con un goto Opcionalidad elementos catch Relanzar con throw (pasando por finally) Javier Segovia

Instrucciones de salto break: Finaliza bucle continue: Finaliza iteración de bucle return: Finaliza método (return; o return <valor>;) Throw: Lanza una excepción Notas: Saltos pasan por finally break, continue y return no usables para salir de finally (throw sí) Javier Segovia

Instrucciones de salto (goto) Significado: Se continua ejecutando por la instrucción etiquetada con la etiqueta indicada Sintaxis goto: goto <etiqueta> Sintaxis etiquetas: <nombre> : Notas: ¡Instrucción maldita! No puede saltarse dentro de bloques internos Usable con etiquetas de switch pero sólo salto a etiquetas especiales del mismo switch Código:goto.cs Javier Segovia

Otras instrucciones (checked, unchecked) Siginificado: Idem aoperadores checked y unchecked pero aplicable a bloques de instrucciones Sintaxis: checked <instrucciones> unchecked <instrucciones> Notas: Por defecto constantes checked y variables unchecked Por defecto modificable a través opción /checked de csc y de View  Propety Pages  Configuration Settings  Build  Check for overflow underflow en VS.NET Código: checked.cs Javier Segovia

Otras instrucciones (lock) Significado: Asegura exclusión mutua Sintaxis: lock (<cerrojo>) <instrucciones> Equivale a: System.Threading.Monitor.Enter(<cerrojo>); try <instrucciones> finally {System.Threading.Monitor.Exit(<cerrojo>); Ejemplo: lock (typeof(Clase)) { a+=2; } Notas: lock más eficiente y compacto que equivalente <objeto> ha de ser de tipo referencia Javier Segovia

Otras instrucciones (using) Significado: Asegura limpieza de recursos Sintaxis: using (<declaraciones>) <instrucciones> Ejemplo: using (R r1 = new R()) {r1.F();} Equivale a: { R r1 = new R(); try {r1.F();} finally { if (r1!=null) (IDisposable) r1).Dispose(); } Javier Segovia

Otras instrucciones (using) Notas: Sólo un tipo en <declaraciones> Ha de implementar System.IDisposable: interface IDisposable { void Dispose();} Se llama a Dispose SIEMPRE, incluso al salir con goto o excepción <declaraciones> de solo lectura <declaraciones> solo visibles en <instrucciones> Varias <declaraciones> = anidado using Javier Segovia

¡Gracias! Javier Segovia