\section{Introducción a Mono/.NET}
	\subsection{¿Qué es?}
		\begin{itemize}
			\item El .NET Framework es una \emph{plataforma de desarrollo de software}, enfocada en:
			\begin{itemize}
				\item Desarrollo rápido y explotación de aplicaciones gestionadas (\emph{managed}) y orientadas a objetos
				\item Independencia del lenguaje
				\item Independencia de la plataforma
				\item Transparencia a través de la red
			\end{itemize}
			\item Esta plataforma ofrece, entre otras cosas:
			\begin{itemize}
				\item Nuevos y modernos lenguajes de programación (C\#, VB.NET\ldots)
				\item Compatibilidad con otros lenguajes (Managed C++, J\#\ldots)
				\item La posibilidad de incluir nuevos lenguajes de programación
				\item Integración multilenguaje, reutilización de componentes, herencia entre componentes desarrollados en diferentes lenguajes
				\item Una extensa framework de librerías de clases independiente del lenguaje
				\item Un sistema de ejecución de lenguaje común (CLR)
				\item Un conjunto de servidores .NET
				\item Programación
				\begin{itemize}
					\item web: ASP.NET
					\item gráfica: Windows Forms
					\item de Servicios Web XML independientes de la plataforma vía SOAP y WSDL
				\end{itemize}
				\item Conjunto de herramientas de desarrollo (Visual Studio .NET, ...)
			\end{itemize}
		\end{itemize}
	\newpage
	\subsection{Common Language Runtime}
		\subsubsection{Características}
			\begin{itemize}
				\item La CLR trae incorporadas las características de un runtime moderno:
				\begin{itemize}
					\item Recolección de basura
					\item Gestión de hilos
					\item Interoperabilidad con código nativo
					\item Seguridad en el acceso a código
					\item Introspección
					\item \ldots
				\end{itemize}
				\item El CLR es el encargado de ejecutar las aplicaciones .NET
			\end{itemize}
		\subsubsection{Soporte multilenguaje}
			\begin{itemize}
				\item La plataforma es independiente del lenguaje
				\item Cuenta con un lenguaje universal, el CIL
				\begin{itemize}
					\item Common Intermediate Language, también llamado IL o MSIL
					\item fácilmente compilable
					\item cada lenguaje tiene su compilador a CIL
				\end{itemize}
				\item Luego, del CIL se genera el código nativo de la plataforma en la que se ejecute
				\begin{itemize}
					\item compilador JIT (Just In Time) o AOT (Ahead Of Time) o intérprete
					\item las diferentes implementaciones de .NET soportan diferentes plataformas
				\end{itemize}
				\begin{center}
					\includegraphics[scale=0.75]{figuras/leng2cil2arq.png}
				\end{center}
				\item Gracias a esto:
				\begin{itemize}
					\item Se puede desde un lenguaje utilizar componentes escritos en otro lenguaje
					\item Dada una librería, su API es accesible a todos los lenguajes
					\item Lo único que es necesario es que estos lenguajes tengan su compilador a CIL
					\item Incluso se pueden reutilizar compiladores hechos por terceros
				\end{itemize}
			\end{itemize}
		\subsubsection{Librerías}
			\begin{itemize}
				\item Como hemos dicho, .NET trae una gran cantidad de librerías
				\item Todas estas librerías son accesibles a todo lenguaje que cuente con compilador para el CIL
			\end{itemize}
	\newpage
	\subsection{Estandarización de .NET}
		\begin{itemize}
			\item Microsoft estandarizó parte del .NET Framework en el \href{http://www.ecma-international.org}{ECMA}
			\begin{itemize}
				\item En los estándares \href{http://www.ecma-international.org/publications/standards/Ecma-334.htm}{ECMA 334} (C\#) y \href{http://www.ecma-international.org/publications/standards/Ecma-335.htm}{ECMA 335} (CLI: Common Language Infrastructure)
				\subitem Estandarizó el núcleo de .NET y C\#
				\item C\# y la CLI además está estandarizado por la ISO en los estándares \href{http://www.iso.org/iso/en/CatalogueDetailPage.CatalogueDetail?CSNUMBER=36768&ICS1=35&ICS2=60&ICS3=}{ISO/IEC 23270} y \href{http://www.iso.org/iso/en/CatalogueDetailPage.CatalogueDetail?CSNUMBER=36769&ICS1=35&ICS2=60&ICS3=}{ISO/IEC 23271} respectivamente
			\end{itemize}
			\item Pero otros componentes no están estandarizados:
			\begin{itemize}
				\item ASP.NET
				\item Windows Forms
				\item ADO.NET
			\end{itemize}
		\end{itemize}
	\newpage
	\subsection{Implementaciones}
		\begin{itemize}
			\item \href{http://www.microsoft.com}{Microsoft} tiene su implementación de .NET
			\item Pero hay más implementaciones, algunas \href{http://opensource.org}{Open Source}, como:
			\begin{itemize}
				\item \href{http://www.mono-project.com}{Mono}
				\item \href{http://www.dotgnu.org}{DotGNU}
			\end{itemize}
			\item En el aula están instaladas:
			\begin{itemize}
				\item La implementación de Microsoft en Windows
				\begin{itemize}
					\item .NET 1.1 (Visual Studio 2003)
					\begin{itemize}
						\item Microsoft ha publicado este curso VS.NET 2005, con .NET 2
					\end{itemize}
				\end{itemize}
				\item Mono en Ubuntu
				\begin{itemize}
					\item Versión 1.1.16
				\end{itemize}
			\end{itemize}
			\item La versión 1.1.16 de Mono implementa C\# 2, que daremos en clase
			\subitem \emph{Aunque todo lo que vayamos a dar sea estándar, en la versión instalada en el aula hay cosas que sólo funcionarán con Mono}
		\end{itemize}
	\newpage
	\subsection{Versiones}
		Versiones del .NET Framework
		\begin{itemize}
			\item 1.0 $\rightarrow$ Enero 2002
			\item 1.1 $\rightarrow$ Abril 2003. Instalado en el aula en la partición de Windows. Viene con C\# 1
			\item 2.0 $\rightarrow$ Noviembre 2005. En español a comienzos de 2006. Viene con C\# 2
		\end{itemize}
		En \href{http://www.mono-project.com}{Mono}:
		\begin{itemize}
			\item Algunas características de C\# 2 están disponibles en el compilador \texttt{mcs}
			\item Para hacer uso de todas las características de C\# 2, hay que utilizar \texttt{gmcs}
			\item En MonoDevelop, basta con activar el runtime 2.0 en las Opciones del Proyecto.
		\end{itemize}
	\newpage
	\subsection{Instalación de Mono}
		\begin{itemize}
			\item \href{http://www.mono-project.com/Downloads}{http://www.mono-project.com/Downloads}
			\item En Windows hay un instalador que viene con Mono, GTK\# y xsp
			\item Para GNU/Linux en x86 está disponible un instalador para cualquier distribución
			\begin{itemize}
				\item Está muy bien para cacharrear con Mono:
				\begin{itemize}
					\item Fácil de instalar (instalador \texttt{GTK})
					\item Instalación limpia (desinstalación limpia)
					\item Viene con la última versión de Mono
					\item Independiente de dependencias etc. (da lo mismo si usas sid, testing, suse o lo que sea)
				\end{itemize}
				\item Por otra parte, también tiene sus desventajas:
				\begin{itemize}
					\item Es fácil para hacer poca cosa. Para hacer que \texttt{xsp} se ejecute como usuario www-data, tienes que configurarlo tú mismo (que es hacer lo que los mantenedores de los paquetes ya han hecho por tí)
					\item Dificil de mantener: tienes que estar pendiente de actualizaciones
					\item Las dependencias no lo detectan. Algunos programas exigen otras dependencias.
				\end{itemize}
			\end{itemize}
		\end{itemize}
	\newpage
	\subsection{Introducción al entorno}
		\begin{itemize}
			\item Mono viene con las baterías puestas:
			\begin{itemize}
				\item IDE: \href{http://www.monodevelop.com}{MonoDevelop}
				\begin{itemize}
					\item Port del \href{http://www.icsharpcode.net/OpenSource/SD/}{SharpDevelop} para GNOME, con múltiples nuevas características para desarrollo de aplicaciones para GNOME
				\end{itemize}
				\item Muchas otras herramientas que quedan fuera del cursillo
			\end{itemize}
			\item Vamos a poner un poco en práctica lo que hemos comentado hasta ahora (todo esto se explica mejor en el cursillo de Mono):
			\begin{itemize}
				\item Vamos a \texttt{ejemplos/holamundo}
				\item Compilamos el "hola mundo": \texttt{mcs holamundo.cs}
				\begin{verbatim}
					nctrun@ord3p:~/cursillo_cs$ cd ejemplos/holamundo/
					nctrun@ord3p:~/cursillo_cs/ejemplos/holamundo$ mcs holamundo.cs
					holamundo.cs(26,7): warning CS0219: The variable `dato3' is assigned but its 
					value is never used
					Compilation succeeded - 1 warning(s)
					nctrun@ord3p:~/cursillo_cs/ejemplos/holamundo$ ls
					holamundo.cs  holamundo.exe
					nctrun@ord3p:~/cursillo_cs/ejemplos/holamundo$
				\end{verbatim}
				\item ¿Qué tipo de fichero es?
				\begin{verbatim}
					nctrun@ord3p:~/cursillo_cs/ejemplos/holamundo$ file holamundo.exe
					holamundo.exe: PE executable for MS Windows (console) Intel 80386 32-bit
				\end{verbatim}
				\item Vaya. ¿Cómo lo ejecuto?
				\begin{verbatim}
					nctrun@ord3p:~/cursillo_cs/ejemplos/holamundo$ mono holamundo.exe
					Hola mundo 37
				\end{verbatim}
				\item Guay\ldots pero\ldots ¿Todo eso del CIL? ¿Era pipa?
				\begin{verbatim}
					nctrun@ord3p:~/cursillo_cs/ejemplos/holamundo$ monodis holamundo.exe |less
					.assembly extern mscorlib
					{
					    .ver 1:0:5000:0
					    .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4..
					}
					.assembly 'holamundo'
					{
					    .hash algorithm 0x00008004
					//...
				\end{verbatim}
				\item ¿Y lo de AOT?
				\begin{itemize}
					\item Por defecto, estamos utilizando el compilador JIT al hacer el \texttt{mono holamundo.exe}
					\item Si queremos utilizar el compilador AOT:
					\begin{verbatim}
						nctrun@ord3p:~/cursillo_cs/ejemplos/holamundo$ mono --aot -O=all 
						   holamundo.exe

						Mono Ahead of Time compiler - compiling assembly
						 /home/nctrun/cursillo_cs/ejemplos/holamundo/holamundo.exe
						Code: 205 Info: 34 Ex Info: 17 Class Info: 31 PLT: 4 GOT: 24
						Executing the native assembler: as /tmp/mono_aot_7PL9KZ -o 
						   /tmp/mono_aot_7PL9KZ.o
						Executing the native linker: ld -shared -o
						 /home/nctrun/cursillo_cs/ejemplos/holamundo/holamundo.exe.so 
						   /tmp/mono_aot_7PL9KZ.o
						Compiled 5 out of 5 methods (100%)
						0 methods contain absolute addresses (0%)
						0 methods contain wrapper references (0%)
						0 methods contain lmf pointers (0%)
						0 methods have other problems (0%)
						AOT RESULT 0
						nctrun@ord3p:~/cursillo_cs/ejemplos/holamundo$ file holamundo.exe.so
						holamundo.exe.so: ELF 32-bit LSB shared object, Intel 80386, version 1 
						   (SYSV), not stripped
					\end{verbatim}
				\end{itemize}
				\item ¿Y lo de integración entre lenguajes?
				\begin{itemize}
					\item Cojamos como ejemplo Java
					\begin{itemize}
						\item En el aula está instalado tanto Java 1.4 como Java 1.5 de Sun Microsystems
						\item Para cambiar de versión: \texttt{cambiarJava 1.4} (como root)
					\end{itemize}
					\item Vamos a \texttt{ejemplos/libreria}
					\begin{verbatim}
						nctrun@ord3p:~/cursillo_cs/ejemplos/libreria$ javac MiClase.java
						nctrun@ord3p:~/cursillo_cs/ejemplos/libreria$ ikvmc -out:MiClase.dll 
						   MiClase.class

						Note: automatically adding reference to 
						   "/home/nctrun/mono-1.1.16/lib/ikvm/IKVM.GNU.Classpath.dll"
						nctrun@ord3p:~/cursillo_cs/ejemplos/libreria$ export 
						   MONO_PATH=~/mono-1.1.16/lib/ikvm/:$MONO_PATH
						nctrun@ord3p:~/cursillo_cs/ejemplos/libreria$ mcs DesdeCS.cs -r:MiClase.dll
						nctrun@ord3p:~/cursillo_cs/ejemplos/libreria$ mono DesdeCS.exe
						hola mundo
						llamando al metodo
						nctrun@ord3p:~/cursillo_cs/ejemplos/libreria$
					\end{verbatim}
				\end{itemize}
				\item Más ejemplos $\rightarrow$ Cursillo de Mono
			\end{itemize}
		\end{itemize}
\newpage