\section{Mirando al futuro: C\# 3}
	\subsection{Introducción}
		\begin{itemize}
			\item Ya está propuesta \href{http://msdn.microsoft.com/vcsharp/future/}{especificación de C\# 3}
			\subitem \href{http://download.microsoft.com/download/5/8/6/5868081c-68aa-40de-9a45-a3803d8134b8/CSharp_3.0_Specification.doc}{El documento} es bastante interesante y legible (no es un tocho de más de 500 páginas)
			\item Todavía no hay ninguna implementación que vayamos a poder probar, pero podemos ver hacia dónde irá el futuro de C\# 3
			\item Muuuuuy jugoso :-)
		\end{itemize}

	\newpage
	\subsection{var}
		\begin{itemize}
			\item Cuando asignamos un valor a una variable, desde que en tiempo de compilación tenemos el retorno del valor, no es necesario definir el tipo de la variable
			\item En \href{http://boo.codehaus.org/}{Boo} (una mezcla interesante entre Python y C\#), tenemos desde su comienzo:
			\begin{verbatim}
				a = 5 #a será 5
				b = Funcion() #b será del mismo tipo que el retorno de Funcion
			\end{verbatim} 
			\item En C\# 3, se introduce la palabra reservada \texttt{var}, que realiza la misma función:
			\begin{verbatim}
				var a = 5; //a será int
				var b = Funcion(); //b será del tipo de dato que devuelva Funcion
			\end{verbatim}
			\item También aplicable a arrays:
			\begin{verbatim}
				var a = new{ 1, 2, 3}; //array de int
			\end{verbatim}
		\end{itemize}
	\newpage
	\subsection{Métodos de extensiones}
		\begin{itemize}
			\item Dada una clase, podemos extenderla añadiéndole nuevos métodos:
			\begin{verbatim}
				public static class MisUtilidades{
				   //Con "this" por delante, indicamos el tipo de dato al que extendemos
				   public static void Imprimir(this string s){
				      Console.WriteLine(s);
				   }
				}
				
				//...
				using MisUtilidades;
				//...
				string s = "brutaaaal";
				s.Imprimir(); //Y así con cualquier clase
			\end{verbatim}
		\end{itemize}
	\newpage
	\subsection{Expresiones lambda}
		\begin{itemize}
			\item Las expresiones lambda, como en otros lenguajes, sirven para crear funciones anónimas en línea
			\begin{verbatim}
				delegate int Incrementador(int dato);

				//...
				
				Incrementador i = dato => dato + 1;
				//esto de arriba equivale en C# 2 a:
				Incrementador i = delegate(int dato){
				    return dato + 1;
				};
			\end{verbatim}
		\end{itemize}
	\newpage
	\subsection{Inicializadores de objetos y colecciones}
		\begin{itemize}
			\item Tenemos una nueva forma de inicializar objetos diréctamente pasándole propiedades que tenga:
			\begin{verbatim}
				class Cursillo{
				    int numAula;
				    string nombre;

				    public Aula(){}
				
				    public int NumAula{
				        get{
				            return numAula;
				        }
				        set{
				            numAula = value;
				        }
				    }
				
				    public string Nombre{
				        get{
				            return nombre;
				        }
				        set{
				            nombre = value;
				        }
				    }
				}

				//Lo inicializamos con las propiedades en la misma línea
				Cursillo cursillo = new Cursillo{NumAula = 114, Nombre = "C# rulez"};
			\end{verbatim}
			\item Además y junto a lo anterior podemos inicializar colecciones típicas de \texttt{System.Collections.Generic} como si fuesen arrays:
			\begin{verbatim}
				List<Cursillo> cursillos = new List<Cursillo>{
				    new Cursillo{ NumAula = 114, Nombre = "C#"},
				    new Cursillo{ NumAula = 114, Nombre = "Introducción a Mono"}
				};
			\end{verbatim}
		\end{itemize}

	\newpage
	\subsection{Tipos anónimos}
		\begin{itemize}
			\item Imagina que quieres una clase punto que no tienes para una función pequeña. Dos opciones:
			\item C\# 2: definir la clase punto:
			\begin{verbatim}
				class Punto{
				    int x, y;
				    public int X { get{ return x; } set { x = value; } }
				    public int Y { get{ return y; } set { y = value; } }
				}
				//...
				Punto p = new Punto();
			\end{verbatim}
			\item C\# 3 (también en Boo) definirlo de la misma con un tipo anónimo:
			\begin{verbatim}
				var miPunto = new { X = 5, Y = 6};
				Console.WriteLine(miPunto.X); // :-D~~~~
			\end{verbatim}
			\item Muy interesante:
			\begin{verbatim}
				var misPuntos = new {
				    new { X = 1, Y = 2},
				    new { X = 3, Y = 4}
				};
			\end{verbatim}
		\end{itemize}

	\newpage
	\subsection{Expresiones de consulta}
		\begin{itemize}
			\item Uno de los mayores cambios en el lenguaje.
			\item Se integra en el propio lenguaje un nuevo tipo de expresiones similar a SQL o XQuery para facilitar el procesamiento de datos
			\item Es bastante completo, mejor mirar la \href{http://msdn.microsoft.com/vcsharp/future/}{especificación}
			\item Un ejemplo sería:
			\begin{verbatim}
				Cursillo [] cursillos = new Cursillo[23]; //por ejemplo

				//...
				
				var resultado = from c in cursillos
				group c by c.Aula into a
				select new { Aula = a.Key, NumCursillos = a.Count() };

				foreach(var res in resultado)
				    Console.WriteLine("En el aula {0} hay {1} cursillos",res.Aula,res.NumCursillos);
			\end{verbatim}
			\item La idea es que el código anterior se traduciría luego a operaciones tal que:
			\begin{verbatim}
				Cursillo [] cursillos = new Cursillo[23]; //por ejemplo

				//...
				
				var resultado = cursillos.GroupBy(c => c.Aula)
				    .Select( a => new { Aula = a.Key, NumCursillos = a.Count() });

				foreach(var res in resultado)
				    Console.WriteLine("En el aula {0} hay {1} cursillos",res.Aula,res.NumCursillos);
			\end{verbatim}
			\item Las expresiones de consulta luego son mucho más complejas, incluyendo \texttt{join}s, consultas de varios grupos de datos, etc., pudiendo utilizarse sobre diferentes grupos de datos (no sólo \texttt{array}s, sino que podría aplicarse a BBDD, XML\ldots).
		\end{itemize}