Clase
IX
Objeto SQLConnection y SQLDataReader
Objetivo
Aquí veremos como consumir datos desde una fuente de datos (en éste caso
utilizaremos la base de datos de Northwind de SQL)
Duración Aproximada
20 minutos
Pasos o Recomendaciones
1) Primeramente veremos como crear una conexión con SQLServer
utilizando el objeto SQLConnection ubicado en el namespace System.Data.SqlClient
2) Vamos a crear un nuevo proyecto llamado Ejercicio4 del tipo aplicación
de consola
3) Primeramente vamos a importar los namespaces System.Data y System.Data.SqlClient
4) Luego dentro del método main declararemos un
objeto llamado dtEmpresas del tipo DataTable y le agregaremos dos DataColumn
llamados CustomerID y CompanyName
5) Declaramos un objeto sqlconnection llamado myconn y le indicaremos el connectionstring
que utilizará (ántes de realizar la operación,
se debe verificar que el connection string sea el correcto en el ámbito donde se va a ejecutar)
6) Creamos un objeto SQLCommand y le indicamos la
cadena TSQL que utilizará y el objeto sqlconnection
que utilizará
7) Creamos ahora un objeto SQLDataReader y le
indicamos el Select Command
Text y el objeto slqconnection
que utilizará
8) Ahora abrimos la coneccion con la base de
datos. Creamos un objeto DataReader llamado mydr e invocamos el método ExecuteReader
del objeto mycomando que anteriormente hemos creado.
9)
Luego cargamos el objeto dtEmpresas, utilizando el método Load y pasandole
en el argumento el objeto Datareader. Por último
cerramos la coneccion
10)Por último vamos a recorrer los registros obtenidos y representarlos en
la consola
11)El resultado final será el siguiente:
Hasta aquí, hemos aprendido a llenar un datatable por medio de su método Load y indicandole
un objeto DataReader.
Objeto SQLConnection
y SQLDataAdapter (.Fill)
Objetivo
Obtener conocimientos básicos en el manejo de los objetos connection y el objeto dataadapter
Duración Aproximada
15 minutos
Pasos o Recomendaciones
1) Basado en el ejercicio anterior (de la clase pasada) , ahora veremos de
realizar la mísma operación pero utilizando el objeto
DataAdapter en ves del objeto DatarReader.
2) Lo que vamos a hacer primeramente es eliminar el código que se muestra
encuadrado a continuación
3) En el lugar que previamente borramos creamos un objeto SQLDataAdapter y le indicamos el Select
Command Text y el objeto slqconnection que utilizará
4)
Ahora abrimos la coneccion con la base de datos y rellenamos el contenido
obtenido en el objeto DataTable llamado dtEmpresas. Por último
cerramos la coneccion
Por
último ejecutamos la aplicación presionando F5 y vermos
los mismos resultados que ántes
5) Hasta aquí, hemos aprendido a llenar utilzando
el método fill del objeto dataadapter
para llenar el contenido en un datatable
Objeto SQLConnection
y SQLDataAdapter (.Update)
Objetivo
Obtener conocimientos básicos en el manejo de los objetos connection y el objeto dataadapter
utilizando el método Update()
Duración Aproximada
20 minutos
Pasos o Recomendaciones
1) Basado en el ejercicio anterior, ahora veremos de realizar la mísma operación pero vamos a realizar cambios en nuestro datatable y luego volcarlos a la base de datos. De ésta
manera pondremos en práctica el modelo de acceso a datos desconectados.
2) Utilizando el mísmo ejercicio anterior vamos a
ubicarnos al final del código y vamos a agregar el siguiente código.
3) Ahora recorremos la colección de datarows en
busca del customerid
4) Si no llegaramos a encontrar el customerid entonces enviamos un mensaje y finalizamos la ejecucion del programa
5) Si encontramos el customerid, entonces me
traigo el DataRow correspondiente que tiene dicho customerid y muestro en consola el nombre original y
solicito un nuevo nombre para dicha empresa: 
6) Ahora que eh obtenido el nuevo nombre, modifico el datarow,
pero primeramente hay que llamar al método .BeginEdit
del propio datarow para luego poder asignarles
valores y por último se debe llamar el método EndEdit()
como se muestra en la siguiente figura:
7) Creamos un objeto command que será utilizado
por el dataadapter para poder realizar los cambios
necesarios en la base de datos. El objeto command que
crearemos se llamará updcomando y le debemos indicar
la cadena TSQL que utilizará para llamar a la BD y los parámetros que utiliza,
tanto como su nombre, el tipo de dato, la longitud y el nombre del campo de
nuestro datatable.
8) Por último adjuntamos éste objeto a nuestro DataAdapter
(myada) para luego invocar su método .Update() e indicarle el datatable
que tiene que actualizar contra la base de datos.
9) Hasta aquí hemos aprendido a consultar en la base de datos, traer los
resultados y guardarlos en un objeto en memoria (datatable),
modificar su contenido y volver a conectarnos a la base de datos para guardar
los cambios.
10)De ésta manera se ve reflejado la importancia y trabajar en forma desconectada.
DataBinding
Duración Aproximada
35 minutos
Pasos o Recomendaciones
1) En éste ejercicio mostraremos básicamente como enlazar datos de un
origen de datos con un control de WinForms,
2) Para ello crearemos un proyecto del tipo “Windows Application”
con el nombre de “Ejercicio7”
3) Primermente
arrastraremos desde nuestro ToolBox en la sección
“Data”, arrastraremos y colocaremos el control DataGridView
sobre nuestro formulario “Form1”, una vez colocado resaltará un cuadro de
tareas correspondiente al DataGridView de donde
seleccionaremos de “Choose Data Source”
la opcion “Add Project Data
Source…”
4) Una ves que seleccionamos “Add Project Data Source..” aparecerá un cuadro con templates,
de donde seleccionaremos “DataBase”
5) Seleccionamos DataBase, luego “Next”, luego presionamos el boton
“New Connection...”. luego
veremos un cuandro de dialogo para seleccionar el
origen y la base de datos. (dependiendo del ambito
donde se desarrolle el curso, se deberia verificar
primeramente el nombre y la instancia de sql donde
resida una base de datos Northwind).
6) Una vez que hallamos presionado “Ok”, VisualStudio nos notificará que es dentro de la cadena de coneccion hay datos importantes (nombre de usuario,
contraseña), Presionamos “Yes” sobre el cuado de
dialogo”
7) Ahora VisualStudio nos brinda la posibilidad
de guardar el conecction string
dentro de un archivo externo de configuración, ya que si en el día de mañana
cambia la ubicación del servidor, o las claves, etc, habria que entrar al código de la aplicación para modificar
y volver a recompliar el programa. De ésta manera
queda guardado en un archivo externo a la aplicación.
8)
Por último seleccionaremos
de Tablas, la tabla Customers, y de ahí
seleccionaremos únicamente los campos CustomerID y CompanyName. Por último
presionamos “Finish”.
9) Luego de finalizado el asistente veremos que el control DataGridView esta enlazado con un control llamado “customerBindingSource”, que a su ves éste control esta
enlazado con un northwindDataSet (un dataset tipado que ha creado) y
un customerDataTable que utilizara para realizar las
consultas y/o modificaciones sobre la base de datos.
10)Si presionamos F5 veremos que automaticamente
se rellena el contenido en el control DataGridView
11)Fin
Semáforos
Objetivos
El objetivo de este lab
es el de comprender como los semáforos pueden ser utilizados para controlar las
threads. Además, al igual que el resto de los labs de este primer módulo, será útil para comenzar un
acercamiento a Visual Studio 2005.
Duración Aproximada
30 minutos
Pasos:
1) Crear una nueva aplicación tipo consola, en c#,
en la carpeta Labs, con el nombre “SemaforosLab”.
2) Agregar una nueva clase al proyecto, con el nombre de Tester
3)
Agregar:
using
System.Threading;
en
ambos encabezados. Esto es requerido para poder hacer una aplicación multi-threading.
4) En la clase Tester agregar dos propiedades:
private Semaphore
sem;
private int _id;
una
es el semaforo que compartiran
todas las clases, la otro es un identificador de la instancia.
5) Agregar un constructor con parametros:
// Constructor
public Tester(int i)
{
_id = i;
sem = new Semaphore(1, 1, "ElSemaforo");
}
Asigna
el id a la instancia, y define el el
semaforo que sera
compartido por todas las instancias por tener el mismo nombre. En principio,
permite que las threads corran de a una.
6) El objeto tester tiene que tener un método que
ejecute algo:
// Metodo
que ejecuta algo
public void
Ejecutar()
{
for (int j = 0; j < 5; j++)
{
//
Activacion del semaforo
sem.WaitOne();
for (int i = 0; i
< 5; i++)
{
Console.WriteLine("Tester
{0}", _id);
Thread.Sleep(200);
}
// Liberacion del semaforo
sem.Release();
}
}
Este
metodo va a imprimir su id
por consola 5 veces dentro del waitOne del semaforo, en 5 oportunidades. Observar que el semaforo se activa, y luego se abre, para que el recurso
pueda ser tomado por otra thread.
7) Desde el main de la aplicación de consola,
deben ser creadas y ejecutadas cada una de las threads,
esto se realiza con el siguiente código, que va dentro del main.
for (int i = 0; i < 5; i++)
{
Tester obj = new Tester(i);
Thread t = new Thread(new ThreadStart(obj.Ejecutar));
t.Start();
}
Console.ReadLine();
Se
crean 5 testers y se los ejecuta en 5 threads distintas. El ultimo ReadLine
es para que no se cierre la consola al terminar la ejecucion
y se puedan observar los resultados.
8) Correr la aplicación. Observar como el recurso, en este caso el uso de
la salida de consola, es accedido de a una thread por
vez.
9) Modificar la cantidad de threads que acceden
al semaforo por vez, cambiando la linea:
sem = new Semaphore(2, 2, "ElSemaforo");
Observar las diferencias con la ejecución anterior.
Generics
Objetivos
El objetivo de este lab
es comprender el uso de los Generics, a partir de la implementacion de una lista generica
(First In Last Out), y su utilizacion. Ademas, permitirá un
acercamiento con Visual Studio 2005.
Duración Aproximada
45 minutos
Pasos:
1)
Crear una nueva aplicación tipo consola, en c#, en la
carpeta Labs, con el nombre “GenericsLab”.
2) Agregar
una nueva clase al proyecto, con el nombre de ListaGenerica
3)
Esta clase debe implementarse como genérica, por lo tanto, al declararla debe
aparecer como:
public class ListaGenerica<T>
4)
La lista debe contener nodos. Cada nodo tiene su dato, que será del tipo T, y
deberá poder conocer al proximo nodo (Next) para poder implementar la lista del tipo FILO.
Completar la siguiente clase para implementar dicho nodo:
protected class Nodo
{
// Implementar las properties Next y Data para
estos
// fields
public Nodo
next;
private T data;
public Nodo(T t)
{
//Implementar
constructor
}
}
5)
Ahora que disponemos de un Nodo, la clase lista genérica debe conocer solo a
uno, el nodo head:
protected Nodo head;
6)
La lista debe implementar dos metodos, Agregar y
Sacar. El primero agregar un elemento del tipo T, creando un nuevo nodo y dejandolo como head, y el segundo
devuelve un elemento del tipo T, eliminando el nodo head
y dejando como head el nodo que esta referenciando el antiguo.
// Agrega un nodo en el tope de la lista
public void Agregar(T t)
{
// Instanciar un nuevo
nodo, y agregarlo como head
// Tener en cuenta que el
actual Head debe quedar
// Referenciado como Next
desde el nuevo nodo
}
// Obtiene el
dato del primer nodo de la lista
// y lo
elimina
public
T Sacar()
{
// Devuelve Data del nodo
head, luego
// Tiene que dejar como
head el nodo referenciado como
// head. Tener en cuenta
que es posible que no haya
// elementos en la lista,
por lo que el valor de devolucion // en ese caso, debe ser default(T);
}
7)
Por ultimo, debe implementarse el método GetEnumerator,
de IEnumerator<T>, para poder realizar un foreach por los valores de la lista.
// Implementa el GetEnumerator
// Devuelve
un IEnumerator<T> para poder hacer
// un foreach
de la lista
public IEnumerator<T> GetEnumerator()
{
Nodo current = head;
while
(current != null)
{
yield return
current.Data;
current
= current.Next;
}
// La lista fue vaciada
head = null;
}
8)
La clase ListaGenerica<T> esta terminada. En Main, crear varias listas, de diferentes tipos, ingresar
datos con el método Agregar, y sacandolos con los metodo Sacar, y con un foreach.
Mostrar los resultados por pantalla. Observar que ocurre cuando se trata de
sacar valor de una lista vacia ( uso del default(t) ).
Métodos Anónimos
Objetivos
El objetivo de este lab
es comprender el uso de anonymous methods,
a partir de la implementacion de un ejemplo simple de
calculo de bonus en funcion
de ventas para un grupo de empleados.
Duración Aproximada
20 minutos
Pasos:
1) Crear una nueva aplicación tipo consola, en c#, en la carpeta Labs, con el
nombre “AnonymousDelegatesLab”.
2) Definir el método delegate:
// Define
el método delegate
delegate decimal CalcularBonus(decimal ventas);
3) Definir la clase que utilizará ese método:
// Define Empleado
class Empleado
{
public
string nombre;
public decimal ventas;
public decimal bonus;
public CalcularBonus algoritmo_calculo;
}
4) Dentro de la clase Program,
definir un metodo para calculo de bonus.
Este método no es anónimo:
// Este es el método con nombre
// define una posible
implementacion del algoritmo de
calculo // de bonos
static decimal CalcularBonusComun(decimal
ventas)
{
return
ventas / 10;
}
5) Dentro de Main, definir
un multiplicador. Esta es una variable local que será utilizada por el anonymous delegate para calcular
el bonus.
decimal multiplicador = 2;
6) Definir los dos delegates,
uno que utilizara un método con nombre, que se definió arriba, y otro que
utilizará un método anónimo.
// Delegate definido con el método que no es anonimo.
CalcularBonus bonus_comun = new
CalcularBonus(CalcularBonusComun);
// Este Delegate es anonimo, no hay un metodo con
nombre definido
// Define un algoritmo de calculo alternativo
CalcularBonus
bonus_mejorado = delegate(decimal ventas) { return
multiplicador * ventas / 10; };
7) Crear un array de 4
empleados, a cada uno ponerle nombre y un valor de ventas. A dos, asignarles
como algoritmo de calculo bonus_comun, y a dos bonus_mejorado.
8) Crear un método estatico
que calcula los bonus:
public static void CalcularBonus(Empleado
empleado)
{
// Este metodo usa al
delegate guardado en empleado para realizar el
// calculo
// Notar que conoce el
valor de la variable local multiplicador, a
// pesar de que
// la misma esta fuera
del alcance del metodo.
empleado.bonus = empleado.algoritmo_calculo(empleado.ventas);
}
9)
Crear un método para el display del nombre de un empleado
y el valor de bonus.
10)Desde el Main, llamar a ambos métodos, para
cada uno de los empleados, y observar como, para cada empleado, se llama al delegate correspondiente, usando o sin usar un método con
nombre.