public static string EstadoProyecto2String(EstadoProyecto e)
  {
    switch (e)
    {
      case EstadoProyecto.PendienteDeAceptacion:
        return "Pendiente de aceptación";
      case EstadoProyecto.EnRealizacion:
        return "En realización";
      case EstadoProyecto.Finalizado:
        return "Finalizado";
      default:
        throw 
          new ArgumentOutOfRangeException("Error: " + e);
    }
  }

1. Declaración de la enumeración

  using System.ComponentModel;

  public enum EstadoProyecto
  {
    [Description("Pendiente de aceptación")] PendienteDeAceptacion,
    [Description("En realización")]          EnRealizacion,
    [Description("Finalizado")]              Finalizado,
    [Description("Facturado y cerrado")]     FacturadoYCerrado
  }

2. Implementación del método de extensión

using System;
using System.ComponentModel;
using System.Reflection;

public static class Utils
{
  public static string GetDescription(this Enum e)
  {
    FieldInfo field = e.GetType().GetField(e.ToString());
    if (field != null)
    {
      object[] attribs = 
        field.GetCustomAttributes(typeof(DescriptionAttribute), false);

      if (attribs.Length > 0)
        return (attribs[0] as DescriptionAttribute).Description;
    }
    return e.ToString();
  }
}

Imports System.ComponentModel
Imports System.Reflection
Imports System.Runtime.CompilerServices

Module Module1
    Public Enum EstadoProyecto
        <Description("Pendiente de aceptación")> PendienteDeAceptacion
        <Description("En realización")> EnRealizacion
        <Description("Finalizado")> Finalizado
        <Description("Facturado y cerrado")> FacturadoYCerrado
    End Enum

    <Extension()> _
    Public Function GetDescription(ByVal e As System.Enum) As String
        Dim field As FieldInfo = e.GetType().GetField(e.ToString())
        If Not (field Is Nothing) Then
            Dim attribs() As Object = _
                field.GetCustomAttributes(GetType(DescriptionAttribute), False)
            If attribs.Length > 0 Then
                Return CType(attribs(0), DescriptionAttribute).Description
            End If
        End If
        Return e.ToString()
    End Function
End Module

 List<string> ls = new List<string>();
 ls.Add("Uno");
 ls.Add("Dos");
 ls.Add("Tres");

 List<string> ls = 
     new List<string>() { "Uno", "Dos", "Tres" };

 newobj   instance void class 
          [mscorlib]System.Collections.Generic.List`1<string>::.ctor()
 stloc.s  '<>g__initLocal0'
 ldloc.s  '<>g__initLocal0'
 ldstr    "Uno"
 callvirt instance void class 
          [mscorlib]System.Collections.Generic.List`1<string>::Add(!0)
 nop
 ldloc.s  '<>g__initLocal0'
 ldstr    "Dos"
 callvirt instance void class 
          [mscorlib]System.Collections.Generic.List`1<string>::Add(!0)
 nop
 ldloc.s  '<>g__initLocal0'
 ldstr    "Tres"
 callvirt instance void class 
          [mscorlib]System.Collections.Generic.List`1<string>::Add(!0)
 nop

 List<Persona> lp = new List<Persona>
 {
   new Persona { Nombre="Juan", Edad=34 },
   new Persona { Nombre="Luis", Edad=53 },
   new Persona { Nombre="José", Edad=23 }
 };

 var nums = new SortedList
 {
   { 34, "Treinta y cuatro" },
   { 12, "Doce" },
   { 3, "Tres" }
 };
 foreach (var e in nums)
   Console.WriteLine(e.Key + " " + e.Value);

 public partial class Variable
 {
   partial void Log(string msg);
   private int i = 0;

   public void Inc()
   {
      i++;
      Log("Incremento. I: " + i);
   }

   public void Dec()
   {
      Log("Decremento. I: " + (--i));
   }

   public int Value
   {
     get { return i; }
   }
 }

 Variable v = new Variable();
 v.Inc();
 v.Inc();
 v.Dec();
 Console.WriteLine(v.Value);

• Si existe otra porción de la misma clase (otra partial class Variable) donde se implemente el método, se ejecutará éste. El valor mostrado por consola, salvo que desde esta implementación se modificara el valor del campo privado, sería "1".
  
  
• Si no existe una implementación del método Log() en la clase, el compilador eliminará todas las llamadas al mismo. Pero si observáis, esto incluye el decremento del valor interno, que estaba en el interior de la llamada como un autodecremento:
  

  Log("Decremento. I: " + (--i));

  Por tanto, en este caso, el compilador eliminará tanto la llamada a Log() como la operación que se realiza en el interior. Obviamente, el resultado de ejecución de la prueba anterior sería "2".
  
  Lo mismo ocurriría si el resultado a mostrar fuera el valor de retorno de una llamada a otra función: esta no se ejecutaría, lo cual puede ser grave si en ella se realiza una operación importante, como por ejemplo:
  

  public function InicializaValores()
  {
     Log("Elementos reestablecidos: " + reseteaElementos() );
  }

   
  

 // C#
 public partial class Ejemplo
 {
      
   // El método parcial se declara
   // sin implementación...
   partial void Log(string msg);

   public void RealizarAlgo()
   {
     hacerAlgoComplejo();
     Log("¡Ojo!"); // Usamos el método
                   // parcial declarado antes
   }
   
   [...] // Otros métodos y propiedades

 }

 ' VB.NET
 Partial Public Class Ejemplo

   ' El método parcial se declara, sin
   ' implementar nada en el cuerpo
   Partial Private Sub Log(ByVal msg As String)
   End Sub

  Public Sub RealizarAlgo()
    HacerAlgoComplejo()
    Log("¡Ojo!") ' Usamos el método parcial
  End Sub

  [...] ' Otros métodos y propiedades
 End Class

 // C#
 public partial class Variable
 {
   partial void Log(string msg)
   {
     Console.WriteLine(msg);
   }
 }

 ' VB.Net
 Partial Public Class Variable
   Private Sub Log(ByVal msg As String)
     Console.WriteLine(msg)
   End Sub
 End Class

• Los métodos parciales se implementan en la propia clase, mientras que los eventos pueden ser consumidos también desde cualquier otra
• El enlace, o la suscripción, a eventos es dinámica, se realiza en tiempo de ejecución, es necesario incluir código para ello; los métodos parciales, sin embargo, se vinculan en tiempo de compilación
• Los eventos permiten múltiples suscripciones, es decir, asociarles más de un código cliente
• Los eventos pueden presentar cualquier visibilidad (pública, privada...), mientras que los métodos parciales son obligatoriamente privados.

• Deben ser siempre privados (ya lo había comentado antes)
• No deben devolver valores (en VB.Net serían SUB, en C# serían de tipo void)
• Pueden ser estáticos (shared en VB)
• Pueden usar parámetros, acceder a los miembros privados de la clase... en definitiva, actuar como un método más de la misma

  ' VB.NET 
  Public Partial Class Persona
    ...
  End Class

  // C#
  public partial class Persona
  {
    ...
  }

  // *** Archivo PersonaParcial.Propiedades.cs ***
  // Aquí definiremos todas las propiedades
  partial class PersonaParcial
  {
    public string Nombre { get; set; }
    public string Apellidos { get; set; }
  }
 
  // *** Archivo PersonaParcial.IEnumerable.cs ***
  // Aquí implementaremos el interfaz IEnumerable
  partial class PersonaParcial: IEnumerable
  {
    public IEnumerator GetEnumerator()
    {
      throw new NotImplementedException();
    }
  }

  // *** Archivo PersonaParcial.Metodos.cs ***
  // Aquí implementaremos los métodos que necesitemos
  partial class PersonaParcial
  {
    public override string ToString()
    {
      return Nombre + " " + Apellidos;
    }
  }

• Los atributos de la clase resultante serán la combinación de los atributos definidos en cada una de las partes.
• El tipo base de los distintos fragmentos debe ser el mismo, o aparecer sólo en una de las declaraciones parciales.
• Si se trata de una clase genérica, los parámetros deben coincidir en todas las partes.
• Los interfaces que implemente la clase resultante será la unión de todos los implementados por las distintas secciones.
• De la misma forma, los miembros (métodos, propiedades, campos...) de la clase final será la unión de todos los definidos en las distintas partes.

• por ejemplo, separar la interfaz (los miembros visibles desde el exterior de la clase) y por otra los miembros privados a la misma
• o bien separar las porciones que implementan interfaces, o sobreescriben miembros de clases antecesoras de los pertenecientes a la propia clase
• o separar temas concernientes a distintos dominios o aspectos

union Ejemplo
{
  char caracter; // suponiendo char de 8 bits
  byte octeto;   // un byte ocupa 8 bits
};

    x.caracter = 'A';
    x.octeto ++;
    escribir_char (x.caracter); // mostraría 'B'  
    escribir_byte (x.octeto);   // mostraría 66

• la información se almacene como el framework considere oportuno (LayoutKind.Auto)
• que se almacene de forma secuencial, en el mismo orden en el que han sido declarados (LayoutKind.Sequential).
• que se almacene donde le indiquemos de forma explícita (LayoutKind.Explicit). En este caso, necesitaremos especificar en cada miembro la posición exacta de memoria donde será guardado, utilizando el atributo FieldOffset.

using System.Runtime.InteropServices;
using System;
namespace PruebaUniones
{
     [StructLayout(LayoutKind.Explicit)]
     public struct UnionTest
     {
            [FieldOffset(0)] public char Caracter;
            [FieldOffset(0)] public short Valor;
     }    
    class Program
    {
        public static void Main()
        {
            UnionTest ut = new UnionTest();
            ut.Caracter = 'A';
            ut.Valor ++;
            Console.WriteLine(ut.Caracter); // Muestra "B"
            Console.ReadKey();
            return;
        }
    }
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Explicit)> _
Public Structure Union16
    <FieldOffset(0)> Dim Word As Int16
    <FieldOffset(0)> Dim Bytes As Bytes
End Structure

<StructLayout(LayoutKind.Explicit)> _
Public Structure Bytes
    <FieldOffset(0)> Dim Bajo As Byte
    <FieldOffset(1)> Dim Alto As Byte
End Structure

Public Class Program
    Public Shared Sub main()
        Dim u As New Union16
        u.Word = 513         ' 513 = 256*1 (Byte alto) + 1 (byte bajo)
        u.Bytes.Alto += 1
        Console.WriteLine("Word: " & u.Word)            ' Muestra 769 (3*256+1)
        Console.WriteLine("Byte alto: " & u.Bytes.Alto) ' Muestra 3
        Console.WriteLine("Byte bajo: " & u.Bytes.Bajo) ' Muestra 1
        Console.ReadKey()
        Console.ReadKey()
    End Sub
End Class

<script>
    var count = <%= borrarRegistros() %>
    alert("Borrados: " + count + " registros");
</script>

<script>
    /*
    var count = <%= borrarRegistros() %>
    alert("Borrados: " + count + " registros");
    */
</script>

<script>
    /*
    var count = 99;
    alert("Borrados: " + count + " registros");
    */
</script>

<%-- 
  <script>
    var count = <%= borrarRegistros() %>
    alert("Borrados: " + count + " registros");
  </script>
--%>

• que fuera la clase la que realizara esta tarea, ofreciendo al usuario de la misma constructores con distintas sobrecargas cuyos parámetros corresponden con las propiedades a inicializar.
  

  // Constructor de la clase Persona:
  public Persona(string nombre, string apellidos, int edad, ...)
  {
     this.Nombre = nombre;
     this.Apellidos = apellidos;
     this.Edad = edad;
     ...
  }
  // Uso:
  Persona p = new Persona("Juan", "López", 32, ...);

   
• o bien dejar esta responsabilidad al usuario, permitiéndole el acceso directo a propiedades o campos del objeto creado.

  
  // Uso:
  Persona p = new Persona();
  p.Nombre = "Juan";
  p.Apellidos = "López";
  p.Edad = 32;
  ...
  

   
  

// C#:
Persona p = new Persona { Nombre="Juan", Apellidos="López", Edad=32 };


' VB.NET:
Dim p = New Persona With {.Nombre="Luis", .Apellidos="López", .Edad=32 }

// C#:
Persona p = new Persona ("Luis", "López") { Edad = 32 };


' VB.NET:
Dim p = New Persona ("Luis", "López") With { .Edad = 32 }

// C#:
Persona p = new Persona ("Juan", "Pérez") { Nombre="Luis" };
Console.WriteLine(p.Nombre); // Escribe "Luis"


' VB.NET:
Dim p = New Persona ("Juan", "Pérez") With { .Nombre="Luis" }
Console.WriteLine(p.Nombre); ' Escribe "Luis"

// C#:
// Se han cortado las líneas para facilitar la lectura
Persona p = new Persona() 
{ 
    Nombre = "Juan",
    Apellidos = "López",
    Edad = 55,
    Domicilio = new Localizacion 
    {
        Direccion = "Callejas, 34",
        Localidad = "Sevilla",
        Provincia = "Sevilla"
    }
};


' VB.NET:
' Se han cortado las líneas para facilitar la lectura
Dim p = New Persona() With { _
  .Nombre = "Juan", _
  .Apellidos = "López", _
  .Edad = 55, _
  .Domicilio = New Localizacion With { _
    .Direccion = "Callejas, 23", _
    .Localidad = "Sevilla", _
    .Provincia = "Sevilla" _
    } _
  }

public static class MyExtensions
{
    public static bool IsNullOrEmpty(this string s)
    {
        return s == null || s.Length == 0;
    }
}

string name = getCurrentUserName();
if (!name.IsNullOrEmpty())
...

Imports System.Runtime.CompilerServices
Module MyExtensions
    <Extension()> _
    Public Function IsNullOrEmtpy(ByVal s As String) As String
        Return (s = Nothing) OrElse (s.Length = 0)
    End Function
End Module
[...]

' Forma de invocar el método:
If s.IsNullOrEmtpy() Then
[...]

public static class HtmlStringUtils
{
   public static function string Negrita(string s)
   {
     return "<strong>" + s + "</strong>";
   }
   public static function string Cursiva(string s) {...}
   public static function string Superindice(string s) {...}
   [...]
}

  HtmlStringUtils.Negrita(currentUser.Name)

public static class HtmlStringUtils
{
   public static function string Negrita(this string s)
   {
      return "<strong>" + s + "</strong>";
   }
   [...]
}

  return currentUser.Name.Negrita();

   // Método de extensión sobre un string
   public static string Colorea(this string s, Color color)
   {
      [...]
   }

   // Forma de invocarlo:
   string str = User.Name.Colorea(Color.Red);

  string s = "cadena";

  var x = XmlDateTimeSerializationMode.Local;

  XmlDateTimeSerializationMode x = XmlDateTimeSerializationMode.Local;

  // Un ejemplo de bucle...
  var chars = "Saludicos".ToCharArray();
  foreach (var ch in chars)
  {
    Console.Write(ch); // ch es char
  }

  // Y ahora un bloque using...
  using (var ctx = new AppContext())
  {
    // usamos ctx, que es de tipo AppContext
  }

  var x = new { Nombre = "Juan", Edad = 23 };

  class __Anonymous1
  {
     private string nombre ;
     private int edad ;
     public string Nombre { get { return nombre ; } }
     public int Edad { get { return edad ; } }
     public __Anonymous1(string nombre, int edad)
     {
       this.nombre = nombre;
       this.edad = edad;
     }
  }
  ...
  __Anonymous1 x = new __Anonymous1("Juan", 23);

• La declaración debe incluir un valor de inicialización. En otras palabras, no será posible usar en una línea var i;, puesto que el compilador no podría inferir el tipo en este momento.
• El valor de inicialización debe ser una expresión evaluable como clase en tiempo de compilación. Expresamente prohibido el valor null, es decir, nada de var n = null;, puesto que el compilador no sabría de qué tipo se trata; eso sí, si fuera necesario, podría forzarse un casting var str = null as string;.
• La declaración no puede incluir más de una variable. Una línea como var i = 1, s = "hola"; generará un error en compilación.
• El inicializador no puede referirse a la propia variable declarada, obviamente.
• Sólo pueden utilizarse como variables locales en bloques de código, en bucles for y foreach y como recurso de un bloque using.

Implicitly-typed local variables must be initialized
(Las variables locales implícitamente tipadas deben ser inicializadas)

class @class
{
  public static void @static(bool @bool)
  {
    if (@bool)
      System.Console.WriteLine("true");
    else
      System.Console.WriteLine("false");
  }
}

• en la primera estaría el formulario de introducción de criterios.
• en la segunda podríamos simplemente tomar los parámetros de la anterior y mostrar un listado con los resultados obtenidos, o bien un mensaje de información si no hay coincidencias.
• en la tercera podríamos montar una ficha con los datos detallados de un elemento, que habría sido seleccionado por el usuario en la página anterior.

if (PreviousPage != null)
{
  TextBox txt =
    (TextBox)PreviousPage.FindControl("TextBox1");
  Label1.Text = txt.Text; // Por ejemplo
}

<%@ PreviousPageType VirtualPath="~/PaginaOrigen.aspx" %>

public string Texto
{
   get {return txtTexto.Text; }
}

if (PreviousPage != null)
{
  Label1.Text = PreviousPage.Texto; // Por ejemplo
}

• Un ensamblado listo para ser utilizado en nuestros proyectos, o para añadirlo a la caja de herramientas (Toolbox) del entorno de desarrollo.
• Una web de demostración, en la que podéis haceros una idea de la utilidad del componente. No hay una demo on-line debido a que en los servidores donde se encuentra no existe esta posibilidad, cuando encuentre un alojamiento apropiado la pondré para que pueda verse en vivo y en directo.
• La solución VS2005 con el código fuente completo de ambos.

• Web del proyecto NiftyDotNet (alojado en Google code).
• Blog del proyecto, en inglés (o algo parecido ;-))

private string saludar(string nombre)
{
  if ("".Equals(nombre))
    return "No saludo a nadie";
  else
    return "Hola, " + nombre;
}

private string saludar(string nombre)
{
  if (string.IsNullOrEmpty(nombre))
    return "No saludo a nadie";
  else
    return "Hola, " + nombre;
}

public enum EstadoSemaforo
{
    Rojo, Amarillo, Verde
}

[Flags]
public enum LedStatus
{
   BloqMays=1,
   BloqNum=2,
   BloqDespl=4,
   All=BloqMays | BlogNum | BloqDespl,
   None = 0
}

public enum TipoDeUsuario
{
   Anonimo = 0,
   Registrado = 1,
   Gestor = 2,
   SuperUsuario = Registrado | Gestor;
}

LedStatus leds =  LedStatus.BloqMays | LedStatus.BloqNum
Console.WriteLine(leds);

// la siguiente instrucción activa el
// BloqMays, pero desactiva todos los demás

estado = LedStatus.BloqMays;

// las siguientes instrucciones
// activan el bit 0 (BlockMays)
// dejando intactos los demás leds:

estado = estado | LedStatus.BloqMays;
estado |= LedStatus.BloqMays;

if(estado==LedStatus.BloqMays)
   // sólo se cumple si está
   // activo únicamente BloqMays

if ( (estado & LedStatus.BloqMays) != 0)
   // se cumple cuando el BloqMays
   // está activo, independientemente del resto

string sql =
@"SELECT product_name,
       product_details,
       total_rows
  FROM (
        SELECT product_name,
               product_details,
               total_rows,
               rownum row_counter
        FROM   (
                SELECT product_name,
                       product_details,
                       count(*) OVER () total_rows
                FROM   products
                WHERE product_name
                        like '%" + pattern + @"%'
                ORDER BY product_name
               )
       )
  WHERE row_counter between v_start_row and v_end_row;";

<?php
echo <<<EOT
function AddCss()
{
   var l=document.createElement('link');
   l.setAttribute('type','text/css');
   l.setAttribute('rel','stylesheet');
   l.setAttribute('href','styles.css');
   document.getElementsByTagName('head')[0].appendChild(l);
};
EOT;
?>

string script =
@"function AddCss()
{
    var l=document.createElement('link');
    l.setAttribute('type','text/css');
    l.setAttribute('rel','stylesheet');
    l.setAttribute('href','styles.css');
    l.setAttribute('media','screen');
    document.getElementsByTagName('head')[0].appendChild(l);
}";
Response.Write(script);