\section{Introducción breve a la FCL}
	\subsection{Qué es la FCL?}
		\begin{itemize}
			\item La \textit{Framework Class Library} es el conjunto de librerías que vienen con el .NET Framework
			\begin{itemize}
				\item En Mono vienen por defecto también otra serie de librerías, algunas de las cuales se verán en el cursillo de Introducción a Mono
			\end{itemize}
			\item La mayoría de tipos de datos cuelgan del espacio de nombres \texttt{System}
			\item Un punto de comienzo para buscar algo podría : \href{http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/cpref_start.asp}{ser este} (\href{http://msdn2.microsoft.com/en-us/library/ms306608.aspx}{este} para .NET 2)
			\item Ejecutando \texttt{monodoc} también podemos acceder a la documentación
			\item En la web del \href{http://www.msc.deusto.es}{DotNetGroup} hay una sección \texttt{Documentación} en la que hay documentación de talleres que ha hubo el curso pasado en la que explica el uso de la FCL para comunicaciones con sockets, multihilo, etc. etc.
			\item Aquí sólo vamos a dar una pequeña parte y de pasada
		\end{itemize}
	\newpage
	\subsection{Clases básicas}
		\begin{itemize}
			\item Echando un ojo al espacio de nombres \texttt{System}, podemos ver clases que ya conocemos realmente como:
			\begin{itemize}
				\item \texttt{Console}: A la que ya estamos acostumbrados :-)
				\item \texttt{Int32}, \texttt{Byte}, \texttt{String}: cuando en C\# escribimos \texttt{int}, \texttt{byte} o \texttt{string}, internamente en CLI se están utilizando estos tipos de datos
				\item \texttt{Array}: Que es lo que hay cuando utilizamos arrays
			\end{itemize}
			\item También podemos ver la documentación de las excepciones más frecuentes:
			\subitem \texttt{ArithmeticException}, \texttt{DivideByZeroException}...
			\item Además podemos ver los espacios de nombres que hay definidos dentro de \texttt{System}, como por ejemplo:
			\begin{itemize}
				\item \texttt{System.Collections}: colecciones
				\item \texttt{System.IO}: manejo de entrada-salida
				\item \texttt{System.Threading}: manejo de hilos
				\item \texttt{System.Net}: redes
				\item \texttt{System.Reflection}: reflection
				\item \texttt{System.GC}: manejo del Garbage Collector
				\item \texttt{System.XML}: procesamiento de XML
			\end{itemize}
			\item y muchos muchos más
		\end{itemize}
	\newpage
	\subsection{Colecciones}
		\begin{itemize}
			\item En \texttt{System.Collections} hay una serie de clases e interfaces para usar pilas, colas, mapas...:
			\item Esto es, vienen definidas una serie de clases listas para ser utilizadas, como por ejemplo: \textit{(T4\_E01\_Colecciones)}
			\begin{itemize}
				\item \texttt{ArrayList}: Estilo \texttt{vector} o \texttt{Vector}. Permite el ir añadiendo, eliminando y modificando elementos a la lista
				\item \texttt{Hashtable}: Array asociativo. Permite añadir variables indexadas por otras variables
				\item \texttt{Stack}, \texttt{Queue}: pilas y colas
				\item \texttt{SortedList}: Listas ordenadas
			\end{itemize}
			\item Así como una serie de interfaces que implementan estas clases, sus valores, etc.
			\subitem \texttt{ICollection}, \texttt{IList}, \texttt{IDictionary}, \texttt{IComparer}...
			\begin{verbatim}
				using System;
				using System.Collections;
				
				class A{
				    public static void Main(){
				        ArrayList al = new ArrayList();
				        string s;
				        do{
				            Console.Write("Dame un algo (salir para salir): ");
				            s = Console.ReadLine();
				            al.Add(s);
				        }while(s.ToLower() != "salir");
				        string [] todasLasFrases = (string[])al.ToArray(typeof(string));
				        foreach(string frase in todasLasFrases)
				            Console.WriteLine(frase);
				    }
				}
			\end{verbatim}
			\item En C\# 2, encontramos nuevos tipos de datos que utilizan \texttt{generic}s en el espacio de nombres \texttt{System.Collections.Generic} \textit{(T4\_E02\_Colecciones)}:
			\begin{itemize}
				\item \texttt{LinkedList}: Lista doblemente enlazada
				\item \texttt{List}: Versión de \texttt{ArrayList} adaptada a \texttt{generic}s
				\item \texttt{Dictionary}: Versión de \texttt{Hashtable} adaptada a \texttt{generic}s
				\item \texttt{Stack}, \texttt{Queue}, \texttt{SortedList}\ldots adaptaciones a \texttt{generic}s de sus versiones en \texttt{System.Collections}
			\end{itemize}
		\end{itemize}
	\newpage
	\subsection{Ficheros}
		\begin{itemize}
			\item Las clases relacionadas con manejo de ficheros y directorios cuelgan de \texttt{System.IO}
			\item Ficheros de texto:
			\begin{itemize}	
				\item Fichero de texto lectura: \texttt{new StreamReader(nombre\_fichero)}, 
					\subitem o \texttt{File.OpenRead(nombre\_fichero)}, que devuelve un \texttt{StreamReader}
				\item Fichero de texto escritura: \texttt{new StreamWriter(nombre\_fichero)} 
					\subitem o \texttt{File.CreateText(nombre\_fichero)}, que devuelve un \texttt{StreamWriter}
				\item Console.Out y Console.Error son dos \texttt{TextWriter}s (y Console.In un \texttt{TextReader}). \texttt{StreamWriter} es hija de \texttt{TextWriter}
			\end{itemize}
			\item Ficheros y directorios:
			\begin{itemize}
				\item Manejo básico de ficheros (copiar, mover, eliminar\ldots) $\rightarrow$ \texttt{File.Move}, \texttt{File.Copy}\ldots
				\item Manejo básico de directorios (copiar, mover, eliminar\ldots) $\rightarrow$ \texttt{Directory.Move}, \texttt{Directory.Copy}, \texttt{Directory.Delete}\ldots
				\item ¿Separador de directorios? \\ en Windows\ldots / en UNIX\ldots $\rightarrow$ \texttt{Path.DirectorySeparatorChar} en todos :-)
			\end{itemize}
			\item Ver \textit{(T4\_E03\_Ficheros)}
		\end{itemize}
	\newpage

	\subsection{Hilos}
		\subsection{Introducción}
			\begin{itemize}
				\item Las clases relacionadas con manejos de hilos cuelgan de \texttt{System.Threading}
				\item Un hilo es un \texttt{System.Threading.Thread}
				\begin{itemize}
					\item Lanzando un hilo:
					\begin{verbatim}
						public void Funcion(){
						   //...
						}
						//...
						Thread t = new Thread(new ThreadStart(Funcion));
						t.Start();
					\end{verbatim}
					\item \texttt{System.Threading.ThreadStart} es un delegate declarado tal que:
					\begin{verbatim}
						public delegate void ThreadStart ();
					\end{verbatim}
					\item Utilizando delegates anónimos:
					\begin{verbatim}
						Thread t = new Thread(delegate{
						      Console.WriteLine("hola mundo desde otro hilo");
						   });
						t.Start();
					\end{verbatim}
					\item Esperando a que terminen:
					\begin{verbatim}
						t.Join();
					\end{verbatim}
				\end{itemize}
				\item Ver \textit{(T4\_E04\_Hilos)}
			\end{itemize}
		\subsection{Protección básica}
			\begin{itemize}
				\item La protección más básica para gestionar hilos en C\# es la palabra \texttt{lock}:
				\begin{verbatim}
					lock(instancia){
					    //Código
					}
				\end{verbatim}
				\item Lo que garantiza \texttt{lock} es que cuando un hilo entra en un \texttt{lock} de una instancia, cualquier otro hilo se queda bloqueado al llegar a un lock de esta instancia.
				\item Ver \textit{(T4\_E05\_Hilos)}
			\end{itemize}
		\subsection{Sincronización básica}
			\begin{itemize}
				\item A través de monitores podemos obtener una sincronización básica:
				\item Protegemos el código:
				\begin{verbatim}
					Monitor.Enter(instancia);
					    //código
					Monitor.Exit(instancia);
				\end{verbatim}
				\item Ponemos dentro \texttt{Wait} para permitir a otros entrar en la región protegida y \texttt{Pulse} para avisar hilos que estén en un Wait
				\begin{verbatim}
					Monitor.Enter(instancia);
					    //código
					    Monitor.Wait(instancia); //Me quedo esperando a que alguien me diga algo
					    //código
					    Monitor.Pulse(instancia); //aviso a alguien de que ocurre algo
					Monitor.Exit(instancia);
				\end{verbatim}
				\item También están otras funciones, como \texttt{PulseAll} (avisar a todos) o \texttt{TryEnter} (intentar entrar, si está bloqueado hacer otro código).
				\item Ver \textit{(T4\_E06\_Monitores)}
			\end{itemize}
		\subsection{Otros}
			\begin{itemize}
				\item En la Semana ESIDE 2005, Iñigo Herrero dio un \href{http://www.msc.deusto.es/LinkClick.aspx?link=Multithreads.rar&mid=404}{cursillo de manejo de hilos en .net}
			\end{itemize}
	\newpage
\newpage