Wie ordnen Sie normalerweise die Regionen einer Klasse an?

Ich habe mich gefragt, ob es einen Standard für die Anordnung der Regionen einer Klasse gibt.

Ich benutze derzeit

Fields
Constructor
Properties
Public Methods
Private Methods

Fieldsals Privateigentum und Propertiesals öffentliches Eigentum. Normalerweise verwende ich Subregionen innerhalb dieser, falls erforderlich, oder füge gelegentlich andere Regionen darunter hinzu (z. B. Interface- oder BaseClass-Mitglieder).

Klassenbezogene Aufzählungen oder gelegentlich Strukturen / reine Datenklassen (oberhalb der tatsächlichen Klassendefinition)

--- Klassendefinition ---

Private Mitglieder

CTORs / DTORs, wenn die Sprache DTORs hat

Öffentliche Objekte

Dienstprogrammmethoden (private oder geschützte Methoden mit kleinem Umfang)

Klassenfunktionalität (Kann je nach Umfang der Klasse in mehrere Regionen unterteilt werden).

Unterregionen? Hat Ihre Klasse eine Einzelverantwortung ? (implizit ... meine Antwort lautet "Selten irgendwelche Regionen, außer vielleicht um Eigenschaften, Konstruktoren und Methoden zu gruppieren" ... aber selbst dann benutze ich es nicht so oft.)

Ich wollte nur bestätigen, dass Sie "#regions" und nicht das Klassenlayout im Allgemeinen meinten.

Ich bin überrascht, dass niemand erwähnt hat, um die Verwendung von Regionen zu vermeiden. Ich verstehe, dass das OP eine Umfrage zum Layout von Regionen durchführen möchte, aber ich möchte einen alternativen Standpunkt ansprechen.

Ich vermeide Regionen. Ich sehe gerne den Code, mit dem ich arbeite. Wenn Sie Schwierigkeiten haben, das Gesuchte zu finden, verwenden Sie Code Folding und gruppieren Sie ähnliche Klassenkonstrukte.

Warum hasse ich Regionen? CTRL+M,Lund CTRL+M,Oschaltet die Codefaltung um. Beim Zusammenklappen wird jedoch die gesamte Region ausgeblendet. Ich muss nur Methoden / Eigenschaften / Kommentare reduzieren.

Wenn es zu viele Regionen gibt, riecht es vielleicht nach Code und Ihre Klasse leistet zu viel Arbeit. Jeff Atwood bietet einen guten Beitrag zu Regionen, die es wert sind, gelesen zu werden.

Mein Lieblingszitat zu #regions:

Nein, ich werde keine #regions verwenden. Und nein, ich verhandele nicht mit Terroristen. Halte den Mund, halt den Rand, Halt die Klappe.

- Jeff Atwood

Trotzdem weiß ich, dass viele Programmierer darauf bestehen, sie zu verwenden. Diese Frage ist subjektiv. Ich hatte nur gedacht, ich würde eine Alternative anbieten.

Es variiert von Sprache zu Sprache. Da ich ein Delphi-Codierer bin, folge ich normalerweise der Delphi-Standardkonvention, die so aussieht:

type
  TMyClass = class(TBaseClass)
  private
    private fields
    private methods
  protected
    protected fields
    protected methods
    protected properties
  public
    constructor(s)
    destructor
    public methods
    public properties
  end;

Ich finde es eine gute Möglichkeit, Informationen zu organisieren, die einfach zu lesen und zu verstehen sind.

Ich neige dazu, sie folgendermaßen zu gestalten:

Public fields (usually static constants)
Constructors
Public methods
Private methods
Private fields

Habe keine Sprache benutzt Properties, die benutzt wird , deshalb sind diese nicht angelegt. Ich setze private Methoden und Felder ganz unten, denn wenn jemand anderes diese Datei in seinem Code verwendet, sollte er sich nur mit der API befassen müssen, die das öffentliche Zeug ist. Alle mir bekannten Texteditoren und sogar IDEs setzen den Cursor beim Öffnen von Dateien ganz oben.

Es ist ein Urteilsspruch für mich. Ich benutze Regionen, wenn sie für die Lesbarkeit benötigt werden.

Ich verwende auch eine andere Farbe in meinem Visual Studio-Farbschema (derzeit ein Dunkelrot), um sie vom Rest des Codes abzuheben.

Ein Beispiel für die Verwendung einer #region: Wenn ich eine Testmethode für einen Komponententest schreibe, für den ein mehrzeiliges XML-Snippet erforderlich ist, unterbricht der XML-String den üblichen Einzug (da er am linken Rand von beginnt) Um die Hässlichkeit zu verbergen, werde ich es in eine #Region verpacken, damit ich es zusammenklappen kann.

Bob Martins Clean Code- Buch widmet sich im gesamten 5. Kapitel der Formatierung. Es gibt ein paar wichtige Punkte, die meiner Meinung nach gut zusammengefasst sind.

• Die meisten Versuche, Variablen und Methoden nach Sichtbarkeit und Sauberkeit zu gruppieren, ergeben wenig Sinn und führen dazu, dass Sie häufig im Code navigieren.
• Indem Sie Methoden, die sich vertikal aufrufen, eng zusammenhalten, reduzieren Sie den Navigationsaufwand und erleichtern das Auffinden von Objekten.
• Ihr Gedankengang wird nicht unterbrochen, wenn Sie anhalten und sich überlegen müssen, in welche Region dieser Code gehört. alle paar Minuten.
• Instanzvariablen sollten normalerweise wenige sein und wahrscheinlich überall verwendet werden, daher gehören sie an die Spitze der Klasse, wo sie am einfachsten zu finden sind. Variablen und Deklarationen, die nur von einer Methode verwendet werden, müssen in dieser Methode vorhanden sein. Wenn sie nur von wenigen Methoden verwendet werden, sollten sie vertikal nahe beieinander liegen, jedoch über den wenigen Methoden, die sie verwenden.

Indem Sie Ihren Code mit häufig wechselwirkenden Elementen vertikal dicht nebeneinander anordnen, müssen Sie keine bestimmten Bereiche erstellen. Wenn Ihr Code so lang ist, dass Regionen viel Code verbergen müssen, ist dies möglicherweise ein Codegeruch, der darauf hinweist, dass die Klasse versucht, zu viel zu tun. Möglicherweise kann ein Teil der Funktionalität in eine Utility-Klasse verschoben oder an einen Vorfahren übertragen werden.

Wenn Sie den Code "verstecken" müssen, weil er zu lang oder zu "hässlich" ist, haben Sie wahrscheinlich größere Probleme, als sich Gedanken darüber zu machen, ob Sie Regionen verwenden sollen oder nicht. Persönlich muss ich sie nie verwenden, und wenn ich an dem Code eines anderen arbeite, muss ich sie sowieso immer alle öffnen. Warum also die Mühe machen?

Ich habe derzeit Layout-Klassen wie folgt:

class types
constructors
destructor
accessors
methods
properties (where properties are present in the language)
member variables

und dann die Zugriffsebene jeder Deklaration voranstellen (Art, manchmal nach Zugriff gruppieren). Früher habe ich Gruppierungen nach Zugriff auf oberster Ebene durchgeführt, aber irgendwann weiß ich nicht, wann, es hat nicht ganz so gut funktioniert wie oben. Zum Beispiel in C ++ / CLI (wozu ich momentan gezwungen bin :-() können Sie dies tun, was die Gruppierung nach Zugriff durcheinander bringt:

public: property int SomeProperty
{
private: void set (int value) { ... }
public: int get () { ... }
}

Wahnsinnige Randantwort: Das tue ich nicht, zumindest wenn es um C # geht. Zwischen Visual Studio und R # kann ich auf magische Weise zu jedem Mitglied oder jeder Implementierung navigieren, sodass es keinen Grund gibt, über dieses Zeug nachzudenken. fang einfach an zu tippen, wo der Cursor ist.

Wie Wyatt und einige andere Antworten vermeide ich auch generell die Verwendung von Regionen. Regionen haben einen Zweck; um Code zu verstecken, muss man sich nicht umsehen. Wenn Sie in einer Klasse viel Code haben, den Sie sich nicht ansehen müssen, und Sie daher viele Regionen benötigen, um den Code zu reduzieren, dann haben Sie wahrscheinlich zu viel Code in der Klasse. ReSharper berücksichtigt Regionen nicht, wenn entschieden wird, wo neuer Code abgelegt werden soll, es sei denn, es hat die Region erstellt (was bei Schnittstellenimplementierungen der Fall ist).

Die einzige Verwendung von Regionen, die ich für akzeptabel halte, besteht darin, "unvermeidlich hässlichen" Code zu verbergen. Code, der sich mit spezifischen Implementierungsdetails befasst, die nach den aktuellen Standards intern nicht gut strukturiert werden können. Dies ist in der Regel fortgeschrittener, esoterischer Code, mit dem ein durchschnittlicher Junior-Programmierer nach dem Schreiben im Allgemeinen nichts anfangen sollte. Dies sind Dinge wie:

• Bestimmte integrierte Schnittstellenimplementierungen (IDisposable, IConvertible, manchmal IEnumerable oder IComparable, da sie generische und nicht generische Implementierungen erfordern)
• Eingebettete P / Invoke-Externe und verwandte Strukturen.
• Finalizer / Destruktoren (normalerweise mit IDisposable)
• Hooks zu nicht verwaltetem Speicher / Zeigern / "unsicherem" Code.