#region Constantes cálculo
private struct ParConstantes
{
    public int M { get; set; }
    public int N { get; set; }
}

private ParConstantes getPar(int anio)
{
    ParConstantes p = new ParConstantes();
    if (anio < 1583) { throw
            new ArgumentOutOfRangeException("El año deberá ser superior a 1583"); }
    else if (anio < 1700) { p.M = 22; p.N = 2; }
    else if (anio < 1800) { p.M = 23; p.N = 3; }
    else if (anio < 1900) { p.M = 23; p.N = 4; }
    else if (anio < 2100) { p.M = 24; p.N = 5; }
    else if (anio < 2200) { p.M = 24; p.N = 6; }
    else if (anio < 2299) { p.M = 25; p.N = 0; }
    else { throw
        new ArgumentOutOfRangeException("El año deberá ser inferior a 2299"); }
    return p;
}
#endregion

using System;

namespace jnSoftware.Calculos
{

    /// <summary>
    /// Cálculo de Semana Santa
    /// </summary>
    class SemanaSanta
    {
        private int a;
        private int b;
        private int c;
        private int d;
        private int e;
        private DateTime pascuaResurreccion;

        private int anio;

        /// <summary>
        /// Constructor de la clase
        /// </summary>
        /// <param name="anio">Entero que representa el año del que se quiere calcular la 
        /// semana santa.</param>
        /// <exception cref="ArgumentOutOfRangeException">Se produce cuando se intenta calcular
        /// la semana santa de un año no contemplado.</exception>
        public SemanaSanta(int anio)
        {
            try
            {
                this.anio = anio;
                calculaDomingoPascua();
            }
            catch { throw; }
        }

        /// <summary>
        /// Cálculo del domingo de Pascua o domingo de Resurrección.
        /// </summary>
        private void calculaDomingoPascua()
        {
            ParConstantes p = getPar(anio);
            a = anio % 19;
            b = anio % 4;
            c = anio % 7;
            d = (19 * a + p.M) % 30;
            e = (2 * b + 4 * c + 6 * d + p.N) % 7;

            if (d + e < 10)
            {
                pascuaResurreccion = new DateTime(anio, 3, d + e + 22);
            }
            else
            {
                pascuaResurreccion = new DateTime(anio, 4, d + e - 9);
            }

            // Excepciones
            if (pascuaResurreccion == new DateTime(anio, 4, 26))
                pascuaResurreccion = new DateTime(anio, 4, 19);

            if (pascuaResurreccion == new DateTime(anio, 4, 25) && d == 28 && e == 6 && a > 10)
                pascuaResurreccion = new DateTime(anio, 4, 18);
        }

        #region Constantes cálculo
        private struct ParConstantes
        {
            public int M { get; set; }
            public int N { get; set; }
        }

        private ParConstantes getPar(int anio)
        {
            ParConstantes p = new ParConstantes();
            if (anio < 1583) { throw
                    new ArgumentOutOfRangeException("El año deberá ser superior a 1583"); }
            else if (anio < 1700) { p.M = 22; p.N = 2; }
            else if (anio < 1800) { p.M = 23; p.N = 3; }
            else if (anio < 1900) { p.M = 23; p.N = 4; }
            else if (anio < 2100) { p.M = 24; p.N = 5; }
            else if (anio < 2200) { p.M = 24; p.N = 6; }
            else if (anio < 2299) { p.M = 25; p.N = 0; }
            else { throw
                new ArgumentOutOfRangeException("El año deberá ser inferior a 2299"); }
            return p;
        }
        #endregion

        #region Propiedades públicas

        public DateTime MiercolesCeniza
        {
            get { return SabadoSanto.AddDays(7 * -6 - 3 ); }
        }

        public DateTime ViernesDolores
        {
            get { return pascuaResurreccion.AddDays(-9); }
        }

        public DateTime DomingoRamos
        {
            get { return pascuaResurreccion.AddDays(-7); }
        }

        public DateTime JuevesSanto
        {
            get { return pascuaResurreccion.AddDays(-3); }
        }

        public DateTime ViernesSanto
        {
            get { return pascuaResurreccion.AddDays(-2); }
        }

        public DateTime SabadoSanto
        {
            get { return pascuaResurreccion.AddDays(-1); }
        }

        public DateTime DomingoResurreccion
        {
            get { return pascuaResurreccion; }
        }

        #endregion

    }

}

<system.net>
  <mailSettings>
    <smtp from="usuario@dominio.com"> <!--Cuenta válida en el servidor de correo SMTP-->
      <network host="servidorSMTP" password="contraseña" userName="userSMTP" />
    </smtp>
  </mailSettings>
</system.net>

/// <summary>
 /// Envío de un mensaje de correo electrónico
 /// </summary>
 /// <param name="address">Dirección de destino</param>
 /// <param name="subject">Asunto del mensaje</param>
 /// <param name="body">Mensaje</param>
 /// <remarks>
 /// En caso de cambio de la configuración de la cuenta del remitente, 
 /// deberá realizarse en el fichero Web.config
 /// </remarks>
 public void SendMessage(string address, string subject, string body)
 {
     System.Net.Mail.MailMessage message = new System.Net.Mail.MailMessage();
     // Dirección de destino
     message.To.Add(address);
     // Asunto 
     message.Subject = subject;
     // Mensaje 
     message.Body = body;

     System.Net.Mail.SmtpClient smpt = new System.Net.Mail.SmtpClient();
     smpt.Send(message);
 }

/// <summary>
/// Obtiene una lista con las claves de las cuentas de Outlook
/// </summary>
/// <returns></returns>
public string[] getOutlookAccounts()
{
    RegistryKey rkRaiz = Registry.CurrentUser;

    string ramaCuentas =
          "Software\\Microsoft\\Windows NT"
           + "\\CurrentVersion\\Windows Messaging Subsystem"
           + "\\Profiles\\Outlook\\9375CFF0413111d3B88A00104B2A6676";

    List<string> listaCuentas = new List<string>();
    RegistryKey rkCuentas = rkRaiz.OpenSubKey(ramaCuentas);

    // Lectura del valor que contiene las cuentas de Outlook
    object oCuentas = rkCuentas.GetValue("{ED475418-B0D6-11D2-8C3B-00104B2A6676}");
    if (oCuentas != null && oCuentas.GetType().Equals(typeof(byte[])))
    {
        byte[] cuentas = (byte[])oCuentas;
        for (int i = 0; i < cuentas.Length; i += 4)
        {
            // Traspaso de Little Endian a Big Endian
            StringBuilder sb = new StringBuilder();
            sb.Append(((byte)(cuentas.GetValue(i + 3))).ToString("X2").ToLower());
            sb.Append(((byte)(cuentas.GetValue(i + 2))).ToString("X2").ToLower());
            sb.Append(((byte)(cuentas.GetValue(i + 1))).ToString("X2").ToLower());
            sb.Append(((byte)(cuentas.GetValue(i))).ToString("X2").ToLower());

            listaCuentas.Add(sb.ToString());
        }
    }
    return listaCuentas.ToArray();
}

namespace jnSoftware.Outlook.Accounts
{

    /// <summary>
    /// Clase que representa una cuenta de correo de Outlook en el registro
    /// </summary>
    public class MailAccount
    {

        /// <summary>
        /// Obtiene el orden en el que se encuentra la cuenta de correo en la lista de
        /// Outlook
        /// </summary>
        public int OrderList { get; internal set; }

        /// <summary>
        /// Obtiene el nombre de la clave que contiene la información de la cuenta en 
        /// el registro
        /// </summary>
        public string AccountID { get; internal set; }

        /// <summary>
        /// Obtiene un valor que indica si la cuenta es la predeterminada
        /// </summary>
        public bool IsDefaultAccount
        { get { return OrderList == 0; } }

        /// <summary>
        /// Obtiene la cuenta de correo asociada a la cuenta
        /// </summary>
        public string Email { get; internal set; }

        /// <summary>
        /// Obtiene el nombre de la cuenta de correo.
        /// </summary>
        public string AccountName { get; internal set; }

        /// <summary>
        /// Obtiene el valor establecido como firma para nuevos mensajes
        /// </summary>
        public string NewSignature { get; internal set; }

        /// <summary>
        /// Obtiene el valor establecido como firma para los mensajes que 
        /// se responden
        /// </summary>
        public string ReplySignature { get; internal set; }

    }
}

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Win32;

namespace jnSoftware.Outlook.Accounts
{

    /// <summary>
    /// Gestión de cuentas de correo de Outlook
    /// </summary>
    public class MailAccounts
    {

        private Dictionary<string, MailAccount> cuentasOutlook;

        // Las cuentas de correo dependen directamente de HKCU
        private RegistryKey rkRaiz
        { get { return Registry.CurrentUser; } }

        // De la rama siguiente dependen todas las cuentas de correo definidas
        // en Outlook
        private string ramaCuentas =
               "Software\\Microsoft\\Windows NT"
                + "\\CurrentVersion\\Windows Messaging Subsystem"
                + "\\Profiles\\Outlook\\9375CFF0413111d3B88A00104B2A6676";

        /// <summary>
        /// Obtiene las cuentas de correo de Outlook definidas en el registro
        /// </summary>
        /// <returns></returns>
        public List<MailAccount> GetAccounts()
        {
            readInfoAccounts();
            return new List<MailAccount>(cuentasOutlook.Values);
        }

        /// <summary>
        /// Obtiene información de una cuenta de correo determinada
        /// </summary>
        /// <param name="accountID">Identificador de la cuenta de correo. Se corresponde 
        /// con el nombre de la rama del registro</param>
        /// <exception cref="ArgumentOutOfRangeException">Se produce la excepción cuando no 
        /// se encuentra la cuenta especificada en <paramref name="accountID"/></exception>
        public MailAccount GetAccount(string accountID)
        {
            readInfoAccounts();
            try
            {
                return cuentasOutlook[accountID];
            }
            catch (KeyNotFoundException ex)
            {
                throw new ArgumentOutOfRangeException("No existe la cuenta solicitada", ex);
            }
            catch { throw; }
        }

        /// <summary>
        /// Obtiene información de la cuenta establecida por defecto
        /// </summary>
        public MailAccount GetDefaultAccount()
        {
            string[] cuentas = getOutlookIdAccounts();
            return GetAccount(cuentas[0]);
        }

        /// <summary>
        /// Obtiene información de una cuenta de correo en base a su dirección electrónica
        /// </summary>
        /// <param name="email">Cuenta de correo de la que se quiere recuperar la información</param>
        /// <exception cref="ArgumentOutOfRangeException">Se produce cuando  no se encuentra la 
        /// cuenta de correo especificada en <paramref name="email"/>.</exception>
        public MailAccount GetAcountByEmail(string email)
        {
            readInfoAccounts();

            MailAccount retVal = null;
            // Como en la Uni, desarrollamos un algoritmo de búsqueda
            foreach (MailAccount cuenta in cuentasOutlook.Values)
            {
                if (cuenta.Email == email)
                {
                    retVal = cuenta;
                    break;
                }
            }
            if (retVal != null)
            { return retVal; }
            else { throw new ArgumentOutOfRangeException("Cuenta de correo no encontrada"); }
        }

        /// <param name="email">Cuenta de correo de la que se quiere establecer la firma</param>
        /// <param name="newSignature">Nombre de la firma que quiere establecerse en la cuenta de 
        /// correo para mensajes nuevos</param>
        /// <param name="replySignature">Nombre de la firma que quiere establecerse en la cuenta 
        /// de correo para mensajes respondidos</param>
        public void SetSignature(string email, string newSignature, string replySignature)
        {
            MailAccount cuenta = GetAcountByEmail(email);

            // TODO : Queda pendiente una comprobación para que existan las firmas 
            // en la carpeta de firmas.

            RegistryKey rkCuenta = rkRaiz.OpenSubKey(ramaCuentas + "\\" + cuenta.AccountID, true);
            rkCuenta.SetValue("New Signature", GetFirmaCodificada(newSignature));
            rkCuenta.SetValue("Reply-Forward Signature", GetFirmaCodificada(replySignature));
        }

        /// <summary>
        /// Realiza la lectura de las cuentas definidas en el registro
        /// </summary>
        private void readInfoAccounts()
        {
            cuentasOutlook = new Dictionary<string, MailAccount>();
            string[] cuentas = getOutlookIdAccounts();
            for (int i = 0; i < cuentas.Length; i++)
            {
                MailAccount m = getInfoAccount(cuentas[i]);
                m.OrderList = i;
                cuentasOutlook.Add(m.AccountID, m);
            }
        }

        /// <summary>
        /// Recupera la información de una cuenta determinada.
        /// </summary>
        /// <param name="accountID"></param>
        /// <returns></returns>
        private MailAccount getInfoAccount(string accountID)
        {
            MailAccount m = new MailAccount();
            m.AccountID = accountID;

            RegistryKey rkCuentas = rkRaiz.OpenSubKey(ramaCuentas + "\\" + accountID, false);
            m.Email = binaryToString(rkCuentas.GetValue("Email"));
            m.NewSignature = binaryToString(rkCuentas.GetValue("New Signature"));
            m.ReplySignature = binaryToString(rkCuentas.GetValue("Reply-Forward Signature"));
            m.AccountName = binaryToString(rkCuentas.GetValue("Account Name"));

            return m;
        }

        /// <summary>
        /// Obtiene una lista con las claves de las cuentas de Outlook
        /// </summary>
        /// <returns></returns>
        private string[] getOutlookIdAccounts()
        {
            List<string> listaCuentas = new List<string>();
            RegistryKey rkCuentas = rkRaiz.OpenSubKey(ramaCuentas, false);

            // Lectura del valor que contiene las cuentas de Outlook
            object oCuentas = rkCuentas.GetValue("{ED475418-B0D6-11D2-8C3B-00104B2A6676}");
            if (oCuentas != null && oCuentas.GetType().Equals(typeof(byte[])))
            {
                byte[] cuentas = (byte[])oCuentas;
                for (int i = 0; i < cuentas.Length; i += 4)
                {
                    // Traspaso de Little Endian a Big Endian
                    StringBuilder sb = new StringBuilder();
                    sb.Append(((byte)(cuentas.GetValue(i + 3))).ToString("X2").ToLower());
                    sb.Append(((byte)(cuentas.GetValue(i + 2))).ToString("X2").ToLower());
                    sb.Append(((byte)(cuentas.GetValue(i + 1))).ToString("X2").ToLower());
                    sb.Append(((byte)(cuentas.GetValue(i))).ToString("X2").ToLower());

                    listaCuentas.Add(sb.ToString());
                }
            }
            return listaCuentas.ToArray();
        }

        /// <summary>
        /// Decodifica una cadena del registro en una cadena ASCII.
        /// </summary>
        /// <param name="cadena">Cadena del registro. Devuelve string.empty si la
        /// cadena estuviese vacía.</param>
        /// <returns></returns>
        private string binaryToString(object cadena)
        {
            StringBuilder sb = new StringBuilder();
            if (cadena != null)
            {
                if (cadena.GetType().Equals(typeof(byte[])))
                {
                    byte[] entrada = (byte[])cadena;
                    ASCIIEncoding ascii = new ASCIIEncoding();

                    // Bucle para eliminar los bytes vacíos que se colocan en el registro
                    for (int i = 0; i < entrada.Length; i++)
                    {
                        if (entrada[i] != 0)
                        {
                            sb.Append(ascii.GetString(entrada, i, 1));
                        }
                        i++;
                    }
                }
            }
            return sb.ToString();
        }

        /// <summary>
        /// Codifica el nombre de la firma en un array de Bytes
        /// </summary>
        /// <returns>La codificación se hace tal cómo lo hace Outlook</returns>
        private static byte[] GetFirmaCodificada(string nombreFirma)
        {
            // Codificación del nombre de la firma
            ASCIIEncoding ascii = new ASCIIEncoding();
            byte[] firmaSinCeros = ascii.GetBytes(nombreFirma);

            // La firma de Outlook contiene un byte vacío por cada byte del nombre,
            // así que incluyo un List para no complicarme la vida y añadirle los 
            // bytes vacíos.
            List<byte> firmaConCeros = new List<byte>();

            // Se añaden los ceros a la firma
            foreach (byte b in firmaSinCeros)
            {
                firmaConCeros.Add(b);
                firmaConCeros.Add(new byte());
            }

            // No sé la razón, pero la firma le añade dos bytes más
            firmaConCeros.Add(new byte());
            firmaConCeros.Add(new byte());

            return firmaConCeros.ToArray();
        }

    }       // class
}           // namespace

HKEY_CURRENT_USER
  \Software
    \Microsoft
      \Windows NT
        \CurrentVersion
          \Windows Messaging Subsystem
            \Profiles
              \Outlook
                \9375CFF0413111d3B88A00104B2A6676

CambiaFirma.exe MiFirma

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Win32;

namespace CambiaFirma
{

    /// <summary>
    /// Ejecución del programa de cambio de firma
    /// </summary>
    class CambiarFirma
    {

        /// <summary>
        /// Inicio de la aplicación. Comprobación de argumento y gestión 
        /// de la firma
        /// </summary>
        /// <param name="args">Deberá incluir un parámetro: NombreFirma</param>
        static void Main(string[] args)
        {
            try
            {
                // Lectura de parámetros para obtener el nombre de la firma
                if (args.Length != 1)
                    throw new ArgumentException("Debe añadirse el nombre de la firma como parámetro");
                string nombreFirma = args[0];

                // Gestión de firma
                GestionFirma gf = new GestionFirma(nombreFirma);
                gf.EscribeFirma();
            }
            catch (Exception ex)
            {
                MuestraError(ex);
            }
        }

        /// <summary>
        /// Muestra un error por pantalla de consola
        /// </summary>
        /// <param name="ex"></param>
        private static void MuestraError(Exception ex)
        {
            Console.Clear();
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("ERROR EN CREACIÓN DE FIRMA");
            Console.WriteLine();
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(ex.Message);
            Console.ForegroundColor = ConsoleColor.White;

            for (int i = Console.CursorTop; i < Console.WindowHeight - 1; i++)
            {
                Console.WriteLine();
            }
            Console.Write("Pulsa una tecla para continuar ... : ");
            Console.ReadKey(true);
        }
    }

    /// <summary>
    /// Clase que añade una firma a la cuenta por defecto de Outlook
    /// </summary>
    /// <remarks>Provado en Outlook 2003 y Outlook 2007</remarks>
    class GestionFirma
    {
        private string NombreFirma { get; set; }

        /// <summary>
        /// Constructor de la clase.
        /// </summary>
        /// <param name="nombreFirma">
        /// Texto que representa la firma que se insertará en Outlook
        /// </param>
        public GestionFirma(string nombreFirma)
        {
            NombreFirma = nombreFirma;
        }

        /// <summary>
        /// Cambia el registro del sistema de manera que la firma quedará activada
        /// en Outlook
        /// </summary>
        public void EscribeFirma()
        {
            RegistryKey r = GetRamaCuentaPredeterminadaOutlook();

            byte[] firma = GetFirmaCodificada(NombreFirma);

            // Escritura de los valores
            r.SetValue("New Signature", firma);
            r.SetValue("Reply-Forward Signature", firma);
        }

        /// <summary>
        /// Obtiene la rama del registro correspondiente a la cuenta predeterminada 
        /// de Outlook
        /// </summary>
        /// <returns></returns>
        private RegistryKey GetRamaCuentaPredeterminadaOutlook()
        {
            // Lectura de la rama \\HKCU
            RegistryKey rkRaiz = Registry.CurrentUser;

            // Lectura de la rama en al que se almacena el correo
            RegistryKey rkCorreo =
                rkRaiz.OpenSubKey(
                        "Software\\Microsoft\\Windows NT"
                        + "\\CurrentVersion\\Windows Messaging Subsystem"
                        + "\\Profiles\\Outlook\\9375CFF0413111d3B88A00104B2A6676");

            // Se obtiene el valor de la clave que contiene la cuenta predeterminada
            byte[] cuentaDefecto = (byte[])rkCorreo.GetValue(@"{ED475418-B0D6-11D2-8C3B-00104B2A6676}");

            // Se obtiene el valor de la subclave que contiene la cuenta predeterminada
            string claveCuentaDefecto = "000000" + ((byte)(cuentaDefecto.GetValue(0))).ToString("X2").ToLower();

            // Se abre la rama con la cuenta predeterminada con permisos de escritura
            RegistryKey rkCuentaDefecto = rkCorreo.OpenSubKey(claveCuentaDefecto, true);

            return rkCuentaDefecto;
        }

        /// <summary>
        /// Codifica el nombre de la firma en un array de Bytes
        /// </summary>
        /// <returns>La codificación se hace tal cómo lo hace Outlook</returns>
        private static byte[] GetFirmaCodificada(string nombreFirma)
        {
            // Codificación del nombre de la firma
            ASCIIEncoding ascii = new ASCIIEncoding();
            byte[] firmaSinCeros = ascii.GetBytes(nombreFirma);

            // La firma de Outlook contiene un byte vacío por cada byte del nombre,
            // así que incluyo un List para no complicarme la vida y añadirle los 
            // bytes vacíos.
            List<byte> firmaConCeros = new List<byte>();

            // Se añaden los ceros a la firma
            foreach (byte b in firmaSinCeros)
            {
                firmaConCeros.Add(b);
                firmaConCeros.Add(new byte());
            }

            // No sé la razón, pero la firma le añade dos bytes más
            firmaConCeros.Add(new byte());
            firmaConCeros.Add(new byte());

            return firmaConCeros.ToArray();
        }
    }

}

string caracteres = "abcdefghijklmnopqrstuvwxyz";
string numeros = "0123456789";
string simbolos = "%$#@+-=&";

public GeneradorPassword()
{ }

public GeneradorPassword(int longitudCaracteres)
{ }

public GeneradorPassword(int longitudCaracteres,
                         int porcentajeMayusculas,
                         int porcentajeSimbolos,
                         int porcentajeNumeros)
{ }

using System;
using System.Collections.Generic;
using System.Text;

namespace jnSoftware.Utiles
{
    /// <summary>
    /// Clase que permite la generación de una contraseña. 
    /// La contraseña contiene un número de caracteres fijos y permite especificar el porcentaje
    /// de caracteres en mayúsculas y símbolos que se quieren obtener
    /// </summary>
    public class GeneradorPassword
    {

        /// <summary>
        /// Enumeración que permite conocer el tipo de juego de carácteres a emplear
        /// para cada carácter
        /// </summary>
        private enum TipoCaracterEnum { Minuscula, Mayuscula, Simbolo, Numero }

        #region Campos

        private int porcentajeMayusculas;
        private int porcentajeSimbolos;
        private int porcentajeNumeros;
        Random semilla;

        // Caracteres que pueden emplearse en la contraseña
        string caracteres = "abcdefghijklmnopqrstuvwxyz";
        string numeros = "0123456789";
        string simbolos = "%$#@+-=&";

        // Cadena que contiene el password generado
        private StringBuilder password;

        #endregion

        #region Propiedades

        /// <summary>
        /// Obtiene o establece la longitud en carácteres de la contraseña a obtener
        /// </summary>
        public int LongitudPassword { get; set; }

        /// <summary>
        /// Obtiene o establece el porcentaje de carácteres en mayúsculas que 
        /// contendrá la contraseña
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">Se produce al intentar introducir
        /// un valor que no coincida con un porcentaje</exception>
        public int PorcentajeMayusculas
        {
            get { return porcentajeMayusculas; }
            set
            {
                if (value < 0 || value > 100)
                    throw new ArgumentOutOfRangeException("El porcentaje es un número entre 0 y 100");
                porcentajeMayusculas = value;
            }
        }

        /// <summary>
        /// Obtiene o establece el porcentaje de símbolos que contendrá la contraseña
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">Se produce al intentar introducir
        /// un valor que no coincida con un porcentaje</exception>
        public int PorcentajeSimbolos
        {
            get { return porcentajeSimbolos; }
            set
            {
                if (value < 0 || value > 100)
                    throw new ArgumentOutOfRangeException("El porcentaje es un número entre 0 y 100");
                porcentajeSimbolos = value;
            }
        }

        /// <summary>
        /// Obtiene o establece el número de caracteres numéricos que contendrá la contraseña
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">Se produce al intentar introducir
        /// un valor que no coincida con un porcentaje</exception>
        public int PorcentajeNumeros
        {
            get { return porcentajeNumeros; }
            set
            {
                if (value < 0 || value > 100)
                    throw new ArgumentOutOfRangeException("El porcentaje es un número entre 0 y 100");
                porcentajeNumeros = value;
            }
        }

        #endregion

        #region Constructores
        /// <summary>
        /// Constructor. La contraseña tendrá 8 caracteres, incluyendo una letra mayúscula, 
        /// un número y un símbolo
        /// </summary>
        public GeneradorPassword()
            : this(8)
        { }

        /// <summary>
        /// Constructor. La contraseña tendrá un 20% de caracteres en mayúsculas y otro tanto de 
        /// símbolos
        /// </summary>
        /// <param name="longitudCaracteres">Longitud en carácteres de la contraseña a obtener</param>
        /// <exception cref="ArgumentOutOfRangeException">Se produce al intentar introducir
        /// un porcentaje de caracteres especiales mayor de 100</exception>
        public GeneradorPassword(int longitudCaracteres)
            : this(longitudCaracteres, 20, 20, 20)
        { }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="longitudCaracteres">Longitud en carácteres de la contraseña a obtener</param>
        /// <param name="porcentajeMayusculas">Porcentaje a aplicar de caracteres en mayúscula</param>
        /// <param name="porcentajeSimbolos">Porcenta a aplicar de símbolos</param>
        /// <param name="porcentajeNumeros">Porcentaje de caracteres numéricos</param>
        /// <exception cref="ArgumentOutOfRangeException">Se produce al intentar introducir
        /// un porcentaje de caracteres especiales mayor de 100</exception>
        public GeneradorPassword(int longitudCaracteres, int porcentajeMayusculas, int porcentajeSimbolos, int porcentajeNumeros)
        {
            LongitudPassword = longitudCaracteres;
            PorcentajeMayusculas = porcentajeMayusculas;
            PorcentajeSimbolos = porcentajeSimbolos;
            PorcentajeNumeros = porcentajeNumeros;

            if (PorcentajeMayusculas + porcentajeSimbolos + PorcentajeNumeros > 100)
                throw new ArgumentOutOfRangeException(
                "La suma de los porcentajes de caracteres especiales no puede superar el " +
                "100%, es decir, no puede ser superior a la longitud de la contraseña");
            semilla = new Random(DateTime.Now.Millisecond);
        }

        #endregion

        #region Métodos públicos

        /// <summary>
        /// Obtiene el password
        /// </summary>
        /// <returns></returns>
        public string GetNewPassword()
        {
            GeneraPassword();
            return password.ToString();
        }

        /// <summary>
        /// Permite establecer el número de caracteres especiales que se quieren obtener
        /// </summary>
        /// <param name="numeroCaracteresMayuscula">Número de caracteres en mayúscula</param>
        /// <param name="numeroCaracteresNumericos">Número de caracteres numéricos</param>
        /// <param name="numeroCaracteresSimbolos">Número de caracteres de símbolos</param>
        public void SetCaracteresEspeciales(
            int numeroCaracteresMayuscula
            , int numeroCaracteresNumericos
            , int numeroCaracteresSimbolos)
        {
            // Comprobación de errores
            if (numeroCaracteresMayuscula
                    + numeroCaracteresNumericos
                    + numeroCaracteresSimbolos > LongitudPassword)
                throw new ArgumentOutOfRangeException(
                    "El número de caracteres especiales no puede superar la longitud del password");

            PorcentajeMayusculas = numeroCaracteresMayuscula * 100 / LongitudPassword;
            PorcentajeNumeros = numeroCaracteresNumericos * 100 / LongitudPassword;
            PorcentajeSimbolos = numeroCaracteresSimbolos * 100 / LongitudPassword;
        }

        /// <summary>
        /// Constructor. La contraseña tendrá 8 caracteres, incluyendo una letra mayúscula, 
        /// un número y un símbolo
        /// </summary>
        public static string GetPassword()
        {
            // Se crea un método estático para facilitar el uso
            GeneradorPassword gp = new GeneradorPassword();
            return gp.GetNewPassword();
        }

        #endregion

        #region Métodos de cálculo

        /// <summary>
        /// Método que genera el password. Primero crea una cadena de caracteres 
        /// en minúscula y va sustituyendo los caracteres especiales
        /// </summary>
        private void GeneraPassword()
        {
            // Se genera una cadena de caracteres en minúscula con la longitud del 
            // password seleccionado
            password = new StringBuilder(LongitudPassword);
            for (int i = 0; i < LongitudPassword; i++)
            {
                password.Append(GetCaracterAleatorio(TipoCaracterEnum.Minuscula));
            }

            // Se obtiene el número de caracteres especiales (Mayúsculas y caracteres) 
            int numMayusculas = (int)(LongitudPassword * (PorcentajeMayusculas / 100d));
            int numSimbolos = (int)(LongitudPassword * (PorcentajeSimbolos / 100d));
            int numNumeros = (int)(LongitudPassword * (PorcentajeNumeros / 100d));

            // Se obtienen las posiciones en las que irán los caracteres especiales
            int[] caracteresEspeciales =
                    GetPosicionesCaracteresEspeciales(numMayusculas + numSimbolos + numNumeros);
            int posicionInicial = 0;
            int posicionFinal = 0;

            // Se reemplazan las mayúsculas
            posicionFinal += numMayusculas;
            ReemplazaCaracteresEspeciales(caracteresEspeciales,
                 posicionInicial, posicionFinal, TipoCaracterEnum.Mayuscula);

            // Se reemplazan los símbolos
            posicionInicial = posicionFinal;
            posicionFinal += numSimbolos;
            ReemplazaCaracteresEspeciales(caracteresEspeciales,
                 posicionInicial, posicionFinal, TipoCaracterEnum.Simbolo);

            // Se reemplazan los Números
            posicionInicial = posicionFinal;
            posicionFinal += numNumeros;
            ReemplazaCaracteresEspeciales(caracteresEspeciales,
                 posicionInicial, posicionFinal, TipoCaracterEnum.Numero);
        }

        /// <summary>
        /// Reemplaza un caracter especial en la cadena Password
        /// </summary>
        private void ReemplazaCaracteresEspeciales(
                                        int[] posiciones
                                        , int posicionInicial
                                        , int posicionFinal
                                        , TipoCaracterEnum tipoCaracter)
        {
            for (int i = posicionInicial; i < posicionFinal; i++)
            {
                password[posiciones[i]] = GetCaracterAleatorio(tipoCaracter);
            }
        }

        /// <summary>
        /// Obtiene un array con las posiciones en las que deberán colocarse los caracteres
        /// especiales (Mayúsculas o Símbolos). Es importante que no se repitan los números
        /// de posición para poder mantener el porcentaje de dichos carácteres
        /// </summary>
        /// <param name="numeroPosiciones">Valor que representa el número de posiciones
        /// que deberán crearse sin repetir</param>
        private int[] GetPosicionesCaracteresEspeciales(int numeroPosiciones)
        {
            List<int> lista = new List<int>();
            while (lista.Count < numeroPosiciones)
            {
                int posicion = semilla.Next(0, LongitudPassword);
                if (!lista.Contains(posicion))
                {
                    lista.Add(posicion);
                }
            }
            return lista.ToArray();
        }

        /// <summary>
        /// Obtiene un carácter aleatorio en base a la "matriz" del tipo de caracteres
        /// </summary>
        private char GetCaracterAleatorio(TipoCaracterEnum tipoCaracter)
        {
            string juegoCaracteres;
            switch (tipoCaracter)
            {
                case TipoCaracterEnum.Mayuscula:
                    juegoCaracteres = caracteres.ToUpper();
                    break;
                case TipoCaracterEnum.Minuscula:
                    juegoCaracteres = caracteres.ToLower();
                    break;
                case TipoCaracterEnum.Numero:
                    juegoCaracteres = numeros;
                    break;
                default:
                    juegoCaracteres = simbolos;
                    break;
            }

            // índice máximo de la matriz char de caracteres
            int longitudJuegoCaracteres = juegoCaracteres.Length;

            // Obtención de un número aletorio para obtener la posición del carácter
            int numeroAleatorio = semilla.Next(0, longitudJuegoCaracteres);

            // Se devuelve una posición obtenida aleatoriamente
            return juegoCaracteres[numeroAleatorio];
        }

        #endregion

    }
}

using System;
using System.Collections.Generic;

namespace OrdenacionStrings
{
    class Ordenando
    {
        static void Main(string[] args)
        {
            List<Persona> gente = new List<Persona>();
            gente.Add(new Persona("Jaime", "Cebado Sánchez"));
            gente.Add(new Persona("Victoria", "Chacón Gómez"));
            gente.Add(new Persona("Anibal", "Chacón Gómez"));
            gente.Add(new Persona("Andrés", "Cullera Ramón"));
            gente.Add(new Persona("Juan Manuel", "Damián Rodriguez"));

            gente.Sort();

            foreach (Persona p in gente)
            {
                Console.WriteLine(p.Apellidos + ", " + p.Nombre);
            }
            Console.ReadKey();
        }
    }

    public class Persona : IComparable
    {
        public string Nombre { get; set; }
        public string Apellidos { get; set; }

        public Persona(string nombre, string apellidos)
        {
            Nombre = nombre;
            Apellidos = apellidos;
        }

        public int CompareTo(object obj)
        {
            try
            {
                Persona p = (Persona)obj;
                return (this.Apellidos + " " + this.Nombre).CompareTo(p.Apellidos + " " + p.Nombre);
            }
            catch { return 0; }
        }
    }

}

Cebado Sánchez, Jaime
Chacón Gómez, Anibal
Chacón Gómez, Victoria
Cullera Ramón, Andrés
Damián Rodriguez, Juan Manuel

public int CompareTo(object obj)
 {
     try
     {
         Persona p = (Persona)obj;
         if (!this.Apellidos.ToLower().StartsWith("ch"))
         {
             return (this.Apellidos + " " + this.Nombre).CompareTo(p.Apellidos + " " + p.Nombre);
         }
         else
         {
             if (!p.Apellidos.ToLower().StartsWith("ch"))
             {
                 return (string.Compare((p.Apellidos + " " + p.Nombre).ToLower(), "d") * -1);

                 /* la línea anterior intenta simplificar el conjunto de operaciones siguientes.
                  * Sólo se trata de realizar una inversión en la comparación de la ch y la d
                  */ 

                 //if (string.Compare((p.Apellidos + " " + p.Nombre).ToLower(), "d") == 1)
                 //    return -1;
                 //else if (string.Compare((p.Apellidos + " " + p.Nombre).ToLower(), "d") == -1)
                 //    return 1;
                 //else return 0;
             }
             else
             {
                 return (this.Apellidos + " " + this.Nombre).CompareTo(p.Apellidos + " " + p.Nombre);
             }
         }
     }
     catch { return 0; }
 }
    }

Cebado Sánchez, Jaime
Cullera Ramón, Andrés
Chacón Gómez, Anibal
Chacón Gómez, Victoria
Damián Rodriguez, Juan Manuel

using System;
using System.Collections.Generic;

namespace OrdenacionCorrecta
{
    class Program
    {
        static void Main(string[] args)
        {
            List<Persona> gente = new List<Persona>();
            gente.Add(new Persona("Jaime", "Cebado Sánchez"));
            gente.Add(new Persona("Victoria", "Chacón Gómez"));
            gente.Add(new Persona("Anibal", "Chacón Gómez"));
            gente.Add(new Persona("Andrés", "Cullera Ramón"));
            gente.Add(new Persona("Juan Manuel", "Damián Rodriguez"));

            gente.Sort();

            foreach (Persona p in gente)
            {
                Console.WriteLine(p.Apellidos + ", " + p.Nombre);
            }
            Console.ReadKey();
        }
    }

    public class Persona : IComparable
    {
        public string Nombre { get; set; }
        public string Apellidos { get; set; }

        public Persona(string nombre, string apellidos)
        {
            Nombre = nombre;
            Apellidos = apellidos;
        }

        public int CompareTo(object obj)
        {
            try
            {
                Persona p = (Persona)obj;
                if (!this.Apellidos.ToLower().StartsWith("ch"))
                {
                    return (this.Apellidos + " " + this.Nombre).CompareTo(p.Apellidos + " " + p.Nombre);
                }
                else
                {
                    if (!p.Apellidos.ToLower().StartsWith("ch"))
                    {
                        return (string.Compare((p.Apellidos + " " + p.Nombre).ToLower(), "d") * -1);
                    }
                    else
                    {
                        return (this.Apellidos + " " + this.Nombre).CompareTo(p.Apellidos + " " + p.Nombre);
                    }
                }
            }
            catch { return 0; }
        }
    }

}

<?xml version="1.0" encoding="utf-8"?>
<Configuracion>
    <NombreForm1>
        <WindowState>ValorWindowStateForm1</WindowState>
        <Top>ValorTopForm1</Top>
        <Left>ValorTopForm1</Left>
        <Width>ValorTopForm1</Width>
        <Height>ValorTopForm1</Height>
    </NombreForm1>
    <NombreForm2>
        <WindowState>ValorWindowStateForm2</WindowState>
        <Top>ValorTopForm2</Top>
        <Left>ValorTopForm2</Left>
        <Width>ValorTopForm2</Width>
        <Height>ValorTopForm2</Height>
    </NombreForm2>
</Configuracion>

private string ficheroXML = Path.Combine(Application.StartupPath, "ConfForm.xml");

/// <summary>
 /// Almacena la información del formulario actual en fichero XML
 /// </summary>
 private void GuardaConfiguracionForm()
 {
     string nombreForm = this.Name;
     XmlNode nodoPrincipal;

     try
     {
         // Intancia del documento XML que permitirá guardar la configuración
         XmlDocument doc = new XmlDocument();

         // Se comprueba que exista el fichero
         if (!File.Exists(ficheroXML))
         {
             // No existe el fichero. Se añaden los nodos iniciales
             doc.AppendChild(doc.CreateComment("Configuración de formularios - älskare, Sep/09"));

             // Creación del nodo principal
             nodoPrincipal = doc.CreateNode(XmlNodeType.Element, "Configuracion", null);

             // Se añade el nodo principal al documento
             doc.AppendChild(nodoPrincipal);
         }
         else
         {
             // El fichero existe previamente. Se recupera la información
             doc.Load(ficheroXML);

             // Lectura del nodo principal
             nodoPrincipal = doc.SelectSingleNode("Configuracion");
         }

         // Se comprueba si existe un nodo con el nombre del form actual
         XmlNode nodoFormActual = nodoPrincipal.SelectSingleNode(nombreForm);
         if (nodoFormActual == null)
             nodoFormActual =
                   nodoPrincipal.AppendChild(
                     doc.CreateNode(XmlNodeType.Element, nombreForm, null));

         // Almacenamiento de los valores
         NodoValor(doc, nodoFormActual, "WindowState", this.WindowState);
         NodoValor(doc, nodoFormActual, "Top", this.Top);
         NodoValor(doc, nodoFormActual, "Left", this.Left);
         NodoValor(doc, nodoFormActual, "Width", this.Width);
         NodoValor(doc, nodoFormActual, "Height", this.Height);

         // Se guarda el fichero de configuración en disco
         XmlTextWriter tw = new XmlTextWriter(ficheroXML, Encoding.UTF8);
         tw.Indentation = 4;
         tw.IndentChar = " "[0];
         tw.Formatting = Formatting.Indented;

         doc.Save(tw);
         doc = null;

         tw.Flush();
         tw.Close();
     }
     catch { }
 }

 /// <summary>
 /// Crea un nuevo par clave-valor en el nodo actual en caso de que no exista
 /// <returns></returns>
 XmlNode NodoValor(XmlDocument doc, XmlNode nodoPadre, string Clave, Object Valor)
 {
     XmlNode nodoActual = nodoPadre.SelectSingleNode(Clave);
     if (nodoActual == null)
         nodoActual = nodoPadre.AppendChild(doc.CreateNode(XmlNodeType.Element, Clave, null));
     nodoActual.InnerText = Valor.ToString();
     return nodoActual;
 }

/// <summary>
/// Realiza una lectura del fichero de configuración y aplica los cambios al form
/// </summary>
private void LecturaConfiguracionForm()
{
    // No se controlan errores. En caso de existir cualquier error
    // no se modifica nada en el formulario actual
    try
    {
        string nombreForm = this.Name;
        XmlDocument doc = new XmlDocument();
        doc.Load(ficheroXML);

        // Lectura del nodo principal
        XmlNode nodoPrincipal = doc.SelectSingleNode("Configuracion");

        // Lectura del nodo del formulario actual
        XmlNode nodoActual = nodoPrincipal.SelectSingleNode(nombreForm);

        // Lectura del modo de presentación de la ventana
        this.WindowState = (FormWindowState)Enum.Parse(typeof(FormWindowState), GetValor(nodoActual, "WindowState").ToString(), false);

        if (this.WindowState == FormWindowState.Normal)
        {
            this.Top = Convert.ToInt32(GetValor(nodoActual, "Top"));
            this.Left = Convert.ToInt32(GetValor(nodoActual, "Left"));
            this.Width = Convert.ToInt32(GetValor(nodoActual, "Width"));
            this.Height = Convert.ToInt32(GetValor(nodoActual, "Height"));
        }
    }
    catch { }
}

/// <summary>
/// Obtiene el valor de la clave
/// </summary>
private object GetValor(XmlNode nodoPadre, string clave)
{
    XmlNode valor = nodoPadre.SelectSingleNode(clave);
    return valor.LastChild.Value;
}

public FormularioBase()
{
    this.SuspendLayout();
    InitializeComponent();
    this.ResumeLayout();

    this.Load += new EventHandler(FormularioBase_Load);
    this.FormClosing += new FormClosingEventHandler(FormularioBase_FormClosing);
}

void FormularioBase_Load(object sender, EventArgs e)
{
    LecturaConfiguracionForm();
}
void FormularioBase_FormClosing(object sender, FormClosingEventArgs e)
{
    GuardaConfiguracionForm();
}

public partial class Form2 : jnSoftware.Utiles.FormularioBase
    {
        public Form2()
        {
            InitializeComponent();
        }
    }

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<%@ Register Assembly="AjaxControlToolkit" Namespace="AjaxControlToolkit.HTMLEditor"
    TagPrefix="AjaxCT" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>HTML Editor - Pruebas iniciales</title>
    <style type="text/css" media="all">
        * {
            font-family: Arial, Helvetica, sans-serif;
        }
    </style>
</head>
<body>
    <form id="form1" runat="server">
    <asp:ScriptManager ID="sm" runat="server" />
    <div>
        <h1>HTML Editor</h1>
        <AjaxCT:Editor ID="MiEditor" runat="server"  />
    </div>
    </form>
</body>
</html>

using AjaxControlToolkit.HTMLEditor;

namespace jnSoftware.WebControls
{
    public class jnHTMLEditor : Editor
    {

        /// <summary>
        /// Método en el que se colocarán los elementos de la barra superior del control
        /// </summary>
        protected override void FillTopToolbar()
        {
            // Botón de negrita
            this.TopToolbar.Buttons.Add(
                new AjaxControlToolkit.HTMLEditor.ToolbarButton.Bold());
            // Botón de cursiva
            this.TopToolbar.Buttons.Add(
                new AjaxControlToolkit.HTMLEditor.ToolbarButton.Italic());
            // Botón de subrayado
            this.TopToolbar.Buttons.Add(
                new AjaxControlToolkit.HTMLEditor.ToolbarButton.Underline());
        }

        /// <summary>
        /// Método en el que se colocarán los elementos de la barra inferior del control
        /// </summary>
        protected override void FillBottomToolbar()
        {
            // Vista Diseño
            this.BottomToolbar.Buttons.Add(
                new AjaxControlToolkit.HTMLEditor.ToolbarButton.DesignMode());
            // Vista Previa
            this.BottomToolbar.Buttons.Add(
                new AjaxControlToolkit.HTMLEditor.ToolbarButton.PreviewMode());

            // base.FillBottomToolbar();
        }
    }
}

using AjaxControlToolkit.HTMLEditor;

namespace jnSoftware.WebControls
{
    public class jnHTMLEditor : Editor
    {

        /// <summary>
        /// Muestra u oculta la barra de herramientas superior
        /// </summary>
        public bool ShowTopToolBar
        {
            get { return showTopToolBar; }
            set { showTopToolBar = value; }
        }
        private bool showTopToolBar = true ;

        /// <summary>
        /// Muestra u oculta la barra de botones inferior
        /// </summary>
        public bool ShowBottonToolbar
        {
            get { return showBottomToolbar; }
            set { showBottomToolbar = value; }
        }
        private bool showBottomToolbar = true;

        /// <summary>
        /// Método en el que se colocarán los elementos de la barra superior del control
        /// </summary>
        protected override void FillTopToolbar()
        {
            if (showTopToolBar)
            {
                // Botón de negrita
                this.TopToolbar.Buttons.Add(
                    new AjaxControlToolkit.HTMLEditor.ToolbarButton.Bold());
                // Botón de cursiva
                this.TopToolbar.Buttons.Add(
                    new AjaxControlToolkit.HTMLEditor.ToolbarButton.Italic());
                // Botón de subrayado
                this.TopToolbar.Buttons.Add(
                    new AjaxControlToolkit.HTMLEditor.ToolbarButton.Underline());
            }
        }

        /// <summary>
        /// Método en el que se colocarán los elementos de la barra inferior del control
        /// </summary>
        protected override void FillBottomToolbar()
        {
            if (ShowBottonToolbar)
            {
                // Vista Diseño
                this.BottomToolbar.Buttons.Add(
                    new AjaxControlToolkit.HTMLEditor.ToolbarButton.DesignMode());
                // Vista Previa
                this.BottomToolbar.Buttons.Add(
                    new AjaxControlToolkit.HTMLEditor.ToolbarButton.PreviewMode());
            }
        }
    }
}

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<%@ Register Namespace="jnSoftware.WebControls" TagPrefix="jnControles" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>HTML Editor - Pruebas iniciales</title>
    <style type="text/css" media="all">
        * {
            font-family: Arial, Helvetica, sans-serif;
        }
    </style>
</head>
<body>
    <form id="form1" runat="server">
    <asp:ScriptManager ID="sm" runat="server" />
    <div>
        <h1>HTML Editor</h1>
        <jnControles:jnHTMLEditor ID="MiEditor" runat="server"  />
    </div>
    </form>
</body>
</html>

using System;
using System.Collections.Generic;

namespace ValidacionVies
{
    class Pais : IComparable
    {
        public string CodigoPais { get; set; }
        public string NombrePais { get; set; }

        public Pais(string codigoPais, string pais)
        {
            this.CodigoPais = codigoPais;
            this.NombrePais  = pais;
        }

        // Se implementa la interfaz IComparable para poder ordenar por el país 
        public int CompareTo(object obj)
        {
            return this.NombrePais.CompareTo(((Pais)obj).NombrePais);
        }
    }

    class Paises : List<Pais>
    {
        public Paises()
        {
            this.Add(new Pais("AT", "Austria"));
            this.Add(new Pais("BE", "Bélgica"));
            this.Add(new Pais("BG", "Bulgaria"));
            this.Add(new Pais("CY", "Chipre"));
            this.Add(new Pais("CZ", "Chequia"));
            this.Add(new Pais("DE", "Alemania"));
            this.Add(new Pais("DK", "Dinamarca"));
            this.Add(new Pais("EE", "Estonia"));
            this.Add(new Pais("EL", "Grecia"));
            this.Add(new Pais("ES", "España"));
            this.Add(new Pais("FI", "Finlandia"));
            this.Add(new Pais("FR", "Francia"));
            this.Add(new Pais("GB", "Reino Unido"));
            this.Add(new Pais("HU", "Hungría"));
            this.Add(new Pais("IE", "Irlanda"));
            this.Add(new Pais("IT", "Italia"));
            this.Add(new Pais("LT", "Lituania"));
            this.Add(new Pais("LU", "Luxemburgo"));
            this.Add(new Pais("LV", "Letonia"));
            this.Add(new Pais("MT", "Malta"));
            this.Add(new Pais("NL", "Países Bajos"));
            this.Add(new Pais("PL", "Polonia"));
            this.Add(new Pais("PT", "Portugal"));
            this.Add(new Pais("RO", "Rumania"));
            this.Add(new Pais("SE", "Suecia"));
            this.Add(new Pais("SI", "Eslovenia"));
            this.Add(new Pais("SK", "Eslovaquia"));

            this.Sort();
        }
    }

}

- <element name="checkVatResponse">
- <complexType>
- <sequence>
  <element name="countryCode" type="xsd:string" />
  <element name="vatNumber" type="xsd:string" />
  <element name="requestDate" type="xsd:date" />
  <element name="valid" type="xsd:boolean" />
  <element name="name" type="xsd:string" />
  <element name="address" type="xsd:string" />
  </sequence>
  </complexType>
  </element>

using System;
using System.Windows.Forms;
using ValidacionVies.eu.europa.ec;

namespace ValidacionVies
{
    public partial class Form1 : Form
    {
        checkVatService cvs;

        public Form1()
        {
            InitializeComponent();

            // Asignación de eventos
            this.Load += new EventHandler(Form1_Load);
            this.cmdValida.Click += new EventHandler(cmdValida_Click);
        }

        void Form1_Load(object sender, EventArgs e)
        {
            lblProgreso.Text = string.Empty;

            // Carga de paises y asignación al combo
            Paises paises = new Paises();
            cboPaises.DataSource = paises;
            cboPaises.DisplayMember = "NombrePais";
            cboPaises.ValueMember = "CodigoPais";
            cboPaises.AutoCompleteMode = AutoCompleteMode.SuggestAppend;
            cboPaises.AutoCompleteSource = AutoCompleteSource.ListItems;

            // Asignación del evento IndexChanged para el combo.
            cboPaises.SelectedIndexChanged += new EventHandler(cboPaises_SelectedIndexChanged);
            txtCountryCode.Text = cboPaises.SelectedValue.ToString();
        }

        void cboPaises_SelectedIndexChanged(object sender, EventArgs e)
        {
            ComboBox cbo = (ComboBox)sender;
            txtCountryCode.Text = cbo.SelectedValue.ToString();
        }

        void cmdValida_Click(object sender, EventArgs e)
        {
            lblProgreso.Text = "Consultando";

            // Llamada asíncrona al WebService
            cvs = new checkVatService();
            cvs.checkVatCompleted += new checkVatCompletedEventHandler(cvs_checkVatCompleted);
            cvs.checkVatAsync(txtCountryCode.Text, txtVatNumber.Text);
        }

        void cvs_checkVatCompleted(object sender, checkVatCompletedEventArgs e)
        {
            // Respuesta de la llamada asíncrona al WebService
            try
            {
                if (!e.Cancelled)
                {
                    lblProgreso.Text = string.Empty;
                    rstAddress.Text = e.address;
                    rstCountryCode.Text = e.countryCode;
                    rstName.Text = e.name;
                    rstResult.Text = e.Result.ToShortDateString();
                    rstCorrecto.Text = e.valid ? "Sí" : "No";
                }
                else
                {
                    lblProgreso.Text = string.Empty;
                    rstAddress.Text = string.Empty;
                    rstCountryCode.Text = string.Empty;
                    rstName.Text = string.Empty;
                    rstResult.Text = string.Empty;
                    rstCorrecto.Text = string.Empty;
                }
            }
            catch (System.Reflection.TargetInvocationException ex)
            {
                lblProgreso.Text = ex.Message;
            }
            catch (Exception ex)
            {
                lblProgreso.Text = "Se ha producido un error " + ex.GetType().ToString();

            }
        }
    }
}