Mariano@Blog!

Workshop de desarrollo de aplicaciones Windows Store

2012-10-04T14:57:11Z

La semana próxima con mi compañero de Lagash, RodoF, estaremos dando un Workshop de desarrollo de aplicaciones Windows Store en el MUG los dias 10, 11, y 12 de Octubre.

Durante esos 3 dias haremos un repaso de la plataforma Windows 8, el diseño de aplicaciones Modern UI, y las herramientas y lenguajes que tenemos disponibles para desarrollarlas, todo esto con mucha practica.

!Y como bonus al final del workshop se ofrecerá la posibilidad e subir las aplicaciones que se desarrollen al Windows Store!

Aquí pueden ver el detalle del curso y registrarse.

Los esperamos!!

Día del Programador. Evento MUG

2012-09-12T15:02:38Z

Hola a todos.

Les acerco los materiales de la charla de ayer organizada por el MUG.

Gracias por participar.

Nos leemos!!

Desarrollo de Aplicaciones Metro para Windows 8 con Visual Studio 2012 - Charla MUG

2012-08-01T12:52:00Z

Hola a Todos.

Les dejo el link para descargar las PPTs y Fuentes de la charla sobre desarrollo de aplicaciones Metro que presentamos RodoF Guillermo y Yo en el MUG.

Gracias por participar.

Nos leemos!!

RUN 2012 Buenos Aires - Desarrollando para dispositivos móviles con HTML5 y ASP.NET

2012-03-22T19:04:00Z

El próximo Viernes 23 de Marzo a las 8:30 hs en la Universidad Católica Argentina se realizará una nueva edición del Run en Buenos Aires, el evento Microsoft más importante del año.

Particularmente, voy a estar junto con Rodolfo Finochietti e Ignacio Lopez presentando nuestra charla “Desarrollando para dispositivos móviles con HTML5 y ASP.NET” donde voy a presentar algunas novedades de ASP.NET MVC 4.

Esta es la agenda completa de sesiones para Desarrolladores:

Keynote: Un mundo de dispositivos conectados.
Aplicaciones al alcance de tu mano: Windows Phone – Ariel Schapiro, Miguel Saez.
Desarrollando para dispositivos móviles con HTML5 y ASP.NET – Ignacio Lopez, Rodolfo Finochietti, Mariano Sánchez.
Servicios en la Nube con Windows Azure – Matias Woloski, Johnny Halife.
Desarrollo Estilo Metro en Windows 8 – Martin Salias, Miguel Saez, Adrian Eidelman, Rubén Altman, Damian Martinez Gelabert.

El evento es gratuito, con registro previo: http://bit.ly/registracionrunargdev

Extendiendo ASP.NET MVC 3 – Model Binders

2012-03-13T15:19:00Z

Como vimos en el post anterior Model Binding es el proceso de transformar los datos que se obtienen al momento del Request (como por ejemplo valores de Forms, Query Strings, etc.) en Modelos.

Por cada valor que se quiera obtener para crear un Modelo, se deben seguir mínimamente los siguientes pasos: obtener el valor buscado utilizando los Value Providers, mantener el estado de ese valor para poder utilizarlo en el caso de necesitarlo (por ejemplo para mostrar un error), y aplicar las validaciones necesarias para asegurarnos que el valor obtenido cumple con los requisitos para pertenecer a nuestro Modelo.

En nuestro siguiente ejemplo vamos a ver una implementación de un Model Binder que se utiliza para crear una instancia de la clase Frase, la cual tiene una referencia a la clase Autor. Este Model Binder se encarga de obtener la instancia de Autor correspondiente al código que se envía en el Request y termina generando una instancia de la clase Frase con la referencia al Autor obtenido.

Veamos el código de las clases Frase y Autor:

public class Frase
{
    public Frase()
    {
        Comentarios = new List<Comentario>();
        Votos = new List<Voto>();
    }

    public int FraseId { get; set; }

    [Required(ErrorMessage="Si no vas a decir nada no molestes che!!!")]
    public string Texto { get; set; }

    public List<Voto> Votos { get; set; }

    public List<Comentario> Comentarios { get; set; }

    public int AutorId { get; set; }

    public Autor Autor { get; set; }

    public int CantidadVotos
    {
        get { return CalcularVotos(); }
    }

    private int CalcularVotos()
    {
        var meGusta = Votos.Where(x => x.MeGusta).Count();

        var noMeGusta = Votos.Where(x => !x.MeGusta).Count();

        return meGusta - noMeGusta;
    }
}

public class Autor
{
    public int AutorId { get; set; }

    public string Nombre { get; set; }

    public List<Frase> Frases {get; set;}

    public Autor()
    {
        Frases = new List<Frase>();
    }
}

Nuestro Model Binder se va a encargar de generar una instancia de la clase Frase, con la propiedad Texto y la instancia de Autor completas. Para ello va a obtener del Request, mediante el Value Provider, los valores para la clave “Texto”, y para la clave “Autor”. Con el valor de Autor, obtendremos la instancia correspondiente para asignarla a la Frase. Si se fijan en la definición de la clase Frase, van a ver que el campo “Texto” es un campo requerido el cual posee un mensaje de error especial. Esta Metadata de validación va a ser utilizada por el Model Binder para validar la completitud del valor.
Dicho esto, veamos el código del Model Binder:

public class FraseModelBinder : IModelBinder
{
    public object BindModel(ControllerContext controllerContext,
                            ModelBindingContext bindingContext)
    {

        var frase = new Frase();

        frase.Texto = Get<string>(controllerContext, bindingContext, "Texto");

        var nombreAutor = Get<string>(controllerContext, bindingContext, "Autor");

        var autor = FrasesService.ObtenerAutor(nombreAutor);

        frase.Autor = autor;

        return frase;
    }

    private TModel Get<TModel>(ControllerContext controllerContext,
                                ModelBindingContext bindingContext,
                                string name)
    {
        // Obtengo el Valor del ValueProvider
        ValueProviderResult valueProviderResult = bindingContext.ValueProvider.GetValue(name);

        // Genero el Model State con el valor. Esto me permite devolver el valor para nuevos bindings en caso de que
        // sea invalido, (Ej: Valores string en propiedades int).
        ModelState modelState = new ModelState { Value = valueProviderResult };
        bindingContext.ModelState.Add(name, modelState);

        // Convierto al tipo especifico
        var model = (TModel)valueProviderResult.ConvertTo(typeof(TModel));

        // Obtengo la metadata de la propiedad, necesaria para la validacion
        var metadata = bindingContext.PropertyMetadata[name];
        metadata.Model = model;

        // Usando la Metadada y el valor corro las validaciones
        IEnumerable<ModelValidator> validators = ModelValidatorProviders.Providers.GetValidators(metadata, controllerContext);
        foreach (var validator in validators)
            foreach (var validatorResult in validator.Validate(bindingContext.Model))
                modelState.Errors.Add(validatorResult.Message);

        return model;
    }
}

Como primera observación podemos ver que los Model Binders deben implementar la Interfaz IModelBinder, la cual posee el método BindModel que recibe como parámetros la información de contexto del controller dentro de una instancia de la clase ControllerContext y también la información de contexto del proceso de Binding dentro de una instancia de la clase ModelBindingContext.
Con estos dos parámetros se puede acceder a todo lo necesario para realizar Model Binding: Value Providers, Model State, Metadata de Modelos, etc.
Nuestro Model Binder posee un método privado Get, el cual se encarga de obtener un valor que se corresponda al nombre de una clave.

Este método posee cinco partes interesantes, la primera donde se usa el Value Provider para obtener el valor el cual viene wrapeado en una instancia de la clase ValueProviderResult, la segunda donde se genera el Model State para mantener el valor que se obtuvo para poder ser utilizado según necesidad (por ejemplo si esperamos un entero y recibimos un string, vamos a querer que ese string se mantenga para poder presentarse en la pagina nuevamente en el mismo input donde fue ingresado junto con el mensaje de error correspondiente), la tercera donde se toma el valor obtenido y se transforma al tipo esperado, la cuarta donde se obtiene la Metadata del Modelo para la propiedad que corresponde la clave, y la quinta donde se utiliza la información de validación obtenida en la metadata para realizar las validaciones y en el caso de que no pasen almacenar los errores en el ModelState instanciado para la clave que estamos buscando.

Una vez completada la obtención de valores y construcción del Modelo, el método BindModel devuelve la instancia de Frase con el Texto y el Autor completos.

Con esto, tenemos completo nuestro Custom Model Binder para ahora, como hicimos con el Custom Value Provider, el siguiente paso es “decirle” a MVC que existe un nuevo Model Binder y que tiene que ser considerado para ser utilizado al momento de realizar el Binding para la clase Frase. Esto se realiza dentro del Global.Axasx, como se muestra en el siguiente snippet:

private void RegisterModelBinders()
{
ModelBinders.Binders.Add(typeof(Frase), new FraseModelBinder());
}

Con este último punto, nuestra aplicación esta lista para utilizar nuestro nuevo ModelBinder!

En la próxima semana continuaremos con el siguiente punto de extensibilidad: View Engines.

Nos leemos!!

Extendiendo ASP.NET MVC 3

2012-02-22T18:56:00Z

Buenas!

En esta serie de post vamos a estar revisando con ejemplos los principales puntos de extensibilidad de ASP.NET MVC 3.

La lista a revisar es la siguiente:

•Model:

–Value Providers

–Model Binders

•View:

–View Engines

–Html Helpers

–Razor Helpers

•Controller:

–Action Name Selectors

–Action Methods Selectors

–Action Filters

–Exceptions Filters

–Custom Results

Así que empecemos!!

Value Providers:

Model Binding es el proceso de transformar los datos que se obtienen al momento del Request (como por ejemplo valores de Forms, Query Strings, etc.) en Modelos.

Para esto durante el Model Binding es necesario contar con un mecanismo que nos permita entender de donde provienen los datos para poder acceder a estos y utilizarlos para crear o actualizar objetos del Modelo. Este mecanismo son los Value Providers.

El propósito de un Value Provider es simple, proveer acceso a la información que se puede utilizar para el proceso de Model Binding. MVC posee varios Value Providers que el Default Model Binder utiliza, entre estos FormValueProvider, QueryStringValueProvider y RouteDataValueProvider.

En nuestro ejemplo crearemos un Value Provider que accede a las Cookies para obtener valores.

Para esto, vamos a agregar una nueva clase llamada CookieValueProvider que implementa la interfaz IValueProvider.
Esta interfaz posee dos métodos:
- ContainsPrefix: Se utiliza para determinar si el Value Provider puede obtener los valores solicitados bajo ese prefijo / clave. Si puede, MVC lo va a utilizar para obtener el valor utilizando el método GetValue. Devuelve un boolean.
- GetValue: Obtiene le valor a través de la clave solicitada. Devuelve una instancia de ValueProviderResult la cual es básicamente un Wrapper del valor, que se encarga de resolver algunas cuestiones como conversiones o manejo de cultura.

La siguiente seria nuestra implementación de CookieValueProvider. Al construirse utiliza la colección de HttpCookies para crear un diccionario donde se almacenan los valores de las cookies indexadas por sus claves. Con esta información, el método ContainsPrefix verifica si en la colección existe la clave. Si existe devuelve True y entonces MVC va a utilizar este Value Provider para obtener el valor a través el método GetValue, el cual va a acceder al diccionario de valores de cookies para obtener el valor y devolverlo como una instancia de ValueProviderResult

public class CookieValueProvider : IValueProvider
{
    private Dictionary<string, string> _cookiesKeys =
        new Dictionary<string, string>();

    public CookieValueProvider(HttpCookieCollection cookieCollection)
    {
        foreach (string cookieName in cookieCollection)
        {
            var cookie = cookieCollection.Get(cookieName);

            foreach (var key in cookie.Values.AllKeys)
            {
                if (key != null && !_cookiesKeys.ContainsKey(key))
                    _cookiesKeys.Add(key, cookie.Values.Get(key));
            }
        }
    }

    public bool ContainsPrefix(string prefix)
    {
        var containsPrefix = _cookiesKeys.Keys.Any(x => x == prefix);

        return containsPrefix;

    }

    public ValueProviderResult GetValue(string key)
    {
        var value = _cookiesKeys[key];

        return value != null ?
            new ValueProviderResult(value, value, CultureInfo.CurrentUICulture)
            : null;
    }
}

Con esto, tenemos completo nuestro Custom Value Provider para acceder a las Cookies y obtener valores desde allí. Ahora el siguiente paso es “decirle” a MVC que existe un nuevo Value Provider y que tiene que ser considerado para ser utilizado al momento de obtener valores durante el proceso de Model Binding.

Para esto necesitamos implementar una clase que derive de la clase abstracta ValueProviderFactory e implemente el método GetValueProvider. Esta fábrica se va encargar de devolver nuestro nuevo Value Provider construido basándose en la información de contexto.
La siguiente seria nuestra implementación de la CookieValueProviderFactory, la cual en el método GetValueProvider se encarga de devolver una nueva instancia de CookieValueProvider, pasándole por parámetro de constructor la colección de Cookies que se están utilizando en el Request.

public class CookieValueProviderFactory : ValueProviderFactory
{
    public override IValueProvider GetValueProvider(ControllerContext controllerContext)
    {
        return new CookieValueProvider(controllerContext.HttpContext.Request.Cookies);
    }
}

Una vez creada nuestra fabrica, el ultimo punto es registrarla dentro de la coleción de fábricas de Value Providers que posee MVC. Esto lo podemos hacer dentro del archivo Global.asax, en el método Application_Start, como se ve a continuación:

protected void Application_Start()
{
    //....
    ValueProviderFactories.Factories.Add(new CookieValueProviderFactory());
    //....
}

Con este último punto, nuestra aplicación esta lista para utilizar nuestro nuevo ValueProvider!

En la próxima semana continuaremos con el siguiente punto de extensibilidad: Model Binders.

Nos leemos!!

Extendiendo MVC 3 - Charla MUG

2012-02-17T17:58:00Z

Les acerco el código fuente de la demo de la charla Extendiendo MVC 3 que presentamos en el MUG junto con RodoF.

Gracias a los que vinieron y espero que les sea útil.

Saludos!

Code Camp 2011 - Entity Framework 4.1 - Code First desde las trincheras

2011-10-15T09:44:00Z

Mañana voy a estar presentando la charla Entity Framework 4.1 - Code First desde las trincheras en el CodeCamp 2011 de Buenos Aires.

A partir de el Lunes van a estar disponible en este Blog todos los recursos de la charla.

Nos vemos allá!!!

Update: PPT y Sources acá.

Enamorandose de Entity Framework 4 - CodeCamp 2010

2010-09-04T03:50:00Z

Mañana, con mi colega Leandro Boffi, vamos a estar presentando la charla Enamorandose de Entity Framework 4 donde repasaremos los nuevos features de Entity Framework 4 en el CodeCamp 2010 de Buenos Aires.

A partir de el Lunes va a estar disponible en este Blog todos los recursos que utilizamos para las demos.

Los esperamos!!

Update: Source y PPT

Me at the 'Level Extreme' .NET online magazine

2008-02-14T18:46:01Z

I wrote an article about Workflow Foundation Custom Activities for the .NET online magazine 'Level Extreme'.
I hope you enjoy it!

Thanks to MVP Martín Salías for the opportunity!

Send mails from .NET

2008-01-09T14:04:18Z

.NET offers a simple way to send mails from our applications.
We only need to create a instance of the class MailMessage, that will represent the email, and another instance of the class Smtp that will act like a Smtp Client to send the email.
Both of them are on the System.Net.Mail namespace.
The source code to use is very simple:

 MailMessage mail = new MailMessage(from, to, subject, content);
 SmtpClient client = new SmtpClient();
 client.Send(mail);

And we need to specify the configuration for the Smtp client. You can configure it to use an Exchange server.
That can be done on the App.Config / Web.Config.

Here is the configuration:

<system.net>       
    <mailSettings>
        <smtp deliveryMethod="Network">
            <network
             host="mailHost"
             port="25"
             userName="Domain\Name"
             password="Password"/>
        </smtp>
    </mailSettings>       
</system.net>

Creating a Workflow Foundation Custom Activity with Activity Derivation

2007-11-02T18:09:43Z

Activity derivation is one of the two methods to create Custom Activities. Unlike the composition (the another method), where with several basic activities we can create a new large and complex activity, on this method we focus on creating one single activity, defining their properties and execution model. Let's look at an example of an activity created by this method, wich will be aiming to display a message on the console.

To do that we must create a new project of Workflow Activity Library type. We will name it “WFActivityDerivation”. and add a new class called ActivityDerivationExample.cs, which the following code:

public class ActivityDerivationExample : Activity
{
    string _text;
 
    public string Text
    {
        get { return _text; }
        set { _text = value; }
    }
 
    protected override ActivityExecutionStatus Execute(
    ActivityExecutionContext executionContext)
    {
        Console.WriteLine(Text);
        Console.ReadKey();
        return ActivityExecutionStatus.Closed;
    }
}

The class inherits from System.Workflow.ComponentModel.Activity, which is the base of all activities in WF. Our example activity exposes a property called “Text” whose value can be set from the workflow designer and which will be displayed on the console when the activity run.

The main feature of this class is the Execute method. When we override this method we are assuming full responsability for the behavior of the activity. When the time comes to execute our custom activity, WF runtime will invoke our Execute method and then show our message on the console. After that we need to tell the WF runtime that our activity execution has ended, returning the value Closed of the ActivityExecutionStatus.

At this point we can build our activity and create the assembly for distribution.

Activity Designers:

The Activity Designers are used to control the appearance of the activities at design time. To create a designer we need a new class that inherits from ActivityDesigner and override their virtual methods. The following example shows how to override the method OnPaint, who draws our activity in the designer's workflow:

public class ActivityDerivationDesigner : ActivityDesigner
{
    ActivityDerivationExample _activity;
    protected override void Initialize(Activity activity)
    {
        _activity = activity as ActivityDerivationExample;
        base.Initialize(activity);
    }
 
    protected override void OnPaint(ActivityDesignerPaintEventArgs e)
    {
        e.Graphics.FillRectangle(Brushes.Black, Location.X, Location.Y, Size.Width, Size.Height);
        Rectangle rect = new Rectangle(Location.X, Location.Y, Size.Width, 15);
        Font font = new Font("Lucida Console", 8);
        e.Graphics.DrawString(@"C:\> " + _activity.Text, font, Brushes.White, rect.X, rect.Y + 10);
 
    }
}

The following syntax is used to associate the designer to our activity::

//ActivityDerivationExampe.cs
[Designer(typeof(ActivityDerivationDesigner))]
public class ActivityDerivationExample : Activity
{
    //
} 
 

With this, our activity will looks like the following picture:

Activity Validators:

The Activity Validators run at design and build time, and are used to ensure that the activity has the correct settings to run. To create a validator need a new class that inherits from the class ActivityValidator and overwrite method Validate.
For example the following validator will ensure that our activity has a valid value in the Text property:

public class ActivityDerivationValidator : ActivityValidator
{
    public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
    {
        ValidationErrorCollection errors = base.Validate(manager, obj);
        ActivityDerivationExample activity = obj as ActivityDerivationExample;
        if (activity.Parent != null && String.IsNullOrEmpty(activity.Text))
        {
            errors.Add(ValidationError.GetNotSetValidationError("Text"));
        }
        return errors;
    }
}

All validation errors are added to the ValidationErrorCollection collection and returned to the caller.

The following syntax is used to associate the validator to our activity:

//ActivityDerivationExampe.cs
[ActivityValidator(typeof(ActivityDerivationValidator))]
public class ActivityDerivationExample : Activity
{
    //
}
 

Conclusion:

The Activity Derivation allow us to create new activities that inherits from the base class Activity. You can also inherits from other classes that implement Activity, to use more features. This method gives us the highest level of control and offers us a way to extend WF code itself.

Certificate Access Error in a IIS hosted WCF Service

2007-11-01T19:15:22Z

The problem appears when a WCF Service hosted in an IIS tries to load a certificate from the Windows Certificates Store with the account of the Application Pool where the service runs, and the account’s profile is not previously loaded. When a user logs on interactively, the system automatically loads the user's profile. If a service or an application impersonates a user, the system does not load the user's profile. Therefore, the service or application should load the user's profile with LoadUserProfile.

When this happens the operation throws the following exception:

System.Security.Cryptography.CryptographicException: The system cannot find the file specified.

See http://support.microsoft.com/kb/939761 Microsoft Knowledge Base Article for detailed information.

A workaround to this problem is to load the Application Pool Identity Account´s profile before the service call is executed. Placing the code in the Application_Start() method on the Global.asax of the IIS host will solve the problem (see http://msdn2.microsoft.com/en-us/library/aa374341.aspx for detailed information).

Here is the code:

private ProfileManager.PROFILEINFO profile;
 
protected void Application_Start(object sender, EventArgs e)
{
    bool retVal = false;
    // Need to duplicate the token. LoadUserProfile needs a token with 
    // TOKEN_IMPERSONATE and TOKEN_DUPLICATE.
    const int SecurityImpersonation = 2;
    dupeTokenHandle = DupeToken(WindowsIdentity.GetCurrent().Token, SecurityImpersonation);
 
    if (IntPtr.Zero == dupeTokenHandle)
    {
        throw new Exception("Unable to duplicate token.");
    }
 
    // Load the profile.
    profile = new ProfileManager.PROFILEINFO();
    profile.dwSize = 32;
    //Domain\User
    profile.lpUserName = @"MyDomain\UserName"; 
    retVal = ProfileManager.LoadUserProfile(dupeTokenHandle, ref profile);
 
    if (!retVal)
    {
        throw new Exception("Error loading user profile. " + Marshal.GetLastWin32Error());
    }
}
 
protected void Application_End(object sender, EventArgs e)
{
    ProfileManager.UnloadUserProfile(WindowsIdentity.GetCurrent().Token, profile.hProfile);
    CloseHandle(dupeTokenHandle);
}
 
private IntPtr DupeToken(IntPtr token, int Level)
{
    IntPtr dupeTokenHandle = new IntPtr(0);
    bool retVal = DuplicateToken(token, Level, ref dupeTokenHandle);
    
    if (false == retVal)
    {
        return IntPtr.Zero;
    }
 
    return dupeTokenHandle;
}
 
internal class ProfileManager
{
    [DllImport("Userenv.dll", SetLastError = true, CharSet = System.Runtime.InteropServices.CharSet.Auto)]
    internal static extern bool LoadUserProfile(IntPtr hToken, ref PROFILEINFO lpProfileInfo);
    [DllImport("Userenv.dll", SetLastError = true, CharSet = System.Runtime.InteropServices.CharSet.Auto)]
    internal static extern bool UnloadUserProfile(IntPtr hToken, IntPtr hProfile);
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct PROFILEINFO
    {
        public int dwSize;
        public int dwFlags;
        public String lpUserName;
        public String lpProfilePath;
        public String lpDefaultPath;
        public String lpServerName;
        public String lpPolicyPath;
        public IntPtr hProfile;
    }
}

An alternative workaround consists in creating a Windows Service account that loads at system start-up using the Application Pool Service Identity.

Thanks to JavierA for helping me to find the solution.

The beginning

2007-11-01T19:14:30Z

Hi, my name is Mariano, I'm from Argentina and I´m 25.
I have programmed computers since I was 15 and I really enjoy it.
I'm in the computer business since year 2000 and now I'm working as developer for Lagash Systems S.A. mainly with Microsoft technology.

This is my first blog, so I hope you find it interesting!! (I will try to keep it updated!!)