Dela via

Namngivningsregler och konventioner för C#-identifierare

  • Artikel

En identifierare är det namn som du tilldelar till en typ (klass, gränssnitt, struct, 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 ett understreck (_).
  • Identifierare kan innehålla Unicode-bokstavstecken, decimaltecken, Unicode-anslutande tecken, Unicode som kombinerar tecken eller Unicode-formateringstecken. Mer information om Unicode-kategorier finns i Unicode-kategoridatabasen.

Du kan deklarera identifierare som matchar C#-nyckelord med hjälp av prefixet @ i identifieraren. @ Är inte en del av identifierarnamnet. Deklarerar @if till exempel en identifierare med namnet if. Dessa ordagranna identifierare är främst 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.

Viktigt!

C#-språkspecifikationen tillåter endast bokstavskategorier (Lu, Ll, Lt, Lm, Lo eller Nl), siffra (Nd), anslutning (Pc), kombination (Mn eller Mc) och formatering (Cf). Allt utanför som ersätts automatiskt med ._ Detta kan påverka vissa Unicode-tecken.

Namngivningskonventioner

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änds PascalCase C#-program för typnamn, namnområden och alla offentliga medlemmar. dotnet/docs Dessutom använder 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 den återstående texten är camelCased.

  • Statiska fält börjar med s_. Den här konventionen är inte standardbeteendet för Visual Studio eller en del av ramverkets designriktlinjer, 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 namn med en bokstav, förutom 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änds S för structs för C klasser.
    • Använd M för metoder.
    • Använd v för variabler för p parametrar.
    • Använd r för ref parametrar.

Dricks

Du kan tillämpa namngivningskonventioner som rör versaler, prefix, suffix och ordavgränsare med hjälp av namngivningsregler i kodstil.

I följande exempel gäller vägledning som rör markerade element 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 pascalhöljet ("PascalCasing") när du namnger en class, interface, structeller delegate typ.

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 interfaceanvänder du pascal-hölje förutom att prefixera 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 pascal-hölje för parametrar eftersom de är postens offentliga egenskaper.

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 prefixar dem med _. Använd kamelhölje när du namnger lokala variabler, inklusive instanser av en delegattyp.

public class DataService
{
    private IWorkerQueue _workerQueue;
}

Dricks

När du redigerar C#-kod som följer dessa namngivningskonventioner i en IDE som har stöd för slutförande _ av instruktionen visas alla medlemmar med objektomfattning.

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 C#-programmeringsguiden.

  • 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 prefixet descriptive type parameternamn med "T".

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

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

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

Extra namngivningskonventioner

  • Exempel som inte omfattar användning av direktiv anvä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.