Codekonventionen für C# (C#-Programmierhandbuch)C# Coding Conventions (C# Programming Guide)

Codierungskonventionen dienen den folgenden Zwecken:Coding conventions serve the following purposes:

  • Sie kreieren ein konsistentes Erscheinungsbild des Codes, sodass Leser sich auf den Inhalt und nicht auf das Layout konzentrieren können.They create a consistent look to the code, so that readers can focus on content, not layout.

  • Sie ermöglichen es den Lesern, Code schneller zu verstehen, da Rückschlüsse basierend auf den bisherigen Erfahrungen gezogen werden können.They enable readers to understand the code more quickly by making assumptions based on previous experience.

  • Sie erleichtern das Kopieren, Ändern und Pflegen des Codes.They facilitate copying, changing, and maintaining the code.

  • Sie zeigen die Best Practices für C#.They demonstrate C# best practices.

Die Leitlinien in diesem Artikel werden von Microsoft befolgt, um Beispiele und Dokumentation zu entwickeln.The guidelines in this article are used by Microsoft to develop samples and documentation.

BenennungskonventionenNaming conventions

  • Verwenden Sie Namespacequalifizierungen in kurzen Beispielen, die keine using-Anweisungen umfassen.In short examples that don't include using directives, use namespace qualifications. Wenn Sie wissen, dass ein Namespace standardmäßig in ein Projekt importiert wird, müssen Sie den Namen aus diesem Namespace nicht voll qualifizieren.If you know that a namespace is imported by default in a project, you don't have to fully qualify the names from that namespace. Qualifizierte Namen können nach einem Punkt (.) unterbrochen werden, wenn sie für eine einzelne Zeile zu lang sind, wie im folgenden Beispiel gezeigt.Qualified names can be broken after a dot (.) if they are too long for a single line, as shown in the following example.

    var currentPerformanceCounterCategory = new System.Diagnostics.
        PerformanceCounterCategory();
    
  • Sie müssen nicht die Namen der Objekte ändern, die mit den Designertools von Visual Studio erstellt wurden, um sie an andere Richtlinien anzupassen.You don't have to change the names of objects that were created by using the Visual Studio designer tools to make them fit other guidelines.

LayoutkonventionenLayout conventions

Ein gutes Layout verwendet Formatierungen, um die Struktur des Codes hervorzuheben und um den Code verständlicher zu gestalten.Good layout uses formatting to emphasize the structure of your code and to make the code easier to read. Microsoft-Beispiele entsprechen den folgenden Konventionen:Microsoft examples and samples conform to the following conventions:

  • Verwenden Sie die Code-Editor-Standardeinstellungen (Intelligenter Einzug, vierstelliger Einzug, als Leerzeichen gespeicherte Tabulatoren).Use the default Code Editor settings (smart indenting, four-character indents, tabs saved as spaces). Weitere Informationen finden Sie unter Optionen, Text-Editor, C#, Formatierung.For more information, see Options, Text Editor, C#, Formatting.

  • Schreiben Sie pro Zeile nur eine Anweisung.Write only one statement per line.

  • Schreiben Sie pro Zeile nur eine Deklaration.Write only one declaration per line.

  • Wenn Fortsetzungszeilen nicht automatisch eingezogen werden, rücken Sie diese um einen Tabstopp (vier Leerzeichen) ein.If continuation lines are not indented automatically, indent them one tab stop (four spaces).

  • Fügen Sie zwischen Methoden- und Eigenschaftsdefinitionen mindestens eine Leerzeile ein.Add at least one blank line between method definitions and property definitions.

  • Verwenden Sie Klammern, um Klauseln in einem Ausdruck zu kennzeichnen, wie im folgenden Code gezeigt.Use parentheses to make clauses in an expression apparent, as shown in the following code.

    if ((val1 > val2) && (val1 > val3))
    {
        // Take appropriate action.
    }
    

Konventionen für KommentareCommenting conventions

  • Fügen Sie den Kommentar in einer eigenen Zeile und nicht am Ende einer Codezeile ein.Place the comment on a separate line, not at the end of a line of code.

  • Beginnen Sie Kommentartext mit einem Großbuchstaben.Begin comment text with an uppercase letter.

  • Beenden Sie den Kommentartext mit einem Punkt.End comment text with a period.

  • Fügen Sie ein Leerzeichen zwischen dem Kommentartrennzeichen (//) und dem Kommentartext ein, wie im folgenden Beispiel gezeigt.Insert one space between the comment delimiter (//) and the comment text, as shown in the following example.

    // The following declaration creates a query. It does not run
    // the query.
    
  • Erstellen Sie keine formatierten Blöcke mit Sternchen um Kommentare.Don't create formatted blocks of asterisks around comments.

SprachrichtlinienLanguage guidelines

In den folgenden Abschnitten werden die Vorgehensweisen beschrieben, denen das C#-Team folgt, um Codebeispiele zu erstellen.The following sections describe practices that the C# team follows to prepare code examples and samples.

String-DatentypString data type

  • Verwenden Sie die Zeichenfolgeninterpolation, um wie im folgenden Code gezeigt kurze Zeichenfolgen zu verketten.Use string interpolation to concatenate short strings, as shown in the following code.

    string displayName = $"{nameList[n].LastName}, {nameList[n].FirstName}";
    
  • Verwenden Sie ein StringBuilder-Objekt, um Zeichenfolgen in Schleifen anzufügen, besonders bei der Arbeit mit großen Textmengen.To append strings in loops, especially when you're working with large amounts of text, use a StringBuilder object.

    var phrase = "lalalalalalalalalalalalalalalalalalalalalalalalalalalalalala";
    var manyPhrases = new StringBuilder();
    for (var i = 0; i < 10000; i++)
    {
        manyPhrases.Append(phrase);
    }
    //Console.WriteLine("tra" + manyPhrases);
    

Implizit typisierte lokale VariablenImplicitly typed local variables

  • Verwenden Sie die implizite Typisierung für lokale Variablen, wenn der Typ der Variablen auf der rechten Seite der Zuweisung offensichtlich ist oder wenn der genaue Typ nicht von Bedeutung ist.Use implicit typing for local variables when the type of the variable is obvious from the right side of the assignment, or when the precise type is not important.

    var var1 = "This is clearly a string.";
    var var2 = 27;
    
  • Verwenden Sie nicht var, wenn der Typ nicht von der rechten Seite der Zuweisung offensichtlich ist.Don't use var when the type is not apparent from the right side of the assignment. Gehen Sie nicht davon aus, dass der Typ aus einem Methodennamen ersichtlich und somit eindeutig ist.Don't assume the type is clear from a method name. Ein Variablentyp wird als eindeutig angesehen, wenn es sich um einen new-Operator oder eine explizite Umwandlung handelt.A variable type is considered clear if it's a new operator or an explicit cast.

    int var3 = Convert.ToInt32(Console.ReadLine()); 
    int var4 = ExampleClass.ResultSoFar();
    
  • Verlassen Sie sich nicht auf den Variablennamen, um den Typ der Variablen anzugeben.Don't rely on the variable name to specify the type of the variable. Er ist unter Umständen nicht korrekt.It might not be correct. Im folgenden Beispiel ist der Variablenname inputInt irreführend.In the following example, the variable name inputInt is misleading. Es handelt sich um eine Zeichenfolge.It's a string.

    var inputInt = Console.ReadLine();
    Console.WriteLine(inputInt);
    
  • Vermeiden Sie den Einsatz von var anstelle von dynamic.Avoid the use of var in place of dynamic. Verwenden Sie dynamic, wenn Sie den Laufzeit-Typrückschluss verwenden möchten.Use dynamic when you want run-time type inference. Weitere Informationen finden Sie unter Verwenden des Typs „dynamic“ (C#-Programmierhandbuch).For more information, see Using type dynamic (C# Programming Guide).

  • Verwenden Sie die implizite Typisierung, um den Typ der Schleifenvariablen in for-Schleifen zu bestimmen.Use implicit typing to determine the type of the loop variable in for loops.

    Im folgenden Beispiel wird die implizite Typisierung in einer for-Anweisung verwendet.The following example uses implicit typing in a for statement.

    var phrase = "lalalalalalalalalalalalalalalalalalalalalalalalalalalalalala";
    var manyPhrases = new StringBuilder();
    for (var i = 0; i < 10000; i++)
    {
        manyPhrases.Append(phrase);
    }
    //Console.WriteLine("tra" + manyPhrases);
    
  • Verwenden Sie nicht die implizite Typisierung, um den Typ der Schleifenvariablen in foreach-Schleifen zu bestimmen.Don't use implicit typing to determine the type of the loop variable in foreach loops.

    Im folgenden Beispiel wird die explizite Typisierung in einer foreach-Anweisung verwendet.The following example uses explicit typing in a foreach statement.

    foreach (char ch in laugh)
    {
        if (ch == 'h')
            Console.Write("H");
        else
            Console.Write(ch);
    }
    Console.WriteLine();
    

    Hinweis

    Achten Sie darauf, nicht versehentlich den Typ eines Elements in der Iterable-Sammlung zu ändern.Be careful not to accidentally change a type of an element of the iterable collection. Beispielsweise ist es einfach, in einer foreach-Anweisung von System.Linq.IQueryable zu System.Collections.IEnumerable zu wechseln, was die Ausführung einer Abfrage ändert.For example, it is easy to switch from System.Linq.IQueryable to System.Collections.IEnumerable in a foreach statement, which changes the execution of a query.

Vorzeichenlose DatentypenUnsigned data types

Verwenden Sie im Allgemeinen int anstelle von Typen ohne Vorzeichen.In general, use int rather than unsigned types. Die Verwendung von int ist in C# üblich; durch den Einsatz von int wird die Interaktion mit anderen Bibliotheken vereinfacht.The use of int is common throughout C#, and it is easier to interact with other libraries when you use int.

ArraysArrays

Verwenden Sie die präzise Syntax, wenn Sie Arrays in der Deklarationszeile initialisieren.Use the concise syntax when you initialize arrays on the declaration line. Beachten Sie im folgenden Beispiel, dass Sie nicht var anstelle von string[] verwenden können.In the following example, note that you can't use var instead of string[].

string[] vowels1 = { "a", "e", "i", "o", "u" };

Wenn Sie explizite Instanziierung verwenden, können Sie var verwenden.If you use explicit instantiation, you can use var.

var vowels2 = new string[] { "a", "e", "i", "o", "u" };

Wenn Sie eine Arraygröße angeben, müssen Sie die Elemente einzeln initialisieren.If you specify an array size, you have to initialize the elements one at a time.

var vowels3 = new string[5];
vowels3[0] = "a";
vowels3[1] = "e";
// And so on.

DelegatenDelegates

Verwenden Sie Func<> und Action<>, anstatt Delegattypen zu definieren.Use Func<> and Action<> instead of defining delegate types. Definieren Sie in einer Klasse die Delegatmethode.In a class, define the delegate method.

public static Action<string> ActionExample1 = x => Console.WriteLine($"x is: {x}");

public static Action<string, string> ActionExample2 = (x, y) => 
    Console.WriteLine($"x is: {x}, y is {y}");

public static Func<string, int> FuncExample1 = x => Convert.ToInt32(x);

public static Func<int, int, int> FuncExample2 = (x, y) => x + y;

Rufen Sie die Methode mit der Signatur auf, die vom Func<>- oder Action<>-Delegaten definiert wird.Call the method using the signature defined by the Func<> or Action<> delegate.

ActionExample1("string for x");

ActionExample2("string for x", "string for y");

Console.WriteLine($"The value is {FuncExample1("1")}");

Console.WriteLine($"The sum is {FuncExample2(1, 2)}");

Wenn Sie Instanzen eines Delegattyps erstellen, verwenden Sie die präzise Syntax.If you create instances of a delegate type, use the concise syntax. Definieren Sie in einer Klasse den Delegattyp und eine Methode, die eine übereinstimmende Signatur besitzt.In a class, define the delegate type and a method that has a matching signature.

public delegate void Del(string message);

public static void DelMethod(string str)
{
    Console.WriteLine("DelMethod argument: {0}", str);
}

Erstellen Sie eine Instanz des Delegattyps, und rufen Sie sie auf.Create an instance of the delegate type and call it. Die folgende Deklaration zeigt die komprimierte Syntax.The following declaration shows the condensed syntax.

Del exampleDel2 = DelMethod;
exampleDel2("Hey");

In der folgenden Deklaration wird die vollständige Syntax verwendet.The following declaration uses the full syntax.

Del exampleDel1 = new Del(DelMethod);
exampleDel1("Hey");

try-catch- und using-Anweisungen in der Ausnahmebehandlungtry-catch and using statements in exception handling

  • Verwenden Sie eine try-catch-Anweisung für die meisten Ausnahmebehandlungen.Use a try-catch statement for most exception handling.

    static string GetValueFromArray(string[] array, int index)
    {
        try
        {
            return array[index];
        }
        catch (System.IndexOutOfRangeException ex)
        {
            Console.WriteLine("Index is out of range: {0}", index);
            throw;
        }
    }
    
  • Vereinfachen Sie den Code mithilfe der C#-Anweisung using.Simplify your code by using the C# using statement. Verwenden Sie bei einer try-finally-Anweisung, in der der einzige Code im finally-Block ein Aufruf der Dispose-Methode ist, stattdessen eine using-Anweisung.If you have a try-finally statement in which the only code in the finally block is a call to the Dispose method, use a using statement instead.

    Im folgenden Beispiel ruft die try-finally-Anweisung nur Dispose im finally-Block auf.In the following example, the try-finally statement only calls Dispose in the finally block.

    Font font1 = new Font("Arial", 10.0f);
    try
    {
        byte charset = font1.GdiCharSet;
    }
    finally
    {
        if (font1 != null)
        {
            ((IDisposable)font1).Dispose();
        }
    }
    

    Dasselbe können Sie mit einer using-Anweisung erreichen.You can do the same thing with a using statement.

    using (Font font2 = new Font("Arial", 10.0f))
    {
        byte charset2 = font2.GdiCharSet;
    }
    

    Verwenden Sie in C# 8 und höheren Versionen die neue using-Syntax, die keine geschweiften Klammern erfordert:In C# 8 and later versions, use the new using syntax that doesn't require braces:

    using Font font3 = new Font("Arial", 10.0f);
    byte charset3 = font3.GdiCharSet;
    

Die Operatoren && und ||&& and || operators

Vermeiden Sie Ausnahmen und erhöhen Sie die Leistung durch Überspringen unnötiger Vergleiche, indem Sie && anstelle von & und || anstelle von | bei Vergleichen verwenden, wie im folgenden Beispiel gezeigt.To avoid exceptions and increase performance by skipping unnecessary comparisons, use && instead of & and || instead of | when you perform comparisons, as shown in the following example.

Console.Write("Enter a dividend: ");
int dividend = Convert.ToInt32(Console.ReadLine());

Console.Write("Enter a divisor: ");
int divisor = Convert.ToInt32(Console.ReadLine());

if ((divisor != 0) && (dividend / divisor > 0))
{
    Console.WriteLine("Quotient: {0}", dividend / divisor);
}
else
{
    Console.WriteLine("Attempted division by 0 ends up here.");
}

Wenn der Divisor 0 ist, würde die zweite Klausel in der if-Anweisung einen Laufzeitfehler verursachen.If the divisor is 0, the second clause in the if statement would cause a run-time error. Wenn der erste Ausdruck „false“ ist, wird der &&-Operator kurzgeschlossen.But the && operator short-circuits when the first expression is false. Dies bedeutet, dass er den zweiten Ausdruck nicht auswertet.That is, it doesn't evaluate the second expression. Der &-Operator würde beide auswerten, was zu einem Laufzeitfehler führt, wenn divisor gleich 0 ist.The & operator would evaluate both, resulting in a run-time error when divisor is 0.

new-Operatornew operator

  • Verwenden Sie eine der präzisen Formen der Objektinstanziierung, wie in den folgenden Deklarationen gezeigt.Use one of the concise forms of object instantiation, as shown in the following declarations. Das zweite Beispiel zeigt die Syntax, die ab C# 9 verfügbar ist.The second example shows syntax that is available starting in C# 9.

    var instance1 = new ExampleClass();
    
    ExampleClass instance2 = new();
    

    Die vorangehenden Deklarationen entsprechen der folgenden Deklaration.The preceding declarations are equivalent to the following declaration.

    ExampleClass instance2 = new ExampleClass();
    
  • Verwenden Sie Objektinitialisierer, um die Objekterstellung zu vereinfachen, wie im folgenden Beispiel gezeigt.Use object initializers to simplify object creation, as shown in the following example.

    var instance3 = new ExampleClass { Name = "Desktop", ID = 37414,
        Location = "Redmond", Age = 2.3 };
    

    Im folgenden Beispiel werden dieselben Eigenschaften wie im vorangehenden Beispiel festgelegt, dabei aber keine Initialisierer verwendet.The following example sets the same properties as the preceding example but doesn't use initializers.

    var instance4 = new ExampleClass();
    instance4.Name = "Desktop";
    instance4.ID = 37414;
    instance4.Location = "Redmond";
    instance4.Age = 2.3;
    

EreignisbehandlungEvent handling

Wenn Sie einen Ereignishandler definieren, den Sie später nicht entfernen müssen, verwenden Sie einen Lambdaausdruck.If you're defining an event handler that you don't need to remove later, use a lambda expression.

public Form2()
{
    this.Click += (s, e) =>
        {
            MessageBox.Show(
                ((MouseEventArgs)e).Location.ToString());
        };
}

Der Lambdaausdruck verkürzt die folgende herkömmliche Definition.The lambda expression shortens the following traditional definition.

public Form1()
{
    this.Click += new EventHandler(Form1_Click);
}

void Form1_Click(object sender, EventArgs e)
{
    MessageBox.Show(((MouseEventArgs)e).Location.ToString());
}

Statische MemberStatic members

Rufen Sie statische Member über diesen Klassennamen auf: ClassName.StaticMember.Call static members by using the class name: ClassName.StaticMember. Durch diese Empfehlung ist der Code besser lesbar, da der statische Zugriff eindeutig ist.This practice makes code more readable by making static access clear. Qualifizieren Sie keinen statischen Member, der in einer Basisklasse mit dem Namen einer abgeleiteten Klasse definiert ist.Don't qualify a static member defined in a base class with the name of a derived class. Während dieser Code kompiliert wird, ist die Lesbarkeit des Codes irreführend, und der Code kann später beschädigt werden, wenn Sie der abgeleiteten Klasse einen statischen Member mit dem gleichen Namen hinzufügen.While that code compiles, the code readability is misleading, and the code may break in the future if you add a static member with the same name to the derived class.

LINQ-AbfragenLINQ queries

  • Verwenden Sie aussagekräftige Namen für Abfragevariablen.Use meaningful names for query variables. Im folgenden Beispiel wird seattleCustomers für Kunden in Seattle verwendet.The following example uses seattleCustomers for customers who are located in Seattle.

    var seattleCustomers = from customer in customers
                           where customer.City == "Seattle"
                           select customer.Name;
    
  • Verwenden Sie Aliase, um mithilfe der Pascal-Schreibweise sicherzustellen, dass die korrekte Großschreibung von Eigenschaftennamen anonymer Typen verwendet wird.Use aliases to make sure that property names of anonymous types are correctly capitalized, using Pascal casing.

    var localDistributors =
        from customer in customers
        join distributor in distributors on customer.City equals distributor.City
        select new { Customer = customer, Distributor = distributor };
    
  • Benennen Sie Eigenschaften um, wenn die Eigenschaftennamen im Ergebnis nicht eindeutig sind.Rename properties when the property names in the result would be ambiguous. Wenn die Abfrage beispielsweise einen Kundennamen und eine Händler-ID zurückgibt, anstatt sie als Name und ID im Ergebnis beizubehalten, benennen Sie sie um, um zu verdeutlichen, dass Name der Name eines Kunden und ID die ID eines Händlers ist.For example, if your query returns a customer name and a distributor ID, instead of leaving them as Name and ID in the result, rename them to clarify that Name is the name of a customer, and ID is the ID of a distributor.

    var localDistributors2 =
        from customer in customers
        join distributor in distributors on customer.City equals distributor.City
        select new { CustomerName = customer.Name, DistributorID = distributor.ID };
    
  • Verwenden Sie die implizierte Typisierung in der Deklaration von Abfragevariablen und Bereichsvariablen.Use implicit typing in the declaration of query variables and range variables.

    var seattleCustomers = from customer in customers
                           where customer.City == "Seattle"
                           select customer.Name;
    
  • Richten Sie Abfrageklauseln unter der from-Klausel aus, wie in den vorherigen Beispielen gezeigt.Align query clauses under the from clause, as shown in the previous examples.

  • Verwenden Sie vor anderen Abfrageklauseln where-Klauseln, um sicherzustellen, dass nachfolgende Abfrageklauseln für den reduzierten, gefilterten Datensatz ausgeführt werden.Use where clauses before other query clauses to ensure that later query clauses operate on the reduced, filtered set of data.

    var seattleCustomers2 = from customer in customers
                            where customer.City == "Seattle"
                            orderby customer.Name
                            select customer;
    
  • Verwenden Sie mehrere from-Klauseln anstelle einer join-Klausel, um auf die inneren Auflistungen zuzugreifen.Use multiple from clauses instead of a join clause to access inner collections. Eine Auflistung von Student-Objekten kann beispielsweise jeweils eine Auflistung von Testergebnissen enthalten.For example, a collection of Student objects might each contain a collection of test scores. Wenn die folgende Abfrage ausgeführt wird, wird jedes Ergebnis über 90 zusammen mit dem Nachnamen des Studenten zurückgegeben, der das Testergebnis erzielt hat.When the following query is executed, it returns each score that is over 90, along with the last name of the student who received the score.

    var scoreQuery = from student in students
                     from score in student.Scores
                     where score > 90
                     select new { Last = student.LastName, score };
    

SicherheitSecurity

Befolgen Sie die Richtlinien in Richtlinien für das Schreiben von sicherem Code.Follow the guidelines in Secure Coding Guidelines.

Siehe auchSee also