Welche Namenskonvention für C # -Funktionsparameter zu verwenden ist

Es gibt Situationen, in denen ein in Parameter übergebener Name in einen neuen Typ umgewandelt wird, der Name des übergebenen Objekts jedoch ähnlich bleiben sollte. Für den Fall von Klassenattributen können wir diesen Operator verwenden, aber was ist mit lokalen Variablen in Funktionen? Welche Kodierungskonvention ist weit verbreitet.

Beispiel,

void MyFunc(BaseClass myPara)
{
  DerivedClass _mypara = (BaseClass)myPara;
}

oder im gegenteil

void MyFunc(BaseClass _myPara)
{
  DerivedClass mypara = (BaseClass)_myPara;
}

oder andere Konventionen

Das Präfixieren von Parametern oder lokalen Variablen mit einem Unterstrich ist in C # nicht sehr idiomatisch, es ist nicht sehr einfach zu lesen und wird nicht oft verwendet (obwohl es legal ist, können Sie dies also tun, wenn Sie möchten).

Der beste Name für den Parameter und die Variable ist ein beschreibender Name. Sie müssen sich überlegen, warum Sie den Typ ändern, was der Grund für die Besetzung ist. Dann sollten Sie in der Lage sein, 2 verschiedene Namen zu finden. Wenn Sie beispielsweise eine "Person" übergeben und in einen "Kunden" konvertiert haben, können Sie in den Variablennamen möglicherweise "Person" und / oder "Kunde" verwenden.

Wenn Ihnen wirklich keine zwei verschiedenen Namen einfallen, würde ich "as" im Namen verwenden (dazu gab es vor einigen Tagen eine Frage auf dieser Site ). Beispielsweise würden Sie "myParaAsDerived" für die lokale Variable verwenden.

Wenn es überhaupt möglich ist, würde ich dies nicht verwenden, und ich würde mir überlegen, welches Problem Sie lösen und welche aussagekräftigen Namen verwendet werden könnten. Wenn alles andere fehlschlägt, ist dies ziemlich lesbar.

Erstens mit

void MyFunc(BaseClass _myPara)
{
} 

Ist eindeutig falsch! Da viele C # -Codierungsstandards ein "_" -Präfix für alle Feldnamen verwenden ! Ihr Code muss für andere Programmierer leicht verständlich sein, daher sollte Code nicht so geschrieben werden, dass viele C # -Programmierer in die Irre geführt werden.

In Anbetracht all die Vorteile der kleinen Methoden, ich persönlich sehe keine Notwendigkeit für eine Namenskonvention lokale Variablen von Parametern zu trennen. Wenn Ihre Methoden über so viele Parameter und lokale Variablen verfügen, dass Sie ohne Namenskonvention nicht sagen können, was vor sich geht, treten größere Probleme auf. (Dies wird im Clean Code Book , einem Java-Buch, gut behandelt , aber ich fand es als C # -Programmierer immer noch von großem Nutzen.)

Wenn Sie ihnen etwas voranstellen möchten, sollten Sie p_als Parameter verwenden: Im Allgemeinen würden Sie wahrscheinlich viele Leute ärgern, wenn Sie dies tun. ABER seien Sie konsequent, tun Sie es nicht nur an einem Ort, nur weil Sie zwei verschiedene Namen für Variablen benötigen, denen Sie den gleichen Namen geben möchten.

Eine gute allgemeine Regel für die Benennung von Variablen lautet wie folgt:

• Wenn Sie nur einen Objekttyp haben, benennen Sie ihn nach seiner Funktion:

  var builder = new PizzaBuilder();

• Wenn Sie mehrere Namen nach Funktion und Spezialisierung haben:

  var pizzaBuilder = new PizzaBuilder();
  var milkShakeBuilder = new MilkShakeBuilder();

Mit C # -Namenskonventionen haben Sie:

• Verwenden von PascalCasing für Methoden, öffentliche Eigenschaften und Klassennamen
• Verwenden von IPascalCasing (beachten Sie das I am Anfang) für Schnittstellennamen
• Verwendung von camelCasing für Methodenparameter und lokale Variablen
• Verwenden von _underscoredCamelCasing für klassenweite private Felder

Und bitte halten Sie sich von der ungarischen Notation fern. Es ist sinnlos und entspricht nicht den C # -Konventionen.

Das Unterstreichen bei der Benennung von Variablen kann unnötig sein, da wir das Schlüsselwort "this" haben, um spezifisch auf Variablen auf Klassenebene zu verweisen. Wenn Sie mehr über Variablennamenskonventionen von Experten erfahren möchten, empfehlen wir Ihnen einen Blick auf das berüchtigte Papier "Ottingers Regeln für Variablen- und Klassennamen" von Tim Ottinger, ein Artikel, der von dem Mentor für saubere Codierung, Robert C. Martin, unterstützt wird .

Ottinger sagt, dass Ihr Code so gut wie möglich lesbar bleiben muss, wie gut geschriebene Prosa, also ...

public void Function(string p_Parameter1, string p_Parameter2)

... wäre lesbarer als ...

public void Function(string parameter1, string parameter2)

... wobei Parameter1 und 2 beschreibende Namen für die entsprechenden Variablen sind.

Hier ist der Link, auf jeden Fall einen Blick wert: Link

Ich glaube an das Suffixieren von Parametern: string s_, int i_, etc

Ich glaube auch, dass die Parmnamen so kurz und allgemein wie möglich sein sollten.

Nun zu den Gründen:

• In der Funktion möchten Sie den Parameter in keiner Weise ändern. Wenn Sie eine geänderte Version benötigen, erstellen Sie eine neue Variable, um sie einzufügen. Durch die Benennung von Parametern mit einem Suffix wird sichergestellt, dass Sie sie nicht zuweisen, wenn Sie bezahlen Beachtung.
• Ausnahmen von dieser Regel gibt es, wenn der Parm ref oder out ist. Allerdings benutze ich immer noch das Suffix.
• Warum kurze Gattungsnamen? Sie sollten Ihre Funktion dokumentieren, damit Sie wissen, was s_ wirklich im beschreibenden Sinne ist. Auf diese Weise ist es praktisch, kurze Generika zu verwenden, wenn Sie Gruppen ähnlicher Funktionen erstellen oder einen Funktionskörper beschneiden, um ihn als Ausgangspunkt für Änderungen zu einer anderen Funktion zu transportieren.
• Der eigentliche Vorteil von generischen Namen besteht darin, dass Sie sich in den meisten Fällen nicht daran erinnern müssen, wie Sie diesen Parameter genannt haben. Sie wissen, dass Sie eine Zeichenfolge abrufen, also s_ usw., und müssen sich nicht fragen, ob es sich um 'Dateiname' oder 'Dateipfad' oder 'vollständiger Pfad' handelt. Es ist die einzige Zeichenfolge, also 's_'.

Alles hat Nachteile, und ob Sie etwas verwenden oder nicht, hängt stark davon ab, wie es in Ihren aktuellen Stil passt.