Convenciones y reglas de nomenclatura de identificadores de C#

  • Artículo

Un identificador es el nombre que se asigna a un tipo (clase, interfaz, struct, 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 decimales, 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. @ no forma parte del nombre de 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, vea el artículo sobre identificadores en la Especificación del lenguaje C#.

Importante

La especificación del lenguaje C# solo permite categorías de letras (Lu, Ll, Lt, Lm, Lo o Nl), dígitos (Nd), conexión (Pc), combinación (Mn o Mc), y formato (Cf). Cualquier elemento externo que se reemplace automáticamente mediante _. Es posible que esto afecte a determinados caracteres Unicode.

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 las aplica. Puede usar otras 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 dotnet/docs usa las siguientes convenciones, adoptadas del estilo de codificación del equipo en tiempo de ejecución de .NET:

  • Los nombres de interfaz empiezan por una I mayú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 los identificadores generados por el compilador.

  • Use nombres con significado y descriptivos para las variables, los métodos y las clases.

  • Prefiere la claridad sobre la brevedad.

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

  • Utilice camelCase para los parámetros de los métodos y las variables locales.

  • Use PascalCase para los nombres de las 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 por s_. Esta convención no es el comportamiento predeterminado de Visual Studio ni forma parte de las instrucciones de diseño de Framework, perose puede configurar en editorconfig.

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

  • Use espacios de nombres con significado y descriptivos que siguen la notación inversa del nombre de dominio.

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

  • Evite usar nombres de una sola letra, 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 una sola letra que coinciden con la convención usada en la especificación del lenguaje C#. Los ejemplos de sintaxis son una excepción a la regla.

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

Sugerencia

Puede aplicar las convenciones de nomenclatura relativas a mayúsculas, prefijos, sufijos y separadores de palabras mediante reglas de nomenclatura de estilo de código.

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

Caso Pascal

Use la grafía Pascal ("PascalCasing") al asignar un nombre a los tipos class, interface, struct o 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 elemento 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;
}

Sugerencia

Al editar código de C# que sigue estas convenciones de nomenclatura en un IDE que admite la finalización de instrucciones, al escribir _ se mostrarán todos los miembros con ámbito de objeto.

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.

Instrucciones de nomenclatura de los 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 los parámetros de tipo genéricos 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>() { return 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 puede llamarse TSession.

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

Convenciones de nomenclatura extra

  • En ejemplos que no incluyan directivas using, use calificaciones de espacio de nombres. Si sabe que un espacio de nombres se importa en un proyecto de forma predeterminada, no es necesario completar los nombres de ese espacio de nombres. Los nombres completos pueden partirse 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 objetos que se crearon con las herramientas del diseñador de Visual Studio para que se ajusten a otras directrices.