En la ayuda se marcan con el simbolo de la S.

Elementos que pueden ser estáticos:

• CAMPOS ESTÁTICOS:
  
  Es como una variable global de un lenguaje procedimental (como por ejemplo C).
  
  Como ejemplos de campos estáticos tenemos, en la clase System.DateTime los campos estáticos MinValue y MaxValue.
  
  Un ejemplo de como llamamos a estos campos es el siguiente:
  

  static void Main(string[] args)
  {
      Console.WriteLine("Pasado: {0}", DateTime.MinValue);
      Console.WriteLine("Futuro: {0}", DateTime.MaxValue);
  }
  

  
  La salida que produce este fragmento de código es la siguiente:
  
  Pasado: 01/01/0001 0:00:00
  Futuro: 31/12/9999 23:59:59
  
  Como ya sabemos, cuando se crean objetos de una clase, todos los objetos de la misma comparten los métodos de la clase, pero no comparten sus campos y propiedades, es decir cada objeto posee sus propios campos y propiedades.
  
  Haciendo static a un campo lo que conseguimos es que sea compartido por todos los objetos de la clase.
  
  En el ejemplo de la clase DateTime, el valor del MinValue es para todos los objetos el 01/01/0001 0:00:00 y para el MaxValue el 31/12/9999 23:59:59
  
  Otra cosa importante que hay que tener muy en cuenta es que para llamar a un campo static no se hace a través de un objeto de la clase, sinó que se hace a través del nombre de la clase, seguido de un punto y el nombre del campo. En el caso de la clase DateTime, es Datetime.MinValue por ejemplo.
  
  Veamos ahora un ejemplo más elaborado, tenemos la siguiente clase:
  
  

  namespace Employee
  {
      public class Employee
      {
          public static int EmployeeCounter = 0;
  
          public Employee()
          {
              EmployeeCounter++;
          }
      }
  }
  

  
  Como vemos en esta clase tenemos un campo estático ( EmployeeCounter ) y un constructor que cada vez que se cree una instancia de Employee sumará 1 a nuestro campo estático.
  
  Como ya hemos comentado los campos estáticos son compartidos por todas las instancias de la clase por lo que todos tendrán el mismo valor a medida que se vayan creando instancias de la clase.
  
  Ejemplo de uso de esta clase:
  
  

  static void Main(string[] args)
  {
      Employee e1 = new Employee(); 
      Console.WriteLine("Numero de instancias: {0}", Employee.EmployeeCounter);
      //Devuelve  Numero de instancias: 1
      
      Employee e1 = new Employee();
      Console.WriteLine("Numero de instancias: {0}", Employee.EmployeeCounter);
      //Devuelve  Numero de instancias: 2
  }
  

• MÉTODOS ESTÁTICOS:
  
  Los métodos estáticos son como una función de un lenguaje procedimental (como por ejemplo C)
  
  
  Ejemplo:
  
  

  public class IsLeapYear
  {
     public static void Main()
     {
        for (int year = 1994; year <= 2014; year++)
        {
           if (DateTime.IsLeapYear(year))
           {
              Console.WriteLine("{0} is a leap year.", year);
              DateTime leapDay = new DateTime(year, 2, 29);
              DateTime nextYear = leapDay.AddYears(1);
              Console.WriteLine("   One year from {0} is {1}.", 
                                leapDay.ToString("d"), 
                                nextYear.ToString("d"));
           }         
        }
     }
  }
  // The example produces the following output:
  //       1996 is a leap year.
  //          One year from 2/29/1996 is 2/28/1997.
  //       2000 is a leap year.
  //          One year from 2/29/2000 is 2/28/2001.
  //       2004 is a leap year.
  //          One year from 2/29/2004 is 2/28/2005.
  //       2008 is a leap year.
  //          One year from 2/29/2008 is 2/28/2009.
  //       2012 is a leap year.
  //          One year from 2/29/2012 is 2/28/2013.
  
  

• PROPIEDADES ESTÁTICAS:
  
  Ocurre exáctamente lo mismo que con los campos.
  
• CLASES ESTÁTICAS:
  
  Son clases que se definen solo para agrupar miembros estáticos, no para crear instancias. System.Math (la que hemos usado en uno de los ejemplos anteriores) es un buen ejemplo de una clase de la que nunca se crean instancias porque sus métodos son estáticos.
  
  Las clases estáticas se deben marcar con la palabra static para que el compilador pueda asegurar que no se crean instancias suyas.
  
• CONSTRUCTORES ESTÁTICOS:
  
  Podemos definir constructores estáticos (sin parámetros) para inicializar campos estáticos.
  
  Un constructor estático se marca con la palabra static y no se invoca nunca explicitamente. El entorno de ejecución se asegura de que se ejecute el constructor estático antes de que usemos cualquiera de sus campos o métodos y antes de que se instancie ningún obeto de la clase (si es que la clase no es estática).
  
  Usar un constructor estático es útil, cuando queremos inicializar variables (tipicamente de solo lectura) cuyo valor no se puede conocer en tiempo de compilación, bien porque depende del estado del entorno de ejecución o bien porque requieren de la ejecución de funciones o métodos que solo pueden invocarse en ejecución.
  
  

CONST

Por último, muy interesante e importante, un tipo de campo estático especial que no se marca con la palabra static son las constantes. Cuando quieres dfinir un valor que no puede cambiar en tiempo de ejecución en vez de usar static se utiliza const, esto es porque como no van a variar es tonteria guardar una copia de esta variable en cada instancia (ahorrando memória). Ejemplo de campos const son por ejemplo los que encontramos en la clase Math para definir algunas constantes como por ejemplo el número E o PI:

public static class Math
{
   public const double E = 2.71828;
   public const double PI = 3.14159;
}

Para imprimir en nuestro programa el valor de  PI  por ejemplo haríamos;

Console.WriteLine(Math.PI);

MUY IMPORTANTE: Saber que los métodos, campos y propiedades estáticos no participan en la herencia, por lo que, por ejemplo los operadores sobrecargados de una clase, no son heredados por otra hija de esta.