Namngivningsregler och konventioner för C#-identifierare

En identifierare är det namn du ger en typ (klass, gränssnitt, struktur, ombud eller uppräkning), medlem, variabel eller namnrymd.

Namngivningsregler

Giltiga identifierare måste följa dessa regler. C#-kompilatorn genererar ett fel för alla identifierare som inte följer dessa regler:

• Identifierare måste börja med en bokstav eller understreck (_).
• Identifierare kan innehålla Unicode-bokstavstecken, decimalsiffertecken, Unicode-sammanbindningstecken, Unicode-kombinerande tecken eller Unicode-formateringstecken. Mer information om Unicode-kategorier finns i Unicode Category Database.

Du kan deklarera identifierare som matchar C#-nyckelord med hjälp av @ prefixet i identifieraren. @ ingår inte i identifierarnamnet. Till exempel deklarerar @if en identifierare med namnet if. Dessa ordagranna identifierare är främst avsedda för samverkan med identifierare som deklarerats på andra språk.

En fullständig definition av giltiga identifierare finns i artikeln Identifierare i C#-språkspecifikationen.

Namngivning

Förutom reglerna används konventioner för identifierarnamn i .NET-API:erna. Dessa konventioner ger konsekvens för namn, men kompilatorn tillämpar dem inte. Du kan använda olika konventioner i dina projekt.

Enligt konventionen använder C#-program PascalCase för typnamn, namnområden och alla offentliga medlemmar. Dessutom använder dotnet/docs-teamet följande konventioner som antagits från .NET Runtime-teamets kodningsformat:

• Gränssnittsnamn börjar med versaler I.

• Attributtyper slutar med ordet Attribute.

• Uppräkningstyper använder ett unikt substantiv för nonflags och ett pluralt substantiv för flaggor.

• Identifierare får inte innehålla två på varandra följande understreck (_) tecken. Dessa namn är reserverade för kompilatorgenererade identifierare.

• Använd meningsfulla och beskrivande namn för variabler, metoder och klasser.

• Föredrar klarhet framför korthet.

• Använd PascalCase för klassnamn och metodnamn.

• Använd camelCase för metodparametrar och lokala variabler.

• Använd PascalCase för konstanta namn, både fält och lokala konstanter.

• Privata instansfält börjar med ett understreck (_) och resten av texten är formaterad i camelCase.

• Statiska fält börjar med s_. Den här konventionen är inte standardbeteendet för Visual Studio eller en del av Framework-designriktlinjerna, men kan konfigureras i editorconfig.

• Undvik att använda förkortningar eller förkortningar i namn, med undantag för allmänt kända och accepterade förkortningar.

• Använd meningsfulla och beskrivande namnområden som följer den omvända domännamnsanteckningen.

• Välj sammansättningsnamn som representerar det primära syftet med sammansättningen.

• Undvik att använda enbokstavsnamn, utom för enkla loopräknare. Syntaxexempel som beskriver syntaxen för C#-konstruktioner använder ofta följande namn med en bokstav som matchar den konvention som används i C#-språkspecifikationen. Syntaxexempel är ett undantag från regeln.

  • Använd S för structs, C för klasser.
  • Använd M för metoder.
  • Använd v för variabler, p för parametrar.
  • Använd r för ref parametrar.

I följande exempel gäller vägledning för element som markerats public även när du arbetar med protected och protected internal element, som alla är avsedda att vara synliga för externa anropare.

Pascal-fall

Använd PascalCase ("PascalCasing") när du namnger en typ av class, interface, structeller delegate.

public class DataService
{
}

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

public struct ValueCoordinate
{
}

public delegate void DelegateType(string message);

När du namnger en interface, använd PascalCase och lägg till ett prefix till namnet med en I. Det här prefixet anger tydligt för konsumenterna att det är en interface.

public interface IWorkerQueue
{
}

När du namnger public medlemmar av typer, till exempel fält, egenskaper, händelser, använder du pascal-hölje. Använd också pascalhölje för alla metoder och lokala funktioner.

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;
        // ...
    }
}

När du skriver positionella poster använder du PascalCase för parametrarna eftersom de är offentliga egenskaper hos posten.

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

Mer information om positionella poster finns i Positionssyntax för egenskapsdefinition.

Kamelväska

Använd kamelhölje ("camelCasing") när du namnger private eller internal fält och prefix dem med _. Använd kamelhölje när du namnger lokala variabler, inklusive instanser av en delegattyp.

public class DataService
{
    private IWorkerQueue _workerQueue;
}

När du arbetar med static fält som är private eller internalanvänder du prefixet s_ och för trådens statiska användning t_.

public class DataService
{
    private static IWorkerQueue s_workerQueue;

    [ThreadStatic]
    private static TimeSpan t_timeSpan;
}

När du skriver metodparametrar använder du kamelhölje.

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

Mer information om namngivningskonventioner för C# finns i .NET Runtime-teamets kodningsformat.

Namngivningsriktlinjer för typparametrar

Följande riktlinjer gäller för typparametrar för generiska typparametrar. Typparametrar är platshållare för argument i en allmän typ eller en generisk metod. Du kan läsa mer om generiska typparametrar i programmeringsguiden för C#.

• Namnge generiska typparametrar med beskrivande namn, såvida inte ett enda bokstavsnamn är helt självförklarande och ett beskrivande namn inte skulle lägga till värde.

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

• Överväg att använda T som typparameternamn för typer med en parameter av typen enskild bokstav.

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

• Gör prefix för beskrivande typ parameternamn med "T".

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

• Överväg som anger begränsningar för en typparameter i namnet på parametern. En parameter som är begränsad till ISession kan till exempel anropas TSession.

Kodanalysregeln CA1715 kan användas för att säkerställa att typparametrarna namnges korrekt.

Extra namngivningskonventioner

• Exempel som inte innehåller med hjälp av direktivanvänder namnområdeskvalifikationer. Om du vet att ett namnområde importeras som standard i ett projekt behöver du inte helt kvalificera namnen från det namnområdet. Kvalificerade namn kan brytas efter en punkt (.) om de är för långa för en enda rad, som du ser i följande exempel.

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

• Du behöver inte ändra namnen på objekt som skapades med hjälp av Visual Studio-designerverktygen för att få dem att passa andra riktlinjer.