Reihenfolge der Elemente in Klassen: Felder, Eigenschaften, Konstruktoren, Methoden

Gibt es eine offizielle C # -Richtlinie für die Reihenfolge der Elemente in Bezug auf die Klassenstruktur?

Geht es:

• Öffentliche Felder
• Private Felder
• Eigenschaften
• Konstruktoren
• Methoden
  ?

Ich bin gespannt, ob es eine feste Regel für die Reihenfolge der Artikel gibt. Ich bin irgendwie überall. Ich möchte mich an einen bestimmten Standard halten, damit ich ihn überall machen kann.

Das eigentliche Problem ist, dass meine komplexeren Eigenschaften am Ende sehr nach Methoden aussehen und sich oben vor dem Konstruktor fehl am Platz anfühlen.

Irgendwelche Tipps / Vorschläge?

Gemäß der StyleCop-Regeldokumentation ist die Reihenfolge wie folgt.

Innerhalb einer Klasse, Struktur oder Schnittstelle: (SA1201 und SA1203)

• Konstante Felder
• Felder
• Konstruktoren
• Finalizer (Destruktoren)
• Delegierte
• Veranstaltungen
• Aufzählungen
• Schnittstellen ( Schnittstellenimplementierungen )
• Eigenschaften
• Indexer
• Methoden
• Strukturen
• Klassen

Innerhalb jeder dieser Gruppen nach Zugriff sortieren: (SA1202)

• Öffentlichkeit
• intern
• intern geschützt
• geschützt
• Privat

Innerhalb jeder der Zugriffsgruppen nach statisch und dann nicht statisch sortieren: (SA1204)

• statisch
• nicht statisch

Ordnen Sie innerhalb jeder der statischen / nicht statischen Feldgruppen schreibgeschützt und dann nicht schreibgeschützt: (SA1214 und SA1215)

• schreibgeschützt
• nicht schreibgeschützt

Eine abgewickelte Liste ist 130 Zeilen lang, daher werde ich sie hier nicht abrollen. Der entrollte Methodenteil ist:

• öffentliche statische Methoden
• öffentliche Methoden
• interne statische Methoden
• interne Methoden
• geschützte interne statische Methoden
• geschützte interne Methoden
• geschützte statische Methoden
• geschützte Methoden
• private statische Methoden
• private Methoden

In der Dokumentation wird darauf hingewiesen, dass, wenn die vorgeschriebene Reihenfolge nicht geeignet ist - beispielsweise mehrere Schnittstellen implementiert werden und die Schnittstellenmethoden und -eigenschaften zusammengefasst werden sollten -, eine Teilklasse verwendet wird, um die zugehörigen Methoden und Eigenschaften zusammenzufassen.

Wie wäre es mit einer Gruppierung nach Funktionalität, anstatt nach Sichtbarkeit oder nach Elementtyp (Feld, Eigenschaft, Methode usw.) zu gruppieren?

Dies ist eine alte, aber immer noch sehr relevante Frage, daher füge ich Folgendes hinzu: Was ist das Erste, wonach Sie suchen, wenn Sie eine Klassendatei öffnen, die Sie möglicherweise zuvor gelesen haben oder nicht? Felder? Eigenschaften? Ich habe aus Erfahrung festgestellt, dass ich fast immer auf die Jagd nach den Konstruktoren gehe, denn das Grundlegendste, was ich verstehen muss, ist, wie dieses Objekt aufgebaut ist.

Daher habe ich begonnen, Konstruktoren in Klassendateien an die erste Stelle zu setzen, und das Ergebnis war psychologisch sehr positiv. Die Standardempfehlung, Konstruktoren nach einer Reihe anderer Dinge zu setzen, fühlt sich dissonant an.

Die bevorstehende Funktion für Primärkonstruktoren in C # 6 zeigt, dass der natürliche Platz für einen Konstruktor ganz oben in einer Klasse steht. Tatsächlich werden Primärkonstruktoren bereits vor der offenen Klammer angegeben.

Es ist lustig, wie viel Unterschied eine solche Nachbestellung macht. Es erinnert mich daran, wie usingAnweisungen früher bestellt wurden - zuerst mit den System-Namespaces. Der Befehl "Organisieren von Verwendungen" von Visual Studio verwendete diese Reihenfolge. Jetzt sind usings nur noch alphabetisch geordnet, ohne dass System-Namespaces speziell behandelt werden. Das Ergebnis fühlt sich einfach und sauber an.

Ich kenne keine Sprache oder keinen Industriestandard, aber ich neige dazu, die Dinge in diese Reihenfolge zu bringen, wobei jeder Abschnitt in eine # Region eingeschlossen ist:

Verwenden von Anweisungen

Namespace

Klasse

Private Mitglieder

Öffentliche Immobilien

Konstruktoren

Öffentliche Methoden

Private Methoden

Ich würde empfehlen, die Codierungsstandards von IDesign oder die auf der Website von Brad Abram aufgeführten zu verwenden . Das sind die besten zwei, die ich gefunden habe.

Brad würde sagen ...

Das Klassenmitglied sollte alphabetisch sortiert und in Abschnitte gruppiert sein (Felder, Konstruktoren, Eigenschaften, Ereignisse, Methoden, Implementierungen privater Schnittstellen, verschachtelte Typen).

Wie bereits erwähnt, gibt es in der C # -Sprache nichts, was das Layout vorschreibt. Ich persönlich verwende Regionen und mache so etwas für eine durchschnittliche Klasse.

public class myClass
{
#region Private Members

#endregion
#region Public Properties

#endregion

#region Constructors

#endregion
#region Public Methods

#endregion
}

Es macht sowieso Sinn für mich

Von StyleCop

private Felder, öffentliche Felder, Konstruktoren, Eigenschaften, öffentliche Methoden, private Methoden

Da StyleCop Teil des MS-Erstellungsprozesses ist, können Sie dies als De-facto-Standard betrachten

Normalerweise versuche ich, dem nächsten Muster zu folgen:

• statische Elemente (haben normalerweise einen anderen Kontext, müssen threadsicher sein usw.)
• Instanzmitglieder

Jeder Teil (statisch und Instanz) besteht aus den folgenden Elementtypen:

• Operatoren (sind immer statisch)
• Felder (vor Konstruktoren initialisiert)
• Konstruktoren
• Destruktor ( ist eine Tradition, um den Konstrukteuren zu folgen )
• Eigenschaften
• Methoden
• Veranstaltungen

Dann werden die Mitglieder nach Sichtbarkeit sortiert (von weniger zu mehr sichtbar):

• Privat
• intern
• intern geschützt
• geschützt
• Öffentlichkeit

Die Reihenfolge ist kein Dogma: Einfache Klassen sind leichter zu lesen, komplexere Klassen benötigen jedoch eine kontextspezifische Gruppierung.

Ich bevorzuge es, nach Art zu bestellen und dann die Sichtbarkeit wie folgt zu verringern

public methods
public events
public properties

protected methods
protected events
protected properties

private methods
private events
private properties
private fields

public delegates
public interfaces
public classes
public structs

protected delegates
protected interfaces
protected classes
protected structs

private delegates
private interfaces
private classes
private structs

Ich weiß, dass dies gegen Style Cop verstößt, und wenn mir jemand einen guten Grund geben kann, warum ich die Implementierungsdetails eines Typs vor dessen Schnittstelle stellen sollte, bin ich bereit, dies zu ändern. Gegenwärtig habe ich eine starke Präferenz dafür, private Mitglieder an die letzte Stelle zu setzen.

Hinweis: Ich verwende keine öffentlichen oder geschützten Felder.

Am nächsten finden Sie wahrscheinlich "Design Guidelines, Managed Code und .NET Framework" ( http://blogs.msdn.com/brada/articles/361363.aspx ) von Brad Abrams

Viele Standards werden hier beschrieben. Der relevante Abschnitt ist 2.8, denke ich.

Die einzigen Codierungsrichtlinien, die ich dafür vorgeschlagen habe, sind Felder oben in der Klassendefinition.

Ich neige dazu, Konstruktoren als nächstes zu setzen.

Mein allgemeiner Kommentar wäre, dass Sie sich an eine Klasse pro Datei halten sollten. Wenn die Klasse groß genug ist, dass die Organisation von Eigenschaften im Vergleich zu Methoden ein großes Problem darstellt, wie groß ist die Klasse und sollten Sie sie trotzdem umgestalten? Stellt es mehrere Bedenken dar?

Ich ziehe es vor, die privaten Felder zusammen mit den Konstruktoren oben zu platzieren und danach die öffentlichen Schnittstellenbits und dann die privaten Schnittstellenbits zu setzen.

Wenn Ihre Klassendefinition lang genug ist, damit die Reihenfolge der Elemente eine große Rolle spielt, ist dies wahrscheinlich ein Codegeruch, der darauf hinweist, dass Ihre Klasse zu umfangreich und komplex ist und Sie eine Umgestaltung vornehmen sollten.

Ich halte es so einfach wie möglich (zumindest für mich)

Aufzählungen
Erklärungen
Konstrukteurs
Überschreibungen
Methoden
Eigenschaften
Event - Handler

Es gibt sicherlich nichts in der Sprache, was es in irgendeiner Weise erzwingt. Ich neige dazu, Dinge nach Sichtbarkeit zu gruppieren (öffentlich, dann geschützt, dann privat) und #regions zu verwenden, um verwandte Dinge funktional zu gruppieren, unabhängig davon, ob es sich um eine Eigenschaft, eine Methode oder was auch immer handelt. Konstruktionsmethoden (ob tatsächliche ctors oder statische Factory-Funktionen) stehen normalerweise ganz oben, da sie das erste sind, über das Kunden Bescheid wissen müssen.

Ich weiß, dass dies alt ist, aber meine Bestellung lautet wie folgt:

in der Reihenfolge öffentlich, geschützt, privat, intern, abstrakt

• Konstanten
• Statische Variablen
• Felder
• Veranstaltungen
• Konstruktor (en)
• Methoden
• Eigenschaften
• Delegierte

Ich schreibe auch gerne Eigenschaften wie diese aus (anstelle des Kurzansatzes)

// Some where in the fields section
private int someVariable;

// I also refrain from
// declaring variables outside of the constructor

// and some where in the properties section I do
public int SomeVariable
{
    get { return someVariable; }
    set { someVariable = value; }
}