Javier Segovia 1

Javier Segovia
1
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
2
Características de C#
 Sencillez
 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
3
Características de C#
Orientado a componentes
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
4
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
para eficiencia
Javierreferencia
Segovia
5
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()
{
Console.WriteLine(“¡Hola Mundo!”);
}
se define un método de nombre
comienzo método
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
Javier Segovia
Mundo!
6
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
7
1.SINTAXIS BASICA
• Delimitador de setencias
– 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
8
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
9
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
10
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
11
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
12
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]
 Valores: Literales enteros (por defecto 0)
Javier Segovia
13
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]
Segovia
 Valores: LiteralesJavier
enteros
(por defecto 0)
14
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]
 Valores: Literales enteros (por defecto 0)
Javier Segovia
15
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]
Javier Segovia
16
 Valores: Literales enteros (por defecto 0UL)
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
17
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
18
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
19
Tipos básicos (VII)
object (System.Object)
 Clase base
 Rango: Cualquier objeto
 Valores: objetos (por defecto null)
Javier Segovia
20
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
21
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
==
22
1.SINTAXIS BASICA
• Operadores
AND Lógico
&
XOR Lógico
^
OR Lógico
|
AND Condicional
&&
OR Condicional
||
Condicional
?:
Asignación
=, *=, /=, %=, +=, -=, <<=,
>>=, &=, ^=, |=
23
1.SINTAXIS BASICA
• Inicialización
– Para inicializar objetos se utiliza el operador de
asignación (=)
Javier Segovia
24
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
25
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
26
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
27
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[][] {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
28
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
//
29
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
30
2. INSTRUCCIONES
 Instrucción nula: ;
 Asignación: <destino> = <fuente>;
 Llamada: <objetoOTipo>.<método>(<valores>);
 Definición variable: <tipo> <nombre> = <valorInicial>;
Javier Segovia
31
Instrucciones condicionales (if)
 Sintaxis: if (<condición>)

<instruccionesIf>

else

<instruccionesElse>
 Notas:
 <condición> ha de devolver bool
 Similar a operador ternario ?
Javier Segovia
32
Instrucciones condicionales
(switch)
 Sintaxis: switch (<expresión>)
{
case <caso1>: <instrucciones1>
<siguiente1>
case <caso2>: <instrucciones2>
<siguiente2>
default: <instruccionesDefecto>
<siguienteDefecto>
}
Javier Segovia
33
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
34
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
35
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
36
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
37
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
38
Instrucciones iterativas
(foreach con IEnumerable)
interface IEnumerator
 interface IEnumerable
{
{
 IEnumerator GetEnumerator();
void Reset();
}
bool MoveNext();

object Current {get;}
Notas:
}
Reset() coloca antes de principio de colección
MoveNext() indica si quedan más elementos
Javier Segovia
39
Instrucciones iterativas
(foreach con patrón colección)
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
40
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)
DivideByZero
IndexOutOfRange
InvalidCastException
OverflowException
OutOfMemory
StackOverflow
Argument
ArgumentNull
Causa
División por 0
Índice fuera de rango
Conversión inválida
Desbordamiento
Memoria agotada
Pila desbordada
Argumento mal
Javier Segovia
Argumento nulo
41
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
42
Intrucciones de excepción
(crear nuevas excepciones)
1. Derivar de System.Exception
2. Darle nombre acabado en Exception
3. Implementar constructores de System.Exception:
 Exception()
 Exception(string msg)
 Exception(string msg, Exception causante)
Javier Segovia
43
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
44
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
45
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
46
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
47
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
48
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
49
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
50
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
51
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
52
¡Gracias!
Javier Segovia
53