Tag Archive for .net

Session and Talk: Mono development for .Net developers

A few months ago in DDD Melbourne 2011 and DDD Adelaide 2011 I had the pleasure to share with a lot of developers a little more about Mono and cross development for a Windows .Net developer.

Usually I upload my presentation and share some links with the people in the following week, but well, I’ve been kind of busy!

If you want to know more about Mono development take a look at the official Mono Project page, probably subscribe to the Monologue blog aggregator, download and play a little with Monodevelop, even start some hacking with a mono tutorial or be risky and read a book about programming iPhone with Mono and C# using the great tools from Xamarin.

Of course, you are always welcome to contribute with the Mono community!

My slides are available now for download :)

WiX and setup dialogs like Microsoft Expression Suite

I’ve been playing a few days with WiX, a very handy toolset to create Microsoft Installer Packages from scratch, very handy and easy to use for complex scenarios (and overkill for simple installers). WiX is an open source project supported by Microsoft and available in its Codeplex site.

You can do a lot of things with Wix, check conditions in the machine, create your own dialogs with a declarative xml, and (as many other Microsoft projects) extend the installer with your own actions or extensions or whatever you want to create.

Googling the internet about some scenarios around Wix, I found a common question:

how could I extend the Wix dialogs so instead of using a Windows form set of dialogs use WPF screens or pages so my installer will look like the awesome and beauty Microsoft Expression Suite installer”

Yeah, if you install Microsoft Expression Suite you will find a very beautiful installation UI made in WPF:

Microsoft-Expression-Studio-3-Setup-3

Yeah, people in the forums and mailing list scratch their head about this scenario, if you think about it’s kind of complex because:

  • You need to bootstrap your installation so .Net is installed
  • You need to bootstrap your installation so an specific .Net version is installed
  • If everything is installed, then, you launch your installation dialogs.

In the installation process if you don’t have any of those dependencies then you need to install them or offer the user the option to download and install, not so simple if you see the installer as a single unit of work.

Well, I didn’t want to keep the secret, so I started a new Expression Suite installation and I found the answer.

To install Expression Suite you launch an exe file, Setup.exe, if you look carefully this is an unmanaged application, let’s say this is kind of bootstrapper for the installation process. It will detect if you have the correct .Net framework installed and if everything looks good would launch Setup\XSetup.exe, a managed WPF application (maybe you can take a look at the assembly Setup\XSetupUI.dll), this is the real installer software. If you peek inside this managed application using a tool like ILSpy or RedGate’s Reflector you will find that it uses .Net interop to call the Windows Installer API and launching the installation of correct packages in the process.

You can take a look at the Setup folder and found the real MSI packages for Expression Suite, they are normal and boring MSI installers:

CropperCapture[27]

Mystery resolved, there is no easy way to create an immersive WPF experience for your installers using WiX, at least you sacrifice some time to create your own custom installation boot strappers, something that someday I will put my eye on.

.NET y Configuraciones – Parte 8

La última vez que conversamos acerca de configuraciones sacamos a relucir lo sencillo que es agregar soporte para funciones de validación callback, y antes de eso comentábamos lo sencillo que era agregar soporte para validación de forma declarativa usando los atributos de validación incluídos en la Configuration Framework de la .Net Framework.

Hoy seguiremos caminando en el soporte de validación customizada de secciones y elementos de validación, pero esta vez creando nuestros propios atributos de validación customizados.

Atributos de Validación

Un atributo de validación nos permite validar los elementos o secciones de nuestra configuración de .Net, simplemente tenemos que adornar ese elemento con el atributo en cuestión. La .Net framework nos incluye algunos atributos ya dentro de la caja, pero podemos agregar los nuestros propios de forma sencilla.

Realmente un atributo de validación costa de dos clases: La clase que marca el atributo (un atributo marcador) y la clase que ejecuta la acción de validar (el validador). Como podremos notar en este lado de la framework se utilizan los atributos de una manera muy particular (y que en lo personal me gusta) de mezclar el atributo como marcador pero no como ejecutor.

Usemos un simple ejemplo, imaginemos que necesitamos validar la entrada de correos electrónicos, como todos sabemos, podemos seguir un par de reglas expuestas en una serie de RFC’s acerca de direcciones de email. Bueno, comencemos por la clase que hace realmente la validación, esta debe heredar de la clase ConfigurationValidatorBase y luego el override de los métodos CanValidate (que nos dice si podemos o no validar el tipo en cuestión) y Validate (quien realmente realiza la validación).

using System;
using System.Configuration;
using System.Text.RegularExpressions;

namespace Cprieto.Samples {
    public class EmailValidator : ConfigurationValidatorBase {
        private const string Word = "[^x00-x1F^(^)^<^>^@^,^;^:^\^"^.^[^]^s]";
        private const string IpEntry = "[[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}]";
        private static readonly string Domain = string.Format("({0}+(.{0}+)*", Word);

        private static readonly Regex EmailRegex =
            new Regex(string.Format("^{0}+(.+)*@{1}|{2})$", Word, Domain, IpEntry), RegexOptions.Compiled);

        public override bool CanValidate(Type type) {
            return type == typeof (string);
        }

        public override void Validate(object value) {
            var item = (string) value;
            if (!string.IsNullOrEmpty(item) && !EmailRegex.IsMatch(item))
                throw new ArgumentException("value is not a valid email");
        }
    }
}

Bien, ahora simplemente creamos el atributo marcador, este debe heredar de ConfigurationValidatorAttribute y la parte importante de este es el override de la propiedad ValidatorInstance que retorna una nueva instancia de nuestra clase validadora.

using System.Configuration;

namespace Cprieto.Samples {
    public class EmailValidatorAttribute : ConfigurationValidatorAttribute {
        public override ConfigurationValidatorBase ValidatorInstance {
            get { return new EmailValidator(); }
        }
    }
}

Ahora simplemente lo aplicamos a nuestra sección de configuración:

using System.Configuration;

namespace Cprieto.Samples {
    public class SampleConfigurationSection : ConfigurationSection {
        [CallbackValidator(Type = typeof(PortValidator),
            CallbackMethodName = "Validate")]
        [ConfigurationProperty("port", DefaultValue = 80)]
        public int Port {
            get { return (int) this["port"]; }
        }

        [ConfigurationProperty("host", IsRequired = true)]
        public string Host {
            get { return (string) this["host"]; }
        }

        [EmailValidator]
        [ConfigurationProperty("email")]
        public string Email {
            get { return (string) this["email"]; }
        }
    }
}

Y claro, nunca cae de más un pequeño archivo de validación que debe marcar como inválido

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="sample"
             type="Cprieto.Samples.SampleConfigurationSection, Cprieto.Samples.ValidationCallback"/>
  </configSections>
  <sample port="80" host="localhost" email="invalid@@email" />
</configuration>

Bueno, y ahora me queda pensar que escribo para el siguiente post de la serie :) Hasta la próxima!

.NET y Configuraciones – Parte 7

Bueno, luego de un largo tiempo de ausencia creo que es hora de continuar con la serie acerca de configuraciones en la .NET Framework. La última vez que conversamos mencionamos la capacidad que tenía una sección de configuración de validar los elementos de configuración, esta capacidad es netamente declarativa a partir de atributos que indican el tipo de validación que debe llevarse a cabo. Como ustedes podrán imaginarse existirán situaciones donde es necesario realizar validaciones afuera de las que ya nos trae la configuration framework.

Existen dos formas de especificar o crear nuestras propias rutinas de validación de la configuración: mediante validation callback y utilizando custom validation attributes. Veremos ambas en esta serie y comenzaremos con la primera: validation callbacks

Validation Callbacks

Imaginemos el siguiente caso hipotético, nuestra sección de validación requiere que se ingrese el nombre o host de la aplicación y el puerto para ese host, la sección en cuestión se vería algo así:

using System.Configuration;

namespace Cprieto.Samples {
    public class SampleConfigurationSection : ConfigurationSection {
        [ConfigurationProperty("port", DefaultValue = 80)]
        public int Port {
            get { return (int) this["port"]; }
        }

        [ConfigurationProperty("host", IsRequired = true)]
        public string Host {
            get { return (string) this["host"]; }
        }
    }
}

Bien, ahora imaginemos que por alguna razón especial el puerto no debe ser ni el 110 ni el 23 (o podría ser cualquier otra regla que a uno se le ocurra). Una forma sencilla de realizar esta validación es usando un método callback, la idea es sencilla, cuando la framework obtenga el valor ejecutará el método o callback de validación pasando ese valor (o el por defecto) como parámetro, dentro del método (o callback en este caso) si no se cumple el requerimiento o validación, se arroja una ArgumentException. Los requerimientos del callback method son sencillos: Debe ser público, estático, ser de tipo void (o una Sub en Visual Basic) y tener un parámetro tipo Object (que recibe el valor a validar). Nuestra simple callback de ejemplo sería algo así:

using System;

namespace Cprieto.Samples {
    public class PortValidator {
        public static void Validate(object value) {
            var num = Convert.ToInt32(value);
            if (num == 110 || num == 23)
                throw new ArgumentException("port must not be 110 or 23");
        }
    }
}

Ahora simplemente le decimos declarativamente a la sección de configuración que use ese callback basta con adornar el elemento con el atributo CallbackValidatorAttribute

using System.Configuration;

namespace Cprieto.Samples {
    public class SampleConfigurationSection : ConfigurationSection {
        [CallbackValidator(Type = typeof(PortValidator), CallbackMethodName = "Validate")]
        [ConfigurationProperty("port", DefaultValue = 80)]
        public int Port {
            get { return (int) this["port"]; }
        }

        [ConfigurationProperty("host", IsRequired = true)]
        public string Host {
            get { return (string) this["host"]; }
        }
    }
}

Es importante que recordemos pasar el tipo del validador (o sea, la clase que lo contiene) y el nombre de la función de callback

Para probar nuestro validador basta con usar el siguiente app.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="sample"
             type="Cprieto.Samples.SampleConfigurationSection, Cprieto.Samples.ValidationCallback"/>
  </configSections>
  <sample port="110" host="localhost" />
</configuration>

Bien, como dijo Porky… los dejo hasta la siguiente entrega donde continuaremos hablando de validadores en las configuraciones de la .Net Framework, Saludos miles a todos :)

Lanzamiento de la Comunidad y Visual Studio 2010

Como ustedes habrán notado la comunidad ha estado en un estado de "pausa" por los últimos meses. Para aprovechar el momentum hemos estado organizando un evento de lanzamiento para Visual Studio 2010 a nivel comunitario. Los dejo con la información :)

Lugar: Oficinas de Microsoft, Edificio Torre Citibank (Intercontinental) [3a Avenida 13-78 Zona 10, Of 1101, Guatemala]

Fechas: Miércoles 23, Jueves 24, Viernes 25 de Julio

Horas: de 6pm a 9pm

Expositores y temas

Silverlight/WPF 4.0 Development

Expositor: Carlos Lone, Microsoft MVP Client Application Development, http://weblogs.asp.net/carloslone/

Fecha: Miércoles 23 de Junio

La nueva era de websites en el internet cada vez más demandan la inclusión de una mejor experiencia de usuario (UX) en donde la interactividad, contenido multimedia y uso del sitio sea más sencillo y amigable para los usuarios.

Se ha dicho de que las versiones anteriores de Silverlight estaban muy orientadas a relizar animaciones y a presentar imagenes  y videos con mejor definición. Sin embargo desde la versión 3.0 y ahora en la versión 4.0 la capacidad de poder utilizar esta herramienta para hacer aplicaciones de linea de negocio es cada vez más sencillo.

Acompañanos a descubrir todas las novedades de Silverlight y WPF en VS2010

- Demistificando Silverlight y WPF 4.0

- Novedades

- Construcción de aplicaciones de linea de negocio.

- Construiremos una aplicación 0 a 100.

Sharepoint 2010 Development

Expositor: Manolo Herrera, Microsoft MVP Sharepoint, http://jmhogua.blogspot.com/

Fecha: Jueves 24 de Junio

El desarrollo en SharePoint nunca antes ha sido tan fácil y práctico

- Desarrollando en Web Part Visual para SharePoint en 15 minutos

- Depurando e instalando tu código en SharePoint desde Visual Studio con presionar una sola tecla.

- Descubriendo el nuevo Developer Dashboard de SharePoint

- Conociendo el Client Object Model de SharePoint desde un aplicación Windows.

- Creando una Sandbox Solution para que nos sirve y ayuda.

Web development con ASP.NET 4.0

Expositor: Cristian Prieto, Microsoft MVP ASP.NET, http://www.cprieto.com

Fecha: Viernes 25 de Junio

ASP.NET ha evolucionado muchísimo en los últimos años con la adición de ASP.NET MVC y Dynamic Data, además de las mejoras continuas a la plataforma de WebForms y ASP.NET AJAX. Hablaremos de como aumentar la productividad y al mismo tiempo construir aplicaciones web que manejen de una manera transparente CSS, controles finos sobre el renderizado y markup al mismo tiempo que podemos mejorar SEO y muchas otras características nuevas en ASP.NET 4.0

 

El cupo es limitado, así que sugiero que corran al link de registro y aparten su lugar http://bit.ly/launchgt

¡Espero verlos en el lanzamiento!

NOTA: Recuerden imprimir y llevar al evento el ticket de inscripción que se genera en el momento del registro

Saludos,