\section{Introducción a C\#}
	\subsection{Introducción}
		\begin{itemize}
			\item Lenguaje sencillo
			\item Orientado a objetos
			\item El siguiente en lenguajes derivados de \texttt{C}, pasando por \texttt{C++} y \texttt{Java}
			\begin{itemize}
				\item Recoge muchas de las cosas que \texttt{Java} no había cogido de \texttt{C++}
				\item Asímismo, incorpora varias novedades no presentes en ninguno
				\item La \texttt{\#} viene de que es \texttt{C++++}, donde \texttt{++} encima de \texttt{++} es \texttt{\#}
			\end{itemize}
			\item Permite tanto la programación \texttt{managed} como la \texttt{unsafe} (con punteros como en \texttt{C++})
			\item Más simple que \texttt{C++}, pero tan poderoso y flexible
		\end{itemize}
	\newpage
	\subsection{Comenzando con C\#}
		\subsubsection{Ficheros de código en C\#}
			\begin{itemize}
				\item Al igual que en \texttt{C++}, C\# tiene:
				\begin{itemize}
					\item uno o más ficheros (con extensión \texttt{.cs})
					\item el cual tiene o no espacios de nombres (\texttt{namespace}s)
					\item que generan un único ejecutable o librería (\texttt{.exe} o \texttt{.dll})
				\end{itemize}
			\end{itemize}
		\subsubsection{Hola mundo en C\#}
			\begin{itemize}
				\item Primer programa en C\# \textit{(T3\_E1\_Holamundo)}:
				\begin{verbatim}
					class A{
					    static void Main(){
					        System.Console.WriteLine("hola mundo");
					    }
					}
				\end{verbatim}
				\item Hola mundo explicado:
				\begin{itemize}
					\item \texttt{class}
					\begin{itemize}
						\item Al igual que en \texttt{Java}, \emph{todo código aparecerá en métodos de clases}
					\end{itemize}
					\item \texttt{Main}
					\begin{itemize}
						\item El punto de entrada (\texttt{entrypoint}) del programa estará en un método especial llamado \texttt{Main}, que podrá ser declarado tal que:
						\begin{verbatim}
							static void Main();
							static int Main();
							static void Main(string [] args);
							static int Main(string [] args);
						\end{verbatim}
						\item Sólo podrá haber un \texttt{Main} por ensamblado ejecutable.
						\item \texttt{C\#} es \emph{case-sensitive}.
					\end{itemize}
					\item \texttt{System.Console}
					\begin{itemize}
						\item Al ejecutar \verb+System.Console.WriteLine("hola mundo");+ estamos:
						\begin{itemize}
							\item llamando al método \texttt{WriteLine}
							\item de la clase \texttt{Console}
							\item del espacio de nombres \texttt{System}
						\end{itemize}
						\item Podríamos sustituirlo por \textit{(T3\_E2\_Holamundo)}:
						\begin{verbatim}
							using System;

							class A{
							    static void Main(){
							        Console.WriteLine("hola mundo");
							    }
							}
						\end{verbatim}
						\item De manera que podemos acceder a todas las clases, espacios de nombres, \texttt{delegate}s, interfaces, y enumeraciones que cuelgan de \texttt{System}
					\end{itemize}
				\end{itemize}
			\end{itemize}
		\subsubsection{Ejecutandolo}
			\begin{itemize}
				\item Primero lo compilamos:
				\begin{verbatim}
					nctrun@ord3p:~/dev/cs$ mcs holamundo.cs
					nctrun@ord3p:~/dev/cs$
				\end{verbatim}
				\item Y luego lo ejecutamos:
				\begin{verbatim}
					nctrun@ord3p:~/dev/cs$ mono holamundo.exe
					hola mundo
					nctrun@ord3p:~/dev/cs$
				\end{verbatim}
			\end{itemize}
	\newpage
	\subsection{Fundamentos de C\#}
		\subsubsection{Tipos de datos}
			\begin{itemize}
				\item En C\# hay dos tipos de tipos de datos:
				\begin{itemize}
					\item por valor
					\begin{itemize}
						\item Cada vez que son utilizados, se copia su área de memoria
						\item Se alojan en la \texttt{stack}
						\item Destruidos en cuanto se destruye el bloque en el que son declarados acaba.
					\end{itemize}
					\item por referencia
					\begin{itemize}
						\item Cada vez que son utilizados, se copia un puntero a su posición en memoria
						\item Se alojan en la \texttt{heap}
						\item Destruidos cuando el \texttt{Garbage Collector} detecta que la última referencia al dato ha sido destruida
					\end{itemize}
				\end{itemize}
				\item C\# cuenta con varios tipos de datos \texttt{built-in}:
				\begin{itemize}
					\item \texttt{byte,char, bol, sbyte, short, ushort, int, uint, float, double, decimal, long, ulong}
					\item Ejemplos:
					\begin{verbatim}
						bool bln = true;
						byte byt1 = 22;
						char ch1='x', ch2='\u0066';
						decimal dec1 = 1.23M;
						double dbl1=1.23, dbl2=1.23D;
						short sh = 22;
						int i = 22;
						long lng1 =22, lng2 =22L;
						sbyte sb = 22;
						float f=1.23F;
						ushort us1=22;
						uint ui1=22, ui2=22U;
						ulong ul1 =22, ul2=22U, ul3=22L, ul4=2UL;
					\end{verbatim}
					\item Todos estos tipos de datos son por valor
				\end{itemize}
				\item \texttt{string}s \textit{(T3\_E3\_Strings)}
				\begin{itemize}
					\item Los \texttt{string}s son tipos de datos por referencia
					\item Los caracteres escapados son los típicos de otros lenguajes de programación:
					\subitem \verb+\',\",\\,\0,\a,\b,\f,\n,\r,\t,\v+
					\item Para evitar caracteres escapados, basta con poner una \texttt{@} por delante
					\begin{verbatim}
						string s = "hola";
						s = "hola\n";
						s = @"C:\Documents and Settings\";
					\end{verbatim}
				\end{itemize}
			\end{itemize}
		\subsubsection{Variables} \textit{(T3\_E4\_Variables)}
			\begin{itemize}
				\item Las variables se asignan como en \texttt{C++} o \texttt{Java}:
				\begin{verbatim}
					class Variables{
					    static void Main(){
					        int numero = 5;
					        System.Console.WriteLine("El número es: {0}",numero);
					    }
					}
				\end{verbatim}
				\item Al igual que en Java, un dato debe estar definido antes de ser usado:
				\begin{verbatim}
					class Variables{
					    static void Main(){
					        int numero;
					        System.Console.WriteLine("El número es: {0}",numero);
					    }
					}
				\end{verbatim}
				el compilador suelta:
				\begin{verbatim}
					nctrun@ord3p:~/dev/cs$ mcs definitivo.cs
					definitivo.cs(4) error CS0165: Use of unassigned local variable `numero'
					Compilation failed: 1 error(s), 0 warnings
				\end{verbatim}
			\end{itemize}
		\subsubsection{Constantes}
			\begin{itemize}
				\item Las constantes son declaradas al estilo \texttt{C++}:
				\begin{verbatim}
				        const constante = 50;
				        const constante2 = constante - 2;
				\end{verbatim}
			\end{itemize}
		\subsubsection{Nullable types}
			\begin{itemize}
				\item Desde C\# 2, tenemos los \texttt{nullable types}
				\item Tipos de datos por valor clásicos como ints, por ejemplo, pueden encapsularse en un tipo nullable:
				\begin{verbatim}
					int? variable4 = null;
					//variable4 = 5;
					Console.WriteLine(variable4);
					if(variable4 != null){
					    Console.WriteLine(variable4.Value);
					}else
					    Console.WriteLine("variable4 es null");
				\end{verbatim}
			\end{itemize}
		\subsubsection{Enumerados}
			\begin{itemize}
				\item Los enumerados de \texttt{C++} se han adaptado para que sean orientados a objetos \textit{(T3\_E5\_Enumerados)}
				\begin{verbatim}
					class Enumerados{
					   enum DiaSemana{
					      Lunes,
					      Martes,
					      Miercoles,
					      Jueves,
					      Viernes,
					      Sabado,
					      Domingo
					   };
					   static void Main(){
					      DiaSemana ds = DiaSemana.Lunes; //yeah!
					   }
					}
				\end{verbatim}
			\end{itemize}
		\subsubsection{Control de flujo}
			\begin{itemize}
				\item Condicionales \textit{(T3\_E6\_ControlFlujo)}
				\begin{itemize}
					\item \texttt{if...else}
					\begin{verbatim}
						int i = 15;
						if(i == 5)
						   System.Console.WriteLine("un cinco...");
						else if(i == 15)
						   System.Console.WriteLine("es quince");
						else
						   System.Console.WriteLine("mariposa");
					\end{verbatim}
					\item \texttt{switch}
					\begin{verbatim}
						switch(queToca){
						   case ViernesToca.GhostKino:
						       Console.WriteLine("ghostkino y...");
						     goto case ViernesToca.Fiestas;
						   case ViernesToca.Cena:
						       Console.WriteLine("cena");
						     break;
						   case ViernesToca.Fiestas:
						       Console.WriteLine("fiestas");
						     break;
						}
					\end{verbatim}
					\item En línea, al estilo \texttt{C++} y \texttt{Java}:
					\begin{verbatim}
						string ropa = haceFrio?"abrigo":"camiseta";
					\end{verbatim}
				\end{itemize}
				\item Sentencias repetitivas
				\begin{itemize}
					\item \texttt{do...while}
					\begin{verbatim}
						int i = 6;
						do{
						   Console.WriteLine("i: {0}",--i);
						while(i > 0);
						Console.WriteLine(":-S");
					\end{verbatim}
					\item \texttt{while}
					\begin{verbatim}
						while(respuesta.Incorrecta())
						   respuesta = Preguntar();
					\end{verbatim}
					\item \texttt{for}
					\begin{verbatim}
						for(int i = 0; i < 5; ++i)
						    Console.WriteLine("Va por...{0}",i);
					\end{verbatim}
					\item \texttt{foreach}
					\begin{verbatim}
						string [] nombres = new string[]{"nombre1","nombre2"};
						foreach(string n in nombres)
						   Console.WriteLine(n);
					\end{verbatim}
					\item \texttt{continue} y \texttt{break} como en el resto de lenguajes
					\begin{verbatim}
						int n = 10;
						while(n-- > 0){
						    if(n % 2 == 0)
						        continue; //No hagas nada con los pares
						    int n2 = n;
						    Console.WriteLine("n2 es: {0}",n2);
						}
					\end{verbatim}
				\end{itemize}
			\end{itemize}
		\subsubsection{Directivas de compilador}
			\begin{itemize}
				\item En C\#, al igual que en \texttt{C++}, hay directivas de compilador: \textit{(T3\_E7\_DirectivasCompilador)}
				\begin{verbatim}
					#define DEBUG

					#if DEBUG
					    //código
					#elif TEST
					    //otro código
					#else
					    //otro
					#endif

					#undef DEBUG

					#if DEBUG
					    //va a ser que no
					#endif

					#region Mis cosillas
					    //movidillas. Los IDEs permiten agrupar varios métodos, 
					    //por ejemplo, para no verlos
					#endregion

					//En C# 2:
					#pragma warning disable 0168
					int dato; //el warning 0168 (variable no utilizada) no salta.
				\end{verbatim}
			\end{itemize}
	\newpage
	\subsection{Clases}
		\subsubsection{Definiendo clases}
			\begin{itemize}
				\item Una clase es definida tal que: \textit{(T3\_E8\_Clases)}
				\begin{verbatim}
					public class MiClase{
					    //por defecto: datos privados
					    int atributo1;
					    int atributo2;

					    public MiClase(){ //constructor
					        atributo1 = atributo2 = 3;
					    }
				
					    void Metodo(){ //por defecto: privado
					        //codigo
					    }
					    public int Atributo1{//property
					        get{
					            return atributo1;
					        }
					    }
					}
				\end{verbatim}
				\item C\# tiene mejor trabajados los modificadores de acceso que sus lenguajes predecesores \textit{(T3\_E9\_Libreria)} y \textit{(T3\_E10\_UsandoLibreria)}:
				\begin{itemize}
					\item \texttt{public}. Todo el mundo puede acceder
					\item \texttt{private}. Sólo la propia clase puede acceder.
					\item \texttt{protected}. Sólo la propia clase y derivadas pueden acceder.
					\item \texttt{internal}. Sólo accesible desde las clases que están en el mismo ensamblado.
					\item \texttt{protected internal}. Sólo accesible desde las clases del mismo ensamblado \textbf{o} desde las hijas.
				\end{itemize}
				\item También contamos con un constructor estático similar al de Java
			\end{itemize}
		\subsubsection{Construyendo objetos}
			\begin{itemize}
				\item Por defecto, C\# provee un constructor por defecto
				\subitem simplemente pone a cero los datos numéricos, a \texttt{false} los \texttt{bool}eanos, a \texttt{'}\verb+\+\texttt{0'} los \texttt{char}, a 0 los \texttt{enum} y a \texttt{null} las referencias
				\item Para crear una instancia, basta con:
				\begin{verbatim}
					MiClase mc = new MiClase(parametros);
				\end{verbatim}
				\item Al igual que en \texttt{Java}, C\# tiene inicializadores:
				\begin{verbatim}
					private int num = 15;
				\end{verbatim}
				\item A diferencia de \texttt{C++}, C\# no provee de ningún \emph{constructor copy}
				\begin{itemize}
					\item Hay que implementarlo en caso de que se desee
					\item Existe el interfaz System.ICloneable
					\begin{verbatim}
						nctrun@ord3p:~$ /opt/mono-1.1.7/bin/monop System.ICloneable
						public interface ICloneable {
						
						   object Clone ();
						}
					\end{verbatim}
				\end{itemize}
				\item La palabra reservada \texttt{this} tiene el mismo valor que en sus predecesores
				\item C\# introduce la palabra reservada \texttt{readonly}, que hace que un atributo pueda ser unicamente modificado en el constructor de la clase
			\end{itemize}
		\subsubsection{Clases estáticas}
			\begin{itemize}
				\item Desde C\# 2, tenemos clases estáticas \textit{(T3\_E8\_Clases)}
				\item Una vez declaradas como estáticas, el compilador nos asegura:
				\begin{itemize}
					\item Nadie puede heredar de ella
					\item Todos sus miembros son estáticos
				\end{itemize}
			\end{itemize}
		\subsubsection{Clases parciales}
			\begin{itemize}
				\item Desde C\# 2, tenemos clases parciales \textit{(T3\_E8\_Clases)}
				\item Podemos definirlas a lo largo del código, incluso en diferentes ficheros
			\end{itemize}
		\subsubsection{Métodos}
			\begin{itemize}
				\item La definición de métodos en C\# es \textit{(T3\_E11\_MetodosYPropiedades)}:
				\begin{verbatim}
					modificadorAcceso (static) tipoDatoDevuelto nombreFuncion(parametros){
					}
				\end{verbatim}
				\item Los modificadores de acceso ya hemos comentado, y el uso y definición de \texttt{static} y retorno es igual a sus predecesores
				\item Sin embargo, el paso de parámetros cambia bastante
				\begin{itemize}
					\item Por defecto, el paso de parámetros es, al igual que \texttt{Java}, siempre por valor:
					\begin{verbatim}
						void Metodo(MiClase mc){
						    mc.Modificar(); //sin problemas
						    mc = null; //sin problemas, pero no afecta fuera de la función
						}
						//...
						variable.Metodo(mc);
					\end{verbatim}
					\item Sin embargo, C\# permite el paso por referencia, pero de manera diferente a \texttt{C++}:
					\begin{itemize}
						\item Obliga a poner la palabra \texttt{ref} antes del parámetro en la definición del método:
						\begin{verbatim}
							void Metodo(ref MiClase mc){
							    mc = null; //afecta fuera también
							}
						\end{verbatim}
						\item Obliga a poner la misma palabra \texttt{ref} antes del parámetro en la llamada al método:
						\begin{verbatim}
							variable.Metodo(ref mc);
						\end{verbatim}
						\item Como con el paso por valor, para llamarlo, la variable debe estar inicializada:
						\begin{verbatim}
							int numero;
							Metodo(ref numero); //no compila
						\end{verbatim}
					\end{itemize}
					\item Para permitir que una variable sea inicializada dentro de un método, se utiliza la palabra \texttt{out}:
					\begin{itemize}
						\item Obliga a poner la palabra \texttt{out} antes del parámetro en la definición del método.
						\begin{verbatim}
							void Metodo(out int dato){
							    dato = 0;
							}
						\end{verbatim}
						\item También obliga a poner la misma palabra \texttt{out} antes del parámetro en la llamada al método:
						\begin{verbatim}
							int numero;
							Metodo(out numero);
						\end{verbatim}
						\item A la hora de pasar la variable por parámetro, da lo mismo si está o no inicializada
						\item A la hora de salir del método, el compilador da por hecho que puede no estar inicializada y que debe ser inicializada dentro, ateniéndose a las mismas restricciones que si no estuviese inicializada desde el principio
					\end{itemize}
				\end{itemize}
				\item Además, C\# permite el paso de una lista indefinida de parámetros con la palabra \texttt{params}:
				\begin{verbatim}
					void Metodo(params int [] numeros){
					    foreach(int n in numeros)
					        Console.WriteLine(n);
					}
					//...
					Metodo();
					Metodo(1);
					Metodo(1,2);
					Metodo(1,2,3);
				\end{verbatim}
			\end{itemize}
		\subsubsection{Propiedades}
			\begin{itemize}
				\item C\# incorpora el uso de propiedades \textit{(T3\_E11\_MetodosYPropiedades)}:
				\begin{itemize}
					\item Una \emph{property} es un método que ejecuta un código en una clase casi como otro cualquiera, pero que desde fuera es accedido como si fuese un atributo público
					\item Evita el continuo uso de \emph{getAlgo}s y \emph{setAlgo}s, haciendo más legible el código
				\end{itemize}
				\item Pueden ser declarados de sólo lectura:
				\begin{verbatim}
					public int Numero{
					    get{
					        Console.WriteLine("Devolviendo...{0}",numero);
					        return numero;
					    }
					}
					
					//...
					
					int num = variable.Numero; //guay
					variable.Numero = 5; //no compila
				\end{verbatim}
				\item o bien de sólo escritura:
				\begin{verbatim}
					public int Numero{
					    set{
					        Console.WriteLine("Asignando...{0}",value);
					        numero = value; //value es el valor pasado por parámetro
					    }
					}
			
					//...
				
					int num = variable.Numero; //no compila
					variable.Numero = 5; //guay
				\end{verbatim}
				\item o bien de lectura y escritura:
				\begin{verbatim}
					public int Numero{
					    set{
					        Console.WriteLine("Asignando...{0}",value);
					        numero = value; //value es el valor pasado por parámetro
					    }
					    get{
					        Console.WriteLine("Devolviendo...{0}",numero);
					        return numero;
					    }
					}

					int num = variable.Numero; //guay
					variable.Numero = 5; //guay
				\end{verbatim}
				\item En C\# 2, podemos además dar diferentes permisos al get y al set:
				\begin{verbatim}
					public int Numero{
					    get{
					        return numero;
					    }
					    protected set{
					        numero = value;
					    }
					}
				\end{verbatim}
			\end{itemize}
		\subsubsection{Destructores}
			\begin{itemize}
				\item En la clase \texttt{Object} .NET, de la que \emph{todo} hereda, existe el método virtual \texttt{Finalize}, que es similar al \texttt{finalize} de \texttt{Java}, salvo que .NET te garantiza que va a ser llamado \textit{(T3\_E12\_Destructores)}.
				\item El método que a nivel de CIL se sobrecarga es:
				\begin{verbatim}
					protected override void Finalize(){
					    Console.WriteLine("hola");
					}
				\end{verbatim}
				Sin embargo, en su lugar, se debe escribir al estilo \texttt{C++}:
				\begin{verbatim}
					~MiClase(){
					    Console.WriteLine("hola");
					}
				\end{verbatim}
				que el compilador de C\# se encargará de transformar en \texttt{Finalize}.
				\item En caso de que no se deba esperar hasta que el \texttt{Garbage Collector} llame al destructor, se implementa el método \texttt{Dispose}:
				\begin{itemize}
					\item Se implementa el interfaz \texttt{System.IDisposable}
					\item Se puede bien controlar con \texttt{bool}s que no se repita la llamada al método \texttt{Dispose}, para evitar que lo vuelva a llamar el destructor, o bien se puede evitar que el \texttt{Garbage Collector} llame al método \texttt{Finalize} con:
					\begin{verbatim}
						System.GC.SuppressFinalize(instancia);
					\end{verbatim}
					\item El uso de \texttt{Dispose} permite una sintaxis más sencilla y óptima con un nuevo uso de la palabra \texttt{using}:
					\begin{verbatim}
						//MiClase implementa System.IDisposable
						using(MiClase mc = new MiClase(parametros)){
						    mc.hacerAlgo();
						}//llegado aquí, se llama al Dispose y la variable deja de existir
					\end{verbatim}
				\end{itemize}
			\end{itemize}
	\newpage
	\subsection{Estructuras}
		\subsubsection{Qué son}
			\begin{itemize}
				\item Los \texttt{struct}s son \textit{(T3\_E13\_Estructuras)}:
				\begin{itemize}
					\item agrupamientos lógicos de datos y métodos (al igual que las clases)
					\item no permiten herencia, destructores, constructores sin parámetros, inicialización de campos\ldots
					\item sí permiten implementación de interfaces
					\item Son datos por valor
				\end{itemize}
			\end{itemize}
		\subsubsection{Definición}
			\begin{itemize}
				\item La definición de un \texttt{struct} es tal que:
				\begin{verbatim}
					public struct Punto{
					    public int X;
					    public int Y;
					    public Punto(int x, int y){
					        X = x;
					        Y = y;
					    }
					}
				\end{verbatim}
			\end{itemize}
		\subsubsection{Creación}
			\begin{itemize}
				\item La creación de \texttt{struct}s es también similar a la de instancias de clases:
				\begin{verbatim}
					Punto p = new Punto(0,5);
					p.X = 5;
				\end{verbatim}
				\subitem \emph{el que se use la palabra \texttt{new} no significa que sea por referencia}
				\item Por defecto, hay un constructor sin parámetros que inicializa todo. De hecho, podría crearse un struct de esta manera:
				\begin{verbatim}
					Punto p;
					p.X = 5;
				\end{verbatim}
				\subitem No se aconseja este código (mejor crear siempre con \texttt{new}, deja el código más claro)
			\end{itemize}
		\subsubsection{Arrays en structs}
			\begin{itemize}
				\item No podemos declarar un array dentro del struct sin saber el tamaño del mismo
				\item Como no hay inicializadores de campos en structs, tampoco podemos definir el tamaño del array
				\item Solución: desde C\# 2 existen arrays de tamaño fijo:
				\begin{verbatim}
					struct A{
					  char datos [250];
					}
				\end{verbatim}

			\end{itemize}

	\newpage
	\subsection{Herencia y polimorfismo}
		\subsubsection{Heredando}
			\begin{itemize}
				\item Al igual que \texttt{Java}, C\# no soporta herencia múltiple
				\item La sintaxis similar a \texttt{C++}, pero sin modificadores de acceso en la herencia, al estilo \texttt{Java}: \textit{(T3\_E14\_Herencia)}
				\begin{verbatim}
					public class Mamifero : Animal
				\end{verbatim}
				\item Si la clase padre tiene un constructor sin parámetros, por defecto será llamado antes de ejecutar el código del constructor de la clase hija
				\item Si no, será necesario llamar a \texttt{base}:
				\begin{verbatim}
					public class Mamifero : Animal{
					    public Animal(string nombre) : base(nombre){
					        //...
					    }
					}
				\end{verbatim}
				\item Para redefinir un método, hace falta la palabra \texttt{new}:
				\begin{verbatim}
					class A{
					    public void Metodo(){
					        Console.WriteLine("A");
					    }
					}
					class B : A{
					    public new void Metodo(){
					        Console.WriteLine("B");
					    }
					}
					class Test{
					    public static void Main(){
					        B b = new B();
					        b.Metodo(); //mostrará B
					        A a = b;
					        a.Metodo(); //mostrará A
					    }
					}
				\end{verbatim}
				\item Para evitar que alguien pueda heredar de una clase determinada se utiliza la palabra \texttt{sealed} (similar al \texttt{final} de \texttt{Java}):
				\begin{verbatim}
					sealed class A{
						//... 
					}
					class B : A{ //no compila
					}
				\end{verbatim}
			\end{itemize}
		\subsubsection{Polimorfismo}
			\begin{itemize}
				\item Para escribir métodos polimórficos hace falta las palabras \texttt{virtual} y \texttt{override}, al estilo \texttt{C++}:
				\begin{verbatim}
					class A{
					    public virtual void Metodo(){
					        Console.WriteLine("A");
					    }
					}
					class B : A{
					    public override void Metodo(){
					        Console.WriteLine("B");
					    }
					}
					class Test{
					    public static void Main(){
					        B b = new B();
					        b.Metodo(); //mostrará B
					        A a = b;
					        a.Metodo(); //mostrará B también :)
					        A [] varios = new A[2];
					        varios[0] = new B();
					        varios[1] = new A();
					        foreach(A nueva in varios)
					            nueva.Metodo();
					    }
					}
				\end{verbatim}
			\end{itemize}
		\subsubsection{Clases abstractas}
			\begin{itemize}
				\item Una clase abstracta:
				\begin{itemize}
					\item no puede ser instanciada
					\item puede declarar una serie de métodos que obliga a toda hija clase no abstracta a definir
				\end{itemize}
				\item Definiendo clases abstractas \textit{(T3\_E15\_ClasesAbstractas)}:
				\begin{itemize}
					\item Se definen con la palabra reservada \texttt{abstract}:
					\begin{verbatim}
						abstract public class A{
						    protected int dato;
						}
						abstract public class B : A{
						    abstract public void Metodo();
						}
						public class C : B{
						    public override void Metodo(){
						        Console.WriteLine();
						    }
						}
					\end{verbatim}
				\end{itemize}
			\end{itemize}
		\subsubsection{Relacionando tipos de datos por valor y por referencia}
		 	\begin{itemize}
				\item \textbf{Todo} puede ser un \texttt{object} \textit{(T3\_E16\_BoxingUnboxing)}:
				\begin{itemize}
					\item Incluso datos por valor
					\begin{verbatim}
						string s = 5.ToString();
					\end{verbatim}
				\end{itemize}
				\item A este proceso se le llama \emph{boxing} y al opuesto (pasar de un \texttt{object} a \texttt{int} \emph{unboxing}.
				\item El proceso de \emph{unboxing} debe ser lógicamente explícito:
				\begin{verbatim}
					object o = 5;
					int i = (int)o;
				\end{verbatim}
			\end{itemize}
		\subsubsection{Sobrecarga de operadores}
			\begin{itemize}
				\item Al igual que en \texttt{C++}, C\# puede sobrecargar operadores \textit{(T3\_E17\_SobrecargaOperadores)}
				\item Sobrecargando un operador:
				\begin{verbatim}
					class A : B{
					    public static A operator+(A a, A b){
					        return a.X + b.X;
					    }
					}
				\end{verbatim}
			\end{itemize}
	\newpage
	\subsection{Interfaces}
		\subsubsection{Qué son}
			\begin{itemize}
				\item Como hemos comentado antes, C\#, al igual que \texttt{Java}, no tiene herencia múltiple
				\item Sin embargo, una clase sí puede \emph{implementar} varios interfaces.
				\item El interfaz define varios métodos, que la clase que lo implemente deberá declarar como públicos
				\item Al igual que en \texttt{Java}, un interfaz puede heredar de otro
			\end{itemize}
		\subsubsection{Definiendo interfaces}
			\begin{itemize}
				\item Se definen tal que \textit{(T3\_E18\_Interfaces)}:
				\begin{verbatim}
					interface IDisposable{
					    void Dispose();
					}
					interface IDestroyable : IDisposable{
					    void Destroy();
					    int Status{
					        get;
					    }
					}
				\end{verbatim}
			\end{itemize}
		\subsubsection{Is, as}
			\begin{itemize}
				\item Para saber si una instancia implementa un interfaz o hereda de otra clase, se puede utilizar \textit{(T3\_E18\_Interfaces)}:
				\begin{itemize}
					\item \texttt{is}
					\begin{itemize}
						\item Devuelve un \texttt{bool} informando de si es o no
					\end{itemize}
					\item \texttt{as}
					\begin{itemize}
						\item Devuelve \texttt{null} si \textbf{no} lo implementa, o la instancia como otra cosa en caso de que sea
					\end{itemize}
				\end{itemize}
			\end{itemize}
	\newpage
	\subsection{Manejo de excepciones}
		\subsubsection{Capturando excepciones}
			\begin{itemize}
				\item Para capturar excepciones se utiliza \texttt{catch} \textit{(T3\_E19\_Excepciones)}:
				\begin{verbatim}
					try{
					    int i = 10/0;
					}catch(System.DivideByZeroException){
					    Console.WriteLine("capturada");
					}
				\end{verbatim}
				\item Si queremos hacer algo con la excepción, podemos capturar la instancia de la siguiente manera:
				\begin{verbatim}
					try{
					    int i = 10/0;
					}catch(System.DivideByZeroException dbze){
					    Console.WriteLine(dbze.StackTrace)
					}
				\end{verbatim}
				\item Si en cambio queremos capturar todas las excepciones, podemos hacer:
				\begin{verbatim}
					try{
					    int i = 10/0;
					}catch{
					    Console.WriteLine("capturada");
					}
				\end{verbatim}
				\item También podemos utilizar \texttt{finally} para que, tanto si se eleva una excepción como si no, se ejecute un código:
				\begin{verbatim}
					try{
					    int i = 10/0;
					}catch(System.DivideByZeroException dbze){
					    Console.WriteLine("y aquí me he quedado :-)");
					}finally{
					    Console.WriteLine("Esto SIEMPRE se ejecuta");
					}
	
				\end{verbatim}
			\end{itemize}
		\subsubsection{Lanzando excepciones}
			\begin{itemize}
				\item Para lanzar una excepción, se utiliza la palabra reservada \texttt{throw}:
				\begin{verbatim}
					throw new Exception("excepción");
				\end{verbatim}
				\item Lo lanzado debe ser una instancia de una clase hija de \texttt{System.Exception} (o de \texttt{System.Exception})
				\subitem Se recomienda que las excepciones propias sean hijas de \texttt{System.ApplicationException} para diferenciar entre las excepciones del \texttt{Framework} y las de nuestra aplicación
			\end{itemize}
	\newpage
	\subsection{Delegates}
		\subsubsection{Qué son}
			\begin{itemize}
				\item Son el equivalente a puntero a función de otros lenguajes
				\begin{itemize}
					\item adaptados al modelo orientado a objetos
					\item fáciles de usar
				\end{itemize}
			\end{itemize}
		\subsubsection{Definiendo delegates}
			\begin{itemize}
				\item Un \texttt{delegate} se indica tal que \textit{(T3\_E20\_Delegates)}:
				\begin{verbatim}
					delegate tipoDato funcion(parametros);
				\end{verbatim}
				\item Ejemplo:
				\begin{verbatim}
					delegate void Funcion(object o);

					class A{
					    static void Main(){}
					}
				\end{verbatim}
			\end{itemize}
		\subsubsection{Utilizando delegates}
			\begin{itemize}
				\item El uso es tan simple como:
				\begin{verbatim}
					delegate void Funcion();

					class A{
					    void Hacer(Funcion f){
					        f();
					    }
					
					    void HazAlgo(){
					        Hacer(new Funcion(Saludar));
					    }
	
					    void Saludar(){
					        System.Console.WriteLine("hola");
					    }

					    static void Main(){
					        (new A()).HazAlgo();
					    }
					}
				\end{verbatim}
			\end{itemize}
		\subsubsection{Utilizando multicasting}
			\begin{itemize}
				\item Para que al llamar a un delegado, se llamen a varios métodos, sólo hay que ir añadiendo nuevos métodos con \texttt{+=} \textit{(T3\_E21\_DelegateMulticast)}:
				\begin{verbatim}
					delegate void Funcion();
					class A{
					    void Hacer(Funcion f){
					        f();
					    }
					
					    void HazAlgo(){
					        Hacer(new Funcion(Saludar));
					        Funcion f = new Funcion(Saludar);
					        f += new Funcion(Saludar);
					        f += new Funcion(Saludar);
					        f();
					    }
					
					    void Saludar(){
					        System.Console.WriteLine("hola");
					    }
					
					    static void Main(){
					        (new A()).HazAlgo();
					    }
					}
				\end{verbatim}
			\end{itemize}
		\subsubsection{Eventos}
			\begin{itemize}
				\item El \texttt{delegate} es útil, pero hay ciertas situaciones en las que no nos sirve. \ldots
				\begin{itemize}
					\item Si quisiéramos tener un interfaz sobre el cual se pueden dar eventos\ldots no se puede declarar en un interfaz
					\begin{itemize}
						\item ¿\texttt{addListener} de Java?
					\end{itemize}
					\item Si quisiéramos ponerlo público para que otras clases añadiesen funciones a nuestro evento\ldots se podrá llamar al evento desde otras clases (en lugar de siempre llamarlo tú)
				\end{itemize}
				\item Para solucionar estos problemas, está la palabra reservada \texttt{event}
				\item Ver ejemplos: \textit{(T3\_E22\_Eventos)}
			\end{itemize}
	\newpage
	\subsection{Atributos}
		\subsubsection{Qué son}
			\begin{itemize}
				\item Una forma de dar más información acerca de una clase, enumerado, atributo, método...
				\item Son útiles por ejemplo para informar a librerías qué partes de nuestro código son qué
				\item Ejemplos:
				\begin{itemize}
					\item Informar de qué clase es el Servicio Web, y qué métodos son WebMethods
					\item Informar de qué campos son Widgets en Gtk
					\item Informar qué clases son pruebas unitarias y cuáles de sus métodos son tests, y qué tipo de tests en nunit
				\end{itemize}
			\end{itemize}
		\subsubsection{¿Cómo se utilizan?}
			\begin{itemize}
				\item Ver \textit{(T3\_E23\_Atributos)}
				\item \texttt{[Atributo(parametros\_constructor,Propiedad1=valorProp1,Propiedad2=valorProp2...)]}
				\item Ejemplo:
				\begin{verbatim}
					//Los utilizamos así. Puntuaciones es la property, no es obligatoria
					[Mola("mazo",Puntuacion=10)]
					class UnaClase{
					
					    [Mola("lo típico")]
					    int dato;
					    int otroDato; //Sin Mola
					
					    [Mola("no mucho",Puntuacion=6,Docu="Es un método cualquiera")]
					    public int Metodo(){
					        return 5;
					    }
					}
				\end{verbatim}
			\end{itemize}
		\subsubsection{¿Cómo se definen?}
			\begin{itemize}
				\item Tienen que ser clases hijas de System.Attribute
				\item Se les puede definir más ("Este atributo sólo sirve para structs" / "Este sirve para tanto campos como métodos") por medio de atributos :-)
				\item Luego se comprueba si son atributos por medio de la API de Reflection
				\item Ver \textit{(T3\_E23\_Atributos)}
			\end{itemize}
	\newpage
	\subsection{Generics}
		\subsubsection{¿Qué son?}
			\begin{itemize}
				\item Similares a las \texttt{templates} de C++. En C\# están desde su versión 2
				\item Permiten hacer clases o métodos que procesen un tipo de dato único (o heredado de él), desconocido por el autor de esta clase.
				\item Hasta ahora, como todo hereda de \texttt{object}, los contenedores de datos se hacían en función de \texttt{object}:
				\begin{verbatim}
					using System.Collections;
					//...
					ArrayList l = new ArrayList();
					l.Add(5); //Un int cuela
					l.Add("hola"); //Un string también
				\end{verbatim}
				\item Ahora, podemos hacer:
				\begin{verbatim}
					using System.Collections.Generic;
					//...
					List<int> l = new List<int>();
					l.Add(5);
					l.Add("hola"); //no compila
				\end{verbatim}
				\item El espacio de nombres System.Collections sigue teniendo los contenedores de C\# 1, los nuevos contenedores están en System.Collections
			\end{itemize}
		\subsubsection{¿Cómo se implementan?}
			\begin{itemize}
				\item Ver ejemplos en \textit{(T3\_E24\_Generics)}
				\begin{verbatim}
				//Este contenedor sólo depende de T
				class MiPropioContenedor < T >{
				    T [] datos;
					
				    public MiPropioContenedor(T [] datos){
				        this.datos = datos;
				    }
					
				    public T [] Datos{
				        get{
				            return datos;
				        }
				        set{
				            datos = value;
				        }
				    }
				}
				
				//Si queremos que T implemente el interfaz IComparable:
				class MiListaOrdenada < T > where T : IComparable
				{
				    //...	
				}
				
				//Sólo para una función
				class A{
				    public static T Metodo<T>(T dato){
				        return dato;
				    }
				}


				\end{verbatim}

			\end{itemize}
	\newpage
	\subsection{Iteradores}
		\subsubsection{En C\# 1}
			\begin{itemize}
				\item Como en muchos otros lenguajes, en C\# tenemos iteradores
				\item Los iteradores implementan el interfaz \texttt{System.Collections.IEnumerator}
				\item Los podemos utilizar en un \texttt{foreach}:
				\begin{verbatim}
					ArrayList al = new ArrayList();
					al.Add("hola");
					al.Add("adios");
					foreach(string s in al) 
					    Console.WriteLine(s);
					//Internamente, está haciendo:
					IEnumerator ie = al.GetEnumerator();
					while(ie.MoveNext())
					    Console.WriteLine(ie.Current);
				\end{verbatim}
				\item El problema es que para utilizar los nuestros propios, lo tenemos que implementar a mano
				\item Ver ProveedorComandos en \textit{(T3\_E25\_Iteradores)}
			\end{itemize}
		\subsubsection{En C\# 2}
			\begin{itemize}
				\item En C\# 2, con Generics, tenemos \texttt{System.Collections.Generic.IEnumerator<loquesea>}
				\item Además, contamos con generación automática de iteradores con la palabra reservada \texttt{yield}:
				\begin{verbatim}
					class ProveedorComandos2{
					
					    readonly string [] comandos;
					
					    public ProveedorComandos2(params string [] comandos){
					        this.comandos = new string[comandos.Length];
					        for(int i = 0 ; i < comandos.Length ; ++i )
					            this.comandos[i] = comandos[i];
					    }
					
					    public System.Collections.Generic.IEnumerator <string> GetEnumerator(){
					        foreach(string s in comandos)
					            //cada vez que tenemos un comando, lo devolvemos con yield
					            yield return s;
					    }
					}
					//...
					foreach(string s in new ProveedorComandos2("a","b","c")){
					    Console.WriteLine(s);
					}
				\end{verbatim}
				\item Ver ProveedorComandos2 y sobre todo ProveedorComandos3 en \textit{(T3\_E25\_Iteradores)}
			\end{itemize}
	\newpage
	\subsection{Código unsafe}
		\subsubsection{Qué es}
			\begin{itemize}
				\item En C\#, como dijimos al comienzo del cursillo, disponemos de dos modos:
				\begin{itemize}
					\item Código \texttt{managed}
					\begin{itemize}
						\item El código que hemos utilizado durante todo el cursillo
						\item Lo gestiona el runtime, temas de recolección de basura, acceso a memoria (no tendrás segfaults, sino excepciones de alto nivel), etc.
						\item Programación de más alto nivel, facilidades para el programador
					\end{itemize}
					\item Código \texttt{unsafe}
					\begin{itemize}
						\item Código no gestionado
						\item Debemos indicarlo al compilador (-unsafe en mcs, activar la opción correspondiente en el proyecto de MonoDevelop)
						\item Debemos indicarlo en el alcance del código (en la clase, método\ldots correspondiente), con la palabra reservada \texttt{unsafe}
						\item Podemos utilizar punteros, al estilo C / C++, sin recolección de basura
						\item Podemos hacer accesos a memoria al estilo C / C++
						\item Programación de más bajo nivel
					\end{itemize}
				\end{itemize}
			\end{itemize}
		\subsubsection{¿Y para qué me sirve?}
			\begin{itemize}
				\item Interacción con código nativo
				\begin{itemize}
					\item No necesitas \texttt{JNI} o \texttt{SWIG} como "pegamento" entre C\# y C
					\item Utilizando recursos de bajo nivel en momentos concretos
				\end{itemize}
				\item Creación de bindings de librerías existentes (bien de terceros, GTK, SDL, OpenGL\ldots, como nuestras) para poder utilizarlas desde .NET
				\item Optimización de partes de nuestra aplicación (desarrollando en C / C++ partes críticas y luego utilizando esto desde C\#)
				\item Ejemplo: \textit{(T3\_E26\_Unsafe)}
			\end{itemize}

\newpage