Reglas y convenciones de nomenclatura de identificadores de C#

Un identificador de es el nombre que se asigna a un tipo (clase, interfaz, estructura, delegado o enumeración), miembro, variable o espacio de nombres.

Reglas de nomenclatura

Los identificadores válidos deben seguir estas reglas. El compilador de C# genera un error para cualquier identificador que no siga estas reglas:

• Los identificadores deben comenzar con una letra o un carácter de subrayado (_).
• Los identificadores pueden contener caracteres de letra Unicode, caracteres de dígito decimal, caracteres de conexión Unicode, caracteres de combinación Unicode o caracteres de formato Unicode. Para obtener más información sobre las categorías Unicode, vea la base de datos de categorías Unicode.

Puede declarar identificadores que coincidan con palabras clave de C# mediante el prefijo @ en el identificador. El @ no forma parte del nombre del identificador. Por ejemplo, @if declara un identificador denominado if. Estos identificadores textuales son principalmente para la interoperabilidad con los identificadores declarados en otros lenguajes.

Para obtener una definición completa de identificadores válidos, consulte el artículo Identifiers (Identificadores) de la especificación del lenguaje C#.

Convenciones de nomenclatura

Además de las reglas, las convenciones para los nombres de identificador se usan en todas las API de .NET. Estas convenciones proporcionan coherencia para los nombres, pero el compilador no los aplica. Puede usar diferentes convenciones en los proyectos.

Por convención, los programas de C# usan PascalCase para nombres de tipo, espacios de nombres y todos los miembros públicos. Además, el equipo de dotnet/docs usa las siguientes convenciones, adoptadas del equipo de .NET Runtime , estilo de codificación:

• Los nombres de interfaz comienzan con una Imayúscula.

• Los tipos de atributo terminan con la palabra Attribute.

• Los tipos de enumeración usan un sustantivo singular para los que no son marcas y uno plural para los que sí.

• Los identificadores no deben contener dos caracteres de subrayado consecutivos (_). Esos nombres están reservados para identificadores generados por el compilador.

• Utiliza nombres significativos y descriptivos para variables, métodos y clases.

• Prefiere la claridad sobre la brevedad.

• Use PascalCase para los nombres de clase y los nombres de método.

• Use camelCase para parámetros de método y variables locales.

• Use PascalCase para nombres de constantes, tanto campos como constantes locales.

• Los campos de instancia privados comienzan con un guión bajo (_) y el resto del texto se escribe en camelCased.

• Los campos estáticos comienzan con s_. Esta convención no es el comportamiento predeterminado de Visual Studio ni parte de las directrices de diseño de Framework, pero es configurable en editorconfig.

• Evite usar abreviaturas o acrónimos en nombres, excepto las abreviaturas ampliamente conocidas y aceptadas.

• Usa espacios de nombres significativos y descriptivos siguiendo la notación inversa del nombre de dominio.

• Elija nombres de ensamblado que representen el propósito principal del ensamblado.

• Evite usar nombres de letra única, excepto los contadores de bucle simples. Además, los ejemplos de sintaxis que describen la sintaxis de las construcciones de C# suelen usar los siguientes nombres de letra única que coinciden con la convención usada en la especificación del lenguaje C# de . Los ejemplos de sintaxis son una excepción a la regla.

  • Use S para estructuras, C para clases.
  • Se usa M para los métodos.
  • Use v para variables, p para parámetros.
  • Use r para parámetros ref.

En los ejemplos siguientes, las instrucciones relativas a los elementos marcados public también son aplicables al trabajar con elementos protected y protected internal, todos los cuales están diseñados para ser visibles para los autores de llamadas externos.

Caso Pascal

Use PascalCase ("PascalCasing") al asignar un nombre a un tipo class, interface, structo delegate.

public class DataService
{
}

public record PhysicalAddress(
    string Street,
    string City,
    string StateOrProvince,
    string ZipCode);

public struct ValueCoordinate
{
}

public delegate void DelegateType(string message);

Al asignar un nombre a interface, use la grafía Pascal además de agregar el prefijo I al nombre. Este prefijo indica claramente a los consumidores que es un interface.

public interface IWorkerQueue
{
}

Al asignar nombres public a los miembros de los tipos, como campos, propiedades o eventos, use la grafía pascal. Además, use mayúsculas y minúsculas pascales para todos los métodos y funciones locales.

public class ExampleEvents
{
    // A public field, these should be used sparingly
    public bool IsValid;

    // An init-only property
    public IWorkerQueue WorkerQueue { get; init; }

    // An event
    public event Action EventProcessing;

    // Method
    public void StartEventProcessing()
    {
        // Local function
        static int CountQueueItems() => WorkerQueue.Count;
        // ...
    }
}

Al escribir registros posicionales, use la grafía Pascal para los parámetros, ya que son las propiedades públicas del registro.

public record PhysicalAddress(
    string Street,
    string City,
    string StateOrProvince,
    string ZipCode);

Para más información sobre los registros posicionales, consulte Sintaxis posicional para la definición de propiedades.

Grafía Camel

Use la grafía Camel ("camelCasing") al asignar nombres a los campos private o internal, y ponga los prefijos _. Use la grafía camel al asignar nombres a las variables locales, incluidas las instancias de un tipo delegado.

public class DataService
{
    private IWorkerQueue _workerQueue;
}

Al trabajar con campos static que sean private o internal, use el prefijo s_ y, para el subproceso estático, use t_.

public class DataService
{
    private static IWorkerQueue s_workerQueue;

    [ThreadStatic]
    private static TimeSpan t_timeSpan;
}

Al escribir parámetros de método, use la grafía Camel.

public T SomeMethod<T>(int someNumber, bool isValid)
{
}

Para obtener más información sobre las convenciones de nomenclatura de C#, consulte el estilo de codificación del equipo en tiempo de ejecución de .NET.

Directrices de nomenclatura de parámetros de tipo

Las instrucciones siguientes se aplican a los parámetros de tipo en los parámetros de tipo genérico. Los parámetros de tipo son los marcadores de posición de los argumentos de un tipo genérico o un método genérico. Puede obtener más información sobre parámetros de tipo genérico en la guía de programación de C#.

• Asigne nombres descriptivos a los parámetros de tipo genérico, a no ser que un nombre de una sola letra sea completamente claro y un nombre descriptivo no agregue ningún valor.

  public interface ISessionChannel<TSession> { /*...*/ }
  public delegate TOutput Converter<TInput, TOutput>(TInput from);
  public class List<T> { /*...*/ }
  

• Considere usar T como nombre del parámetro de tipo para los tipos con un parámetro de tipo de una sola letra.

  public int IComparer<T>() => 0;
  public delegate bool Predicate<T>(T item);
  public struct Nullable<T> where T : struct { /*...*/ }
  

• Establezca el prefijo "T" a los nombres de parámetro de tipo descriptivos.

  public interface ISessionChannel<TSession>
  {
      TSession Session { get; }
  }
  

• Considere la posibilidad de indicar restricciones que se encuentran en un parámetro de tipo en el nombre del parámetro. Por ejemplo, un parámetro restringido a ISession podría llamarse TSession.

La regla de análisis de código CA1715 se puede usar para asegurarse de que los parámetros de tipo se denominan correctamente.

Convenciones de nomenclatura adicionales

• En ejemplos que no incluyan directivas using, use calificaciones de espacio de nombres. Si sabe que un espacio de nombres se importa de forma predeterminada en un proyecto, no tiene que especificar completamente los nombres de ese espacio de nombres. Los nombres calificados se pueden dividir después de un punto (.) si son demasiado largos para una sola línea, como se muestra en el ejemplo siguiente.

  var currentPerformanceCounterCategory = new System.Diagnostics.
      PerformanceCounterCategory();
  

• No es necesario cambiar los nombres de los objetos creados mediante las herramientas del diseñador de Visual Studio para que se ajusten a otras directrices.