martes, 13 de noviembre de 2012

Introducción al modelo de comando WPF



Introducción al modelo de comando WPF

El modelo de comandos de WPF consta de un sorprendente número de partes móviles. En total, cuenta con cuatro ingredientes claves:

Commands. Un comando representa una tarea y tiene un seguimiento de si puede o no ser ejecutado. Sin embargo, los comandos no contienen el código que realiza la tarea.

Command bindings. Es un enlace que une nuestro comando con algún objeto, podría ser por ejemplo un botón, para un área particular de la interfaz de usuario. Este diseño factorizado es importante, porque un solo comando puede ser usado en varios lugares de la aplicación y tienen un significado diferente en cada lugar. Para controlar esto, se utiliza el mismo comando con enlaces de comandos diferentes.

Command sources. Representa cuando se va activar el comando. Por ejemplo, un MenuItem y Button puede ser fuentes de comandos. Al hacer clic se ejecuta el comando vinculado.

Command targets. Un destino es el elemento sobre el cual el comando se realiza. Por ejemplo, un comando Pegar puede insertar texto en un cuadro de texto.

En el siguiente tutorial vamos a ver un ejemplo de cómo aplicar comandos en WPF, vamos a conocer la interface ICommand y qué relación tiene todo esto con el famoso patrón de diseño MVVM.

Más adelante voy armar una guía de mi experiencia con ese patrón pero quiero primero introducir el tema de los comando que para mí es el más complejo de todos, un saludo y en estos días voy a subir el siguiente post.

lunes, 21 de mayo de 2012

Analisis y Diseño


Análisis Y Diseño

Hola a todos, cada vez me cuesta  más escribir pero bueno voy a escribir un mini articulo de algo que para mí es fundamental, a la hora de construir un sistema si no hay una organización mínima el sistema empieza a crecer de una manera que se hace imposible seguirlo, quiero decirles que me paso esto en un sistema contable que por arrancar a programar sin hacer un análisis y ni que hablar de diseñar  jajaja, así me fue nunca pude terminar el sistema, lo lindo de esto es que era para un familiar así que la saque baratísima, pero me sirvió para no subestimar ningún proyecto y hacer un mínimo análisis de problema y un diseño de cómo mas o menos se va a encarar dicha solución.

Con que vamos a trabajar para el análisis y el diseño?, con el señor UML lenguaje unificado de construcción de modelos, seguramente lo habrán escuchado nombrar en más de una ocasión.

Pero antes vamos hacernos una idea de que es el análisis y el diseño.

  • El análisis se centra en una investigación del problema, no en definir la solución.
  • El diseño pone de relieve una solución lógica, como el sistema cumple con los requerimientos.Los diseños se implementan en software y hardware.
Se podría decir que con el análisis conocemos el problema y vamos viendo el alcance del mismo, los límites del sistema y con el diseño empezados a ver cómo podríamos dar solución a los problemas encontrados en el análisis.

Normalmente en estos casos se habla de un modelo descriptor, que es el que armamos con el análisis, como actualmente están funcionando las cosas.

Con el diseño armamos un modelo solución, como van a funcionar las cosas cuando implementemos nuestro sistema.

Bueno amigos se que es breve pero es la única manera de obligarme a publicar en el próximo articulo vamos a empezar a ver que es UML, y cuáles son los diagramas mas utilizados, saludos.

sábado, 17 de marzo de 2012

Eventos - Tutorial 6


Crear Eventos Enrutados 

Bueno hola a todo el mundo después de mucho tiempo vuelvo a seguir con los eventos, espero algún día terminar jajaja, estoy muy vago pero bueno voy a tratar de escribir 1 articulo por semana ya que el laburo me tiene complicado tengo que terminar y me parece que me va a pasar algo a al 99% de los desarrolladores nos pasa no terminar a tiempo jajaja, me rio para no llorar, bueno me dejo de llorar y arrancamos con la creación de un evento, primero voy a pegar una imagen muy ilustrativa de la diferencia entre los eventos de tipo burbuja suben por el árbol y los de tipo túnel que bajan por el arbolito de elementos.



Ahora que nos acordamos de cómo funcionaban vamos a comenzar, …… a seguir repasando conceptos son necesarios, el modelo de estos eventos es muy similar a lo que son las propiedades de dependencia, ya vamos hablar de esto cuando termine con los eventos, si ya sé que tendría que haber arrancado con eso primero pero yo les digo que no porque nosotros arrancamos hablando de eventos básico los que usábamos en el querido WinForm y ahora tocamos los nuevos eventos que los podemos usar en WPF o Silverlight. 

Para el ejemplo vamos a ver la clase Button, y el evento Click:

public abstract class ButtonBase : ContentControl, ...
{
    //Aca definimos el evento – que es el conocido Click
    public static readonly RoutedEvent ClickEvent;

    //Registramos el eventos
    static ButtonBase()
    {
        ButtonBase.ClickEvent = EventManager.RegisterRoutedEvent(
          "Click", RoutingStrategy.Bubble,
          typeof(RoutedEventHandler), typeof(ButtonBase));
        ...
    }

    // Encapsulamos el evento
    public event RoutedEventHandler Click
    {
        add
        {
            base.AddHandler(ButtonBase.ClickEvent, value);
        }
        remove
        {
            base.RemoveHandler(ButtonBase.ClickEvent, value);
        }
    }
     ...
}

Para resumir de una manera muy básica son 3 pasos:
  • Definimos
  • Registramos
  • Encapsulamos

Como se los describo es facilísimo, aunque no sé si es tan fácil, pero para que se queden contentos les voy a decir que si, después cuando creen sus eventos seguramente se van acordar de mi, espero que de buena manera.

Un breve repaso, EventManager.RegisterRoutedEvent(….)

public static RoutedEvent RegisterRoutedEvent(
        stringname,
        RoutingStrategy routingStrategy,
        Type handlerType,
        Type ownerType
)

Esto es importante que lo sepamos como dijimos a la hora de registrar el evento le vamos a poner un nombre que puede ser lo que se les ocurra pero lo ideal es mantener una relación coherente no como normalmente hago yo que le pongo cualquier cosa, y después cuando dejo el proyecto por 2 semanas tengo que tomarme 4 meses para saber que carajo hice, no hagan como yo hagan las cosas bien muchas veces cuenta pero a la larga es mejor se los digo por experiencia propia.

El segundo parámetro es el tipo directo, túnel o burbuja, el tercero es el tipo del controlador del evento que por defecto es RoutedEventHandler, y el cuarto es la clase en donde esta definido el evento en el caso del ejemplo es ButtonBase.

Y el ultimo paso es encapsular, para despedirme voy a poner el ejemplo en el que le puse un nombre y al encapsulamiento otro distinto pero es un error menor aunque lo ideal es evitarlo.


        #region EVENTOS

        public static readonly RoutedEvent DatoChangedEvent = 
            EventManager.RegisterRoutedEvent( "Selected"RoutingStrategy.Bubble, 
                typeof(RoutedEventHandler), typeof(ArribaAbajo));


            public event RoutedEventHandler DatoChanged
            {
                add { AddHandler(DatoChangedEvent, value); }
                remove { RemoveHandler(DatoChangedEvent, value); }
            }

        #endregion

Ahí en mi ejemplo el paso 1 y 2 los hago juntos, y lo que les decía que eviten yo ahí nombre el evento como “Selected” y después lo encapsulo como DatoChanged, pero bueno son cosas que pasan.


Lo puedo lanzar de la siguiente manera:

arribaAbajoAñosRecidencia.DatoChanged += 
new RoutedEventHandler(arribaAbajoAñosRecidencia_DatoChanged);
            
void arribaAbajoAñosRecidencia_DatoChanged(object sender, RoutedEventArgs e)
{
   throw new NotImplementedException();
}

Y  podría dispáralo de la siguiente manera:

 //creo el evento
RoutedEventArgs args = new RoutedEventArgs(DatoChangedEvent); 
//disparo 
RaiseEvent(args);


Ahora si mis queridos lectores, me despido hasta la próxima creo que ya podemos decir que tenemos una idea general de todo, por el código de ejemplo no se asusten si no me entendieron en el próximo tutorial, el 7 que es donde voy a dar por finalizado el tema voy a crear un control de usuario o extender un control como por ejemplo un textbox y agregarle un evento y llamarlo, lanzarlo, matarlo……….., etc, igual siempre algo nuevo sale y cuando eso pase seguramente armare algún artículo como para llevar el actualizado el tema.

jueves, 1 de marzo de 2012

Entity Framework - Tutorial 1

Mapeo de Objeto-Relacional

Hola a todos los lectores, hoy voy a tocar uno de los temas más importantes en la actualidad, que es el mapeo de una base de datos, ya vamos a ir explicando que es todo esto de una manera bien fácil, para que nadie salga corriendo.

Digamos que en el 99% de los casos, por no decir en el 99,99%, cuando desarrollen una aplicación van a utilizar una base de datos, si tienen experiencia en algún lenguaje como por ejemplo visual basic, el leguaje con el que di mis primeros pasos, me puse nostálgico jajaja, pero bueno sigamos, saben que el tema de las consultas es un tema que complica y mucho, el panorama mejoro mucho con los queridos DataSet de .net, y particularmente me emociono con la salida de entity framework que es el ORM estrella de .NET, seguramente más de uno escucho o leyó algo sobre el, lo cierto es que no es el único hay muchos ORM, tanto en .NET, como en otros lenguajes, en JAVA unos de los orm mas conocidos es Hibernet, pero bueno sigo sin explicarles que es, no se pongan nerviosos ahora voy a empezarles a explicarles todo lo fundamental.

¿Qué es un ORM?

Es un componente de software que nos permite trabajar con los datos persistidos como si ellos fueran parte de una base de datos orientada a objetos , mas fácil como la mayoría de las bases de datos trabajan de forma relacional, y la metodología de desarrollo más populares son las orientadas a objetos, lo que hacen los programitas estos es transformar la base de datos relacional a una base de datos de objetos.

Entonces las hermosas siglas en Argentino significan Mapeo Objeto-Relacional, es decir que pasa una base de datos relacional a objetos, mas adelante vamos a ver que podemos crear la base de datos en el programa y convertirla en relacional, pero de eso vamos hablar en otro artículo.

Vamos a mirar un ejemplo, en la siguiente imagen tenemos una base de datos con 2 tablas, categoría y productos, la relación es 1 a muchos, es decir que en una categoría hay muchos productos.







En la siguiente imagen podemos ver la misma base de datos pero mapeada, ahora para que veamos algunas de las cosas interesantes que tiene el mapeo vamos a ver consultas en ambos escenarios.








Es prácticamente igual la diferencia es que en la base de datos mapeada podemos hacer uso de todos los conceptos que tenemos en la programación orientada a objetos.


No me quiero adelantar mas en el próximo tutorial vamos a ver cómo crear el mapeo haciendo uso de Entity Framework, para después poder ver LINQ to Entities que es la manera más fácil de de hacer consultar sobre el modelo, me despido hasta el próximo articulo un saludo a todos.

miércoles, 29 de febrero de 2012

Eventos - Tutorial 5



Routed Event, llego el dia que me decidí a Escribir.

Antes que nada, hola a todos, después de tanto tiempo volvemos, voy a explicar la idea general de los Routed Event (Eventos Enrutados), lo primero que vamos a decir es que son una evolución de los eventos tradicionales, agregan unas cuantas características más, pero como es una evolución de los eventos comunes los mismos pueden ser consumidos de la forma tradicional, es más si trabajan sobre ellos no van a notar diferencia, la diferencia se nota cuando creamos nuestros propios eventos ahí vamos a notar que cambia un poco mucho para mi gusto la mecánica.

Algo que hay que decir es que este tipo de eventos los van a encontrar en WPF y Silverlight, no están disponibles para los queridos WinForm, ya que en WPF podemos por ejemplo dentro de un botón poner un texto, dentro de ese texto otro y una imagen, lo que les quiero decir es que dentro de un control puede haber otros controles, de ahí  sale el concepto de árbol de objetos de WPF, que es un árbol, una estructura como por ejemplo la de las carpetas de Windows, donde la raíz del árbol estaría representada por el disco. Para que quede claro voy  a poner una imagen de una pantallita que estoy armando, está en desarrollo así que la estética queda pendiente jajaj pero va a servir como ejemplo:


Ahí tenemos la pantalla y el árbol, como pueden ver la raíz en este caso está representada por un objeto Windows, en el caso de Silverlight seria page, en el caso del querido WinForm, seria espero lo digan antes de leerlo el Form.





Acá viene lo fundamental de los eventos enrutados, que cuando se disparan pueden subir por el árbol de elementos de WPF o bajar, y más de uno se pregunta para que sirve esto, como estoy contento y feliz como me dijo un gaucho hace unos días les voy a pongamos el ejemplo donde hay 3 botones, el botón 1 que tiene dentro al botón 2 y este posee al botón 3, hacemos clic en el 2 boton que pasa porque al estar el botón 2 en el botón ¿?????? y se plantea el problema bueno seguro se están haciendo varias preguntas esa es mi idea así paso a contarles que los eventos enrutados se dividen en:

                  Eventos directo (Direct). Estos son los conocidos eventos de .NET. Se originan en uno de los elementos y no pasan a ningún otro.

                  Eventos de propagación (Bubbling). Estos eventos se transmiten a la jerarquía de contenedores. El evento se dispara en el elemento que lo origina y luego, es levantado por el padre de ese elemento, y luego por el padre de ese elemento, y así sucesivamente, hasta que WPF alcanza la cima del árbol de elementos.

                  Eventos de túnel (Tunneling). Estos eventos viajan por el árbol de contenidos. Ellos te dan la oportunidad de ver (y posiblemente detener) un evento antes de que alcance el control adecuado.

Otra cosita importante es se acuerdan que hablamos de las firmas de los eventos, bueno en el caso de los eventos enrutados, se mantiene la firma pero como imagino que mas de uno no sabe de lo que le estoy hablando hacemos un repasito, el primer parámetro es un objeto que representa el elemento que origina el evento, y el segundo es un objeto que contiene los argumentos, se acordaron?, espero que si, pero en el caso de nuestros nuevos amigos, el parámetro sender es siempre el elemento al cual fue enlazado el manejador del evento, y el parámetro  que contiene los argumentos en lugar de heredar de la clase EventArgs, lo hace de una clase RoutedEventArgs se acuerdan que algo de esto en un ejemplo anterior les presente a la clase RoutedEventArgs que tiene las siguiente propiedades:
  • Source. Es el elemento en el árbol lógico de objetos WPF que origino el evento.
  • OriginalSource. Es el elemento en el árbol visual de objetos WPF que origino el evento.
  • Handled. Es una propiedad de tipo bool que sirve para indicar si el evento fue manejado y por tanto permite detener la propagación del evento a través del árbol de objetos WPF (esto es muy útil, después vamos a ver un ejemplito).
  • RoutedEvent. Representa el evento actual, es muy útil cuando se enlaza el mismo manejador a varios eventos.

Espero que más o menos ya tengan una idea general de lo que son los eventos enrutados y las novedades que tiene, en el próximo artículo, vamos a ver como declarar un evento y si hago tiempo voy a poner algo de código para que ya puedan practicar, un saludo a todos.

martes, 31 de enero de 2012

Eventos - Tutorial 4

Hola mis amigos, como para no perder ritmo voy cumplir a medias, lo de RoutedEvent lo estoy armando pero voy lento para que sea fácil ya que son muchos conceptos y antes me interesaría explicar otras cositas como por ejemplo, estos dos delegados que seguro les van a llamar mucho la atención:

•    Action(Of T)
•    Func(Of TResult)

Estos 2 tipos de delegados tiene muchas variantes yo voy a explicar solamente estos, pero creo que va a ser suficiente como para que los otros los entiendan sin ninguna dificultad, la dirección de la ayuda de los amigos de Microsoft es: http://msdn.microsoft.com/es-es/library/018hxwa8.aspx


Ahí vamos, Action(Of T) es un delegado al que le podemos pasar un parámetro, esto nos da la posibilidad de evitar tener que hacer esto public delegate void Mesajoto(string message); entonces yo con Action(Of T) puedo tener infinitas posibilidades, que les quiero decir?? que si quiero pasar un strin, int o una clase lo hago directamente con Action( mi tipo de datos) y me evito tener que declarar un delegado especifico, pero también esta como antes habíamos dicho la posibilidad de hacer un public delegate void DelegadoGenerico(object obj); pero lo que nos da Action y les voy a poner un ejemplo extremo que es Action(Of T1, T2, T3, T4, T5, T6, T7, T8, T9) donde el delegado en este caso no devuelve ningún valor y acepta 9 parámetros del tipo que más les guste.


Es una alternativa interesante pero el detalle a tener en cuenta es que este tipo de delegado nunca devuelve ningún valor, para esto tenemos a Func(Of TResult), es muy similar al anterior con la diferencia de que en este caso, el método que encapsula no tiene parámetros y devuelve un valor, un ejemplo seria public delegate bool EsVerdadero(); acá se ve el caso de un delegado que devuelve un valor booleano true/false. También tiene muchas variantes pero eso se los voy a dejar a ustedes, se que si entendieron esto no les va a costar nada ver los otros ejemplos.

Espero haya quedado claro vuelvo a retomar ya que arranque saliéndome de la pista con los 2 conceptos esos pero sé que les va a servir, es mejor que sobre y no que falte, dejando de lado los refranes vamos a seguir por el camino y vamos a conocer bien a EventHandler, vamos a pensar en como si fuera una minita que se parte de buena, así nos interesamos muchísimo en ella jajaja.


Bueno EventHandler es un delegado, que representa un método que controlará un evento que no tienen datos de evento.

Mas fácil hagan de cuenta que EventHandler es igual  a escribir

public delegate void EventHandler(Object sender, EventArgs e);


Si miran bien y se acuerdan del tutorial numero 3 corresponde a como estandarizábamos el diseño de los eventos, 2 parámetros,  si no se acurdan revisen el tutorial anterior.

Con esto lo que les quiero decir es que si necesitamos un evento donde no tengamos que pasar información declaramos un evento como el siguiente:

 public event EventHandler SimpleEventHandler;

La clase EventArgs que no contiene datos de evento, pero si necesitamos parar datos relacionados al evento, tenemos la posibilidad de usar EventHandler(Of TEventArgs), podríamos tener el siguiente ejemplo:

public event EventHandler<PersonaEventArgs> ListaPersonas;

public class PersonaEventArgs: EventArgs
    {
        //Código que en el próximo tutorial voy a poner.
    }

 

Lo que quiero mostrar es que si pasamos como parámetro una clase la misma tiene que heredar de EventArgs, porque es la clase base para las clases que contienen datos de eventos.

Bueno gente me despido, espero les sirva de algo ya que es una distracción y un gusto como digo siempre compartir lo poco que se con ustedes, yo aprendo día a día muchísimo en los blogs y en los foros, y quiero hacer mi pequeño aporte con estos tutos, ahora si hasta la próxima un saludo, y en el siguiente tutorial voy a subir un ejemplo.

jueves, 19 de enero de 2012

Eventos - Tutorial 3

Hola mis amigos antes de seguir con este hermoso tema voy a contarles que hice un código bien simple, en el que para cargar un vehículo necesitan al dueño del mismo y lo seleccionan de una grilla al hacer clic en el botón seleccionar se pasa el dato a la pantalla de vehículo, es ejemplo es básico pero da una idea del uso que podemos darles. Descargar Código de Ejemplo.

Descarguen prueben, modifiquen, jueguen con el código así se aprende y cualquier duda me consultan, no hay ningún problema.

Vamos a tocar el tema de cómo Estandarizar un diseño de eventos, digamos que como vimos C# acepta cualquier diseño de delegado, pero los muchachos de .NET nos recomiendan el diseño de delegados con 2 argumentos. Si miran cualquier ejemplo de evento de C#,  hay 2 argumentos un ejemplo es el siguiente controlador más fácil método donde ponemos el código cuando se dispara un evento el caso más típico es el clic de un botón:

  1. El evento es el “Clic”
  2. Hay un disparador, que salta cuando hacemos… si clic sobre el botón.
  3. Tenemos un método donde ponemos lo que va a pasar cuando se haga clic, un ejemplo  podría ser el código del botón “seleccionar” del ejemplo.


















En este caso se ve lo que les digo object, es el objeto que desencadena el evento y RoutedEventArgs es el objeto relacionado con el evento. En este caso como estoy usando WPF en vez de WinForm el objeto es RouterEventArgs, sino seria un objeto del tipo EventArgs. Vamos a conversar sobre WPF mas adelante.
Bueno si les pregunto cuales son los 2 elementos, ustedes con carita de feliz cumpleaños responden:


Bueno si les pregunto cuales son los 2 elementos, ustedes con carita de feliz cumpleaños responden:

•    Una referencia al objeto que desencadeno el evento.
•    Un objeto que contiene datos relacionados con el evento.


Bueno el punto 2 tiene el siguiente punto a considerar, pero antes aclaro que al usar WPF ese objeto es RouterEventArgs, cuyo espacio de nombres es System.Windows, en el caso de WinForm es como ya dijimos EventArgs y su espacio de nombre es System.


Lo que es definitiva quiero decir es que tiene que heredar de alguna de esas clases dependiendo en la tecnología que estén para el caso de WinForm es únicamente EventArgs, para WPF cualquiera de los 2 casos, dejemos acá porque me estoy metiendo en terreno minado el próximo tutorial vamos a tocar este tema.


En definitiva la idea seria algo así:








Creo que hasta acá vamos 10 puntos voy a armar el mismo ejemplo con los delegados de esta manera, y para la próxima clase vamos a ver la diferencia que tiene WPF con los “RouterEventArgs”, como pasar parámetros personalizados, así que tenemos para seguir aprendiendo, un abrazo y cuando tenga un tiempo cargo el siguiente tuto.

miércoles, 11 de enero de 2012

Eventos - Tutorial 2

Hola a todos, me tome unas vacaciones y para publicar este articulo prácticamente tuve que volver a entender yo como era el tema de los eventos y delegados jajá, bueno en el primer tutorial hicimos una primera aproximación de cómo crear un evento, seguro se están preguntando como utilizo el evento, antes de responder a esa preguntita, vamos a poner más en claro lo que es un Delegado no les voy a mentir me leí mas de un libro y para mi mala suerte también  la ayuda de Microsoft, es muy completa pero pesadísima de seguir en mi humilde opinión.

Ya estamos así que  vamos a empezar con el amigo Delegado:
Un Delegado es un tipo que define una firma de método. Lo que dice la frase es que si se crea una instancia de un delegado se lo puede asociar con cualquier método que tenga una firma compatible.

Si no te queda muy claro lo que es una “Firma”, no se hagan drama ahora lo vamos a ver con un ejemplo para que la cosa quede más clara:

Supongamos que tenemos un método como este:


public int Sumar(int x, int y)
{
   int resutado = x + y;

   return resultado;
}

Este método se lo puede asignar a una instancia de un delegado de tipo Calcular que es el que representa a la Firma. Para más claridad vamos a poner un ejemplo:

//Creamos la instancia del delegado
Calcular calculito = Sumar;
//Invoco al delegado
int resultadoSuma = calculito(2,5);

Entonces podemos decir que invocar a un delegado es como invocar a un método, si podeos decir que es más o menos así. Pero vamos a aclarar las líneas anteriores para que sea todo transparente, que términos estoy metiendo se ve el que fernet saca mi poeta interior jajaja.
La primera línea es una abreviatura de:

Calcular calculito = new Calcular(Sumar);


y calculito(2,5); es igual a poner Calculito.Invoke(2,5);

En definitiva creo o espero que con esto quede más o menos claro lo que es un delegado, hay muchísimas más cosas pero las iremos viendo más adelante.

Bueno con lo que sabemos hasta acá alcanza como para poder entender el siguiente ejemplito, pero antes aclaro que cuando termine con los tutoriales de Eventos y Delegados voy a poner un código de ejemplo para que sea todo más claro, ahora explico el ejemplo:

Tenemos una ventana llamada “CargarVehiculo” y otra “SeleccionarPersona”, lo que necesitamos para cargar un vehículo es seleccionar el dueño del vehículo, de mas esta decir que las personas ya están cargadas en la Base de Datos.

La mecánica es que en la pantalla CargarVehiculo vamos a tener un botón para seleccionar una persona, para hacer esto vamos lanzar un evento para capturar esa persona y del otro lado el disparador, sé que no suena muy fácil y yo ya a las 3 de la mañana no estoy tan ágil para explicar, sepan disculpar pero con el ejemplo todo va a quedar más claro.

Solución:
Bueno en la pantalla SeleccionarPersona definimos el evento, es decir todo lo que se explico en el tutorial 1.
En la pantalla CargarVehiculo vamos a lanzar el evento y poner el código.

Este código esta en CargarVehiculo:

WinBuscaPersona SeleccionarPersona = new WinBuscaPersona();
SeleccionarPersona.MiEntidadSeleccionada += new WinBuscaPersona.MiSeleccion(miEmpresaSeleccionada);
SeleccionarPersona.ShowDialog();

//Si miran bien este método coincide con el delegado del tutorial 1.
void miEmpresaSeleccionada(object Entidad)
{
   //Mi código
}


Este código esta en SeleccionarPersona (mas lo definido en el tutorial 1)

OnMiEntidadSeleccionada(personita);
Close();

Hasta acá llegue siguiéremos con más de Eventos y Delegados, en el tutorial 3 y les voy a poner el código de todo lo aprendido para que sigamos siendo amigos, un abrazo.

Access