Konwencja nazewnictwa - podkreślenie w zmiennych C ++ i C #


146

Często spotyka się _varnazwę zmiennej w polu klasy. Co oznacza podkreślenie? Czy istnieje odniesienie do wszystkich tych specjalnych konwencji nazewnictwa?



17
Niektóre błędne korporacyjne wytyczne dotyczące kodowania sugerują dodawanie brodawek do zmiennych składowych, aby odróżnić je od zmiennych lokalnych, z przekonania, że ​​klasy i funkcje nieuchronnie rozrosną się do tego stopnia, że ​​nie można śledzić tego, co jest bez takich niejasnych wskazówek. Ludzie, którzy sugerują takie konwencje, zbyt często są tymi, których kod najbardziej ich potrzebuje.
Mike Seymour

26
@Mike - Twoje ogólne stwierdzenie po prostu nie jest prawdziwe. Zauważyłem, że używanie tej konwencji znacznie ułatwia szybkie skanowanie metod i dobre zrozumienie klasy.
ChaosPandion

12
@ChaosPandion: nie czytaj tego jako ogólnej instrukcji. „Niektórzy” nie oznaczają „wszystkich”, a „zbyt często” nie znaczy „zawsze”, a może jesteś wyjątkiem od mojego doświadczenia.
Mike Seymour

17
W C ++ unikaj wiodących podkreśleń. W wielu kontekstach (tj. W zasięgu globalnym, gdy następuje duża litera itp.) Są one zarezerwowane dla implementacji i tak naprawdę ryzykujesz, że zdepczą je jakieś makro. Więc jeśli ich potrzebujesz, umieść je jako końcowe podkreślenia .
sbi

Odpowiedzi:


120

Podkreślenie to po prostu konwencja; nic więcej. W związku z tym jego użycie jest zawsze nieco inne dla każdej osoby. Oto, jak rozumiem je w tych dwóch językach:

W C ++ podkreślenie zwykle oznacza prywatną zmienną składową.

W C # zwykle widzę, że jest używany tylko podczas definiowania podstawowej zmiennej składowej prywatnej dla właściwości publicznej. Inne zmienne składowe prywatne nie miałyby podkreślenia. To użycie w dużej mierze odeszło jednak na bok wraz z pojawieniem się automatycznych właściwości.

Przed:

private string _name;
public string Name
{
    get { return this._name; }
    set { this._name = value; }
}

Po:

public string Name { get; set; }

11
Z wyjątkiem zespołów, które chcą, aby ich właściwości były niezmienne.
ChaosPandion

11
Identyfikatory zaczynające się od podkreślenia są zarezerwowane dla kompilatora. Używanie podkreślenia przedrostków może powodować konflikt z symbolami kompilatora.
Thomas Matthews

12
@Thomas Matthews - nie w C #.
EMP

11
@ChaosPandion Zakładam, że to, co masz na myśli przez „niezmienny”, jest w rzeczywistości „tylko do odczytu”, w takim przypadku można użyć public string Name { get; private set; }. To prawda, że ​​nie jest całkowicie niezmienny, ale istnieje.
jdmichal

7
@Thomas W kontekście klasowym identyfikatory rozpoczynające się od podkreślenia, po którym następuje duża litera zastrzeżona w C ++. _varnie jest zastrzeżone.
Tyler McHenry,

84

Najlepszą praktyką jest NIEUŻYWANIE PODNOŚNIKÓW przed jakąkolwiek nazwą zmiennej lub nazwą parametru w C ++

Nazwy zaczynające się od podkreślenia lub podwójnego podkreślenia są ZAREZERWOWANE dla osób wdrażających C ++. Nazwy z podkreśleniem są zarezerwowane dla biblioteki.

Jeśli przeczytałeś C ++ Coding Standard, zobaczysz, że na pierwszej stronie jest napisane:

„Nie przesadzaj z nazewnictwem, ale stosuj spójną konwencję nazewnictwa: są tylko dwie rzeczy do zrobienia: a) nigdy nie używaj„ podstępnych nazw ”, zaczynających się od podkreślenia lub zawierających podwójne podkreślenie; (p2, Standardy kodowania C ++, Herb Sutter i Andrei Alexandrescu)

Dokładniej, projekt roboczy ISO określa rzeczywiste zasady:

Ponadto niektóre identyfikatory są zarezerwowane do użytku przez implementacje C ++ i nie powinny być używane w inny sposób; nie jest wymagana żadna diagnostyka. (a) Każdy identyfikator, który zawiera podwójne podkreślenie __ lub zaczyna się od podkreślenia, po którym następuje duża litera, jest zarezerwowany dla implementacji do dowolnego użytku. (b) Każdy identyfikator, który zaczyna się od podkreślenia, jest zarezerwowany dla implementacji do użycia jako nazwa w globalnej przestrzeni nazw.

Najlepszą praktyką jest unikanie rozpoczynania symbolu od podkreślenia, na wypadek gdybyś przypadkowo znalazł się w jednym z powyższych ograniczeń.

Sam możesz się przekonać, dlaczego takie użycie podkreśleń może być katastrofalne w przypadku tworzenia oprogramowania:

Spróbuj skompilować prosty program helloWorld.cpp w następujący sposób:

g++ -E helloWorld.cpp

Zobaczysz wszystko, co dzieje się w tle. Oto fragment:

   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       __streambuf_type* __sb = this->rdbuf();
       if (__sb)
  {
    if (__sb->pubsync() == -1)
      __err |= ios_base::badbit;
    else
      __ret = 0;
  }

Możesz zobaczyć, ile nazw zaczyna się od podwójnego podkreślenia!

Ponadto, jeśli spojrzysz na wirtualne funkcje składowe, zobaczysz, że * _vptr jest wskaźnikiem wygenerowanym dla wirtualnej tabeli, który jest automatycznie tworzony, gdy używasz jednej lub więcej wirtualnych funkcji składowych w swojej klasie! Ale to już inna historia ...

Jeśli użyjesz podkreśleń, możesz mieć problemy z konfliktem i NIE MASZ POMYSŁU, co go powoduje, dopóki nie będzie za późno.


4
Czy nazwy, które nie są globalne lub nie mają zasięgu pliku i zaczynają się od podkreślenia i małej litery, są w porządku? Robię to cały czas, ponieważ jest bardzo czysty w określonych przypadkach, np .: void A :: set_size (int _size) {size = _size; }. Co robisz dla tak trywialnych zastosowań?
tukra

3
Uważam, że podkreślenie, po którym następuje mała litera, jest dozwolone w zakresie nieglobalnym / pliku. Czy możesz mi pokazać, gdzie w standardzie mówi, że nie jest? Problem z końcowym podkreśleniem polega na tym, że czasami używam go już dla zmiennych składowych. Więc mógłbym mieć funkcję 'int size ();' zmienna składowa 'int size_;' i argument „int _size”. To zwykle ładnie pokrywa rzeczy i nie widziałem lepszych alternatyw. Funkcje uruchamiane wielkimi literami nie są możliwe w przypadku typów ogólnych, które działają z STL. Styl „this.size”, który lubią ludzie C #, wydaje mi się podatny na błędy, chyba że zawsze używasz go do dostępu do członków, co jest brzydkie.
tukra

7
Rozumiem, że niektórzy ludzie nie chcą używać podkreślenia i małej litery, ponieważ mogą mieć problem z wyjaśnieniem, co jest legalne. Standard C ++ pozwala na to, nawet jeśli niektórzy autorzy nie zalecają jego używania. Dla mnie, ponieważ jest to w pełni legalne i niezastrzeżone, nie widzę powodu, aby uważać to za ryzykowne. Dziękuję za twój komentarz.
tukra

3
@tukra: To nie jest w pełni legalne. Standard C ++ zezwala tylko na użycie pojedynczego podkreślenia, po którym następuje mała litera w zakresie lokalnym. Powodzenia! :-)
Constantinos Glynos

4
Przepraszam. Myślałem, że nie trzeba już powtarzać kwalifikacji. Identyfikator C ++ zaczynający się od podkreślenia, po którym następuje mała litera, jest dozwolony w każdym zakresie innym niż zakres plików. Jest bezpieczny i legalny w funkcjach, prototypach funkcji, klasach, strukturach, uniach, wyliczeniach i wszystkim, co umieścisz w przestrzeni nazw. Jeśli zastosujesz się do powszechnej praktyki umieszczania całego kodu w przestrzeniach nazw, będziesz całkowicie bezpieczny.
tukra

45

Właściwie _varkonwencja pochodzi z VB, a nie z C # czy C ++ (m _, ... to inna sprawa).

Pozwoliło to przezwyciężyć niewrażliwość VB na wielkość liter podczas deklarowania właściwości.

Na przykład, taki kod nie jest możliwe w VB, ponieważ uważa, useri Userjako taki sam identyfikator

Private user As String

Public Property User As String
  Get
    Return user
  End Get
  Set(ByVal Value As String)
    user = value
  End Set
End Property

Aby temu zaradzić, niektórzy używali konwencji dodawania „_” do pola prywatnego, aby uzyskać taki efekt

Private _user As String

Public Property User As String
  Get
    Return _user
  End Get
  Set(ByVal Value As String)
    _user = value
  End Set
End Property

Ponieważ wiele konwencji dotyczy .Net i aby zachować pewną jednolitość między konwencjami C # i VB.NET, używają one tej samej.

Znalazłem odniesienie do tego, co mówiłem: http://10rem.net/articles/net-naming-conventions-and-programming-standards---best-practices

Etui Camel z wiodącym podkreśleniem. W VB.NET zawsze zaznaczaj „Chroniony” lub „Prywatny”, nie używaj „Dim”. Używanie "m_" jest odradzane, podobnie jak używanie nazwy zmiennej, która różni się od właściwości tylko wielkością liter, szczególnie w przypadku zmiennych chronionych, ponieważ narusza to zgodność i sprawi, że twoje życie będzie bólem, jeśli będziesz programować w VB.NET, ponieważ musiałby nadać członkom inną nazwę niż właściwości akcesora / mutatora. Ze wszystkich przedstawionych tutaj elementów, wiodące podkreślenie jest tak naprawdę jedynym kontrowersyjnym. Osobiście wolę to od prostych, pozbawionych podkreślenia wielbłądów dla moich zmiennych prywatnych, więc nie muszę kwalifikować nazw zmiennych za pomocą „this”. odróżnić od parametrów w konstruktorach lub w innych miejscach, gdzie prawdopodobnie wystąpi kolizja nazw. Przy niewrażliwości na wielkość liter w VB.NET jest to jeszcze ważniejsze, ponieważ właściwości akcesorium zwykle mają taką samą nazwę, jak prywatne zmienne składowe, z wyjątkiem podkreślenia. Jeśli chodzi o m_, to tak naprawdę chodzi tylko o estetykę. Ja (i wielu innych) uważam, że m_ jest brzydki, ponieważ wygląda na to, że w nazwie zmiennej jest dziura. To prawie obraźliwe. Używałem go cały czas w VB6, ale to tylko dlatego, że zmienne nie mogły mieć wiodącego podkreślenia. Nie mogłem być szczęśliwszy, widząc, jak to odchodzi. Firma Microsoft odradza m_ (i prostą _), mimo że zrobili to w swoim kodzie. Również prefiks z prostym „m” jest od razu skuteczny. Oczywiście, ponieważ kodują głównie w C #, mogą mieć prywatnych członków różniących się tylko wielkością liter od właściwości. Ludzie VB muszą zrobić coś innego. Zamiast próbować wymyślać przypadki specjalne dla poszczególnych języków, polecam wiodące podkreślenie dla wszystkich języków, które będą go obsługiwać. Jeśli chcę, aby moja klasa była w pełni zgodna z CLS, mógłbym pominąć prefiks na dowolnej chronionej C # zmiennej składowej. W praktyce jednak nigdy się tym nie martwię, ponieważ zachowuję wszystkie potencjalnie chronione zmienne składowe jako prywatne, a zamiast tego dostarczam chronione metody dostępu i mutatory. Dlaczego: w skrócie, ta konwencja jest prosta (jeden znak), łatwa do odczytania (twoje oko nie jest rozpraszane przez inne wiodące znaki) i skutecznie pozwala uniknąć kolizji nazw ze zmiennymi na poziomie procedury i właściwościami na poziomie klasy. Właściwości na poziomie klasy . Polecam wiodące podkreślenie dla wszystkich języków, które będą go wspierać. Jeśli chcę, aby moja klasa była w pełni zgodna z CLS, mógłbym pominąć prefiks na dowolnej chronionej C # zmiennej składowej. W praktyce jednak nigdy się tym nie martwię, ponieważ zachowuję wszystkie potencjalnie chronione zmienne składowe jako prywatne, a zamiast tego dostarczam chronione metody dostępu i mutatory. Dlaczego: w skrócie, ta konwencja jest prosta (jeden znak), łatwa do odczytania (twoje oko nie jest rozpraszane przez inne wiodące znaki) i skutecznie pozwala uniknąć kolizji nazw ze zmiennymi na poziomie procedury i właściwościami na poziomie klasy. Właściwości na poziomie klasy . Polecam wiodące podkreślenie dla wszystkich języków, które będą go wspierać. Jeśli chcę, aby moja klasa była w pełni zgodna z CLS, mógłbym pominąć prefiks na dowolnej chronionej C # zmiennej składowej. W praktyce jednak nigdy się tym nie przejmuję, ponieważ zachowuję wszystkie potencjalnie chronione zmienne składowe jako prywatne i zamiast tego dostarczam chronione metody dostępu i mutatory. Dlaczego: w skrócie, ta konwencja jest prosta (jeden znak), łatwa do odczytania (twoje oko nie jest rozpraszane przez inne wiodące znaki) i skutecznie pozwala uniknąć kolizji nazw ze zmiennymi na poziomie procedury i właściwościami na poziomie klasy. Właściwości na poziomie klasy . Nigdy się tym nie martwię, ponieważ zachowuję wszystkie potencjalnie chronione zmienne składowe jako prywatne, a zamiast tego dostarczam chronione akcesory i mutatory. Dlaczego: w skrócie, ta konwencja jest prosta (jeden znak), łatwa do odczytania (twoje oko nie jest rozpraszane przez inne wiodące znaki) i skutecznie pozwala uniknąć kolizji nazw ze zmiennymi na poziomie procedury i właściwościami na poziomie klasy. Właściwości na poziomie klasy . Nigdy się tym nie martwię, ponieważ zachowuję wszystkie potencjalnie chronione zmienne składowe jako prywatne, a zamiast tego dostarczam chronione akcesory i mutatory. Dlaczego: w skrócie, ta konwencja jest prosta (jeden znak), łatwa do odczytania (twoje oko nie jest rozpraszane przez inne wiodące znaki) i skutecznie pozwala uniknąć kolizji nazw ze zmiennymi na poziomie procedury i właściwościami na poziomie klasy. Właściwości na poziomie klasy .


6

Pierwszy komentator (R Samuel Klatchko) wspomniał: Jakie są zasady dotyczące używania podkreślenia w identyfikatorze C ++? który odpowiada na pytanie o podkreślenie w C ++. Ogólnie rzecz biorąc, nie powinieneś używać początkowego podkreślenia, ponieważ jest on zarezerwowany dla implementującego twój kompilator. Kod, z którym widzisz, _varjest prawdopodobnie kodem starszym lub kodem napisanym przez kogoś, kto dorastał przy użyciu starego systemu nazewnictwa, który nie marszczył brwi na widok wiodących znaków podkreślenia.

Jak podają inne odpowiedzi, był używany w C ++ do identyfikowania zmiennych składowych klasy. Jednak nie ma to specjalnego znaczenia, jeśli chodzi o dekoratory lub składnię. Więc jeśli chcesz go użyć, skompiluje się.

Zostawię dyskusję C # innym.


5

_var nie ma znaczenia i służy jedynie do ułatwienia rozróżnienia, że ​​zmienna jest prywatną zmienną składową.

W C ++ używanie konwencji _var jest złą formą, ponieważ istnieją reguły regulujące użycie znaku podkreślenia przed identyfikatorem. _var jest zarezerwowany jako identyfikator globalny, podczas gdy _Var (podkreślenie + duża litera) jest zarezerwowany w dowolnym momencie. Dlatego w C ++ zobaczysz ludzi używających konwencji var_.


4

Możesz stworzyć własne wytyczne dotyczące kodowania. Po prostu napisz jasną dokumentację dla reszty zespołu.

Użycie _field pomaga Intelilsense w filtrowaniu wszystkich zmiennych klas po prostu wpisując _.

Zwykle postępuję zgodnie z wytycznymi Brada Adamsa , ale odradzam używanie podkreślenia.


2

Nazewnictwie standardem Microsoft C # mówi zmienne i parametry powinny stosować małe liter wielbłąd tj paramName . Norma wymaga również pola podążać taką samą formę, ale może to prowadzić do kodu niejasnej tak wiele zespołów wezwać do prefiksu podkreślenia, aby poprawić jasność tj _fieldName .


2

W przypadku języka C # wytyczne dotyczące projektu Microsoft Framework sugerują, aby nie używać znaku podkreślenia dla członków publicznych . W przypadku członków prywatnych podkreślenia są dopuszczalne. W rzeczywistości Jeffrey Richter (często cytowany w wytycznych) używa na przykład m_ i „s_” dla prywatnych statycznych członków.

Osobiście używam tylko _ do oznaczania moich prywatnych członków. „m_” i „s_” graniczą z notacją węgierską, która jest nie tylko mile widziana w .NET, ale może być dość rozwlekła i uważam, że klasy z wieloma członkami są trudne do wykonania szybkiego skanowania oczu alfabetycznie (wyobraź sobie 10 zmiennych, wszystkie zaczynające się od m_) .


Ponieważ notacja węgierska wskazuje typ, nie sądzę, aby można było powiedzieć, że m / s jest na skraju.
Jerry Nixon

@ JerryNixon-MSFT Czy identyfikujemy zmienny typ danych i zmienny typ widoczności jako to samo, jeśli chodzi o węgierskie pojęcie?
Necro

1

Używam nazewnictwa _var dla zmiennych składowych moich klas. Są dwa główne powody, dla których robię:

1) Pomaga mi śledzić zmienne klasowe i lokalne zmienne funkcyjne podczas późniejszego czytania kodu.

2) Pomaga w Intellisense (lub innym systemie uzupełniania kodu), gdy szukam zmiennej klasy. Znajomość pierwszego znaku jest pomocna w przefiltrowaniu listy dostępnych zmiennych i metod.


1
W przypadku większej metody jest kłopotliwe poleganie na funkcji IntelliSense lub skanowaniu w celu sprawdzenia, czy zmienna jest zdefiniowana lokalnie, czy nie. Preferuj także „__” do statyki z tych samych powodów, o których wspominasz, ale obecnie nie jest to korzystne.
crokusek

1

Jeśli chodzi o języki C i C ++, podkreślenie w nazwie nie ma specjalnego znaczenia (początek, środek lub koniec). To tylko prawidłowy znak nazwy zmiennej. „Konwencje” pochodzą z praktyk kodowania w ramach społeczności programistów.

Jak już wskazano w różnych przykładach powyżej, _ na początku może oznaczać prywatnych lub chronionych członków klasy w C ++.

Podam tylko historię, która może być zabawną ciekawostką. W systemie UNIX, jeśli masz podstawową funkcję biblioteki C i zaplecze jądra, w którym chcesz udostępnić funkcję jądra w przestrzeni użytkownika, znak _ utknie przed funkcją pośredniczącą funkcji, która bezpośrednio wywołuje funkcję jądra, nie robiąc nic innego. Najbardziej znanym i znanym przykładem tego jest exit () vs _exit () w jądrach typu BSD i SysV: Tutaj exit () wykonuje operacje w przestrzeni użytkownika przed wywołaniem usługi wyjścia jądra, podczas gdy _exit po prostu mapuje na usługę wyjścia jądra.

Tak więc _ zostało użyte dla rzeczy „lokalnych”, w tym przypadku lokalnie lokalna dla maszyny. Zazwyczaj funkcja _functions () nie była przenośna. W związku z tym nie należy oczekiwać takiego samego zachowania na różnych platformach.

Teraz co do _ w nazwach zmiennych, takich jak

int _foo;

Z psychologicznego punktu widzenia _ jest dziwną rzeczą, którą trzeba wpisywać na początku. Więc jeśli chcesz utworzyć nazwę zmiennej, która miałaby mniejsze szanse na kolizję z czymś innym, SZCZEGÓLNIE w przypadku zastępowania preprocesorów, które chcesz, rozważ użycie _.

Moja podstawowa rada jest taka, aby zawsze postępować zgodnie z konwencją Twojej społeczności programistów, aby móc efektywniej współpracować.


0

Oznacza to po prostu, że jest to pole składowe w klasie.


0

Nie ma żadnej konkretnej konwencji nazewnictwa, ale widziałem to w przypadku prywatnych członków.


0

Wiele osób lubi mieć prywatne pola poprzedzone podkreśleniem. To tylko konwencja nazewnictwa.

„Oficjalne” konwencje nazewnictwa języka C # nakazują proste nazwy małymi literami (bez podkreślenia) dla pól prywatnych.

Nie znam standardowych konwencji C ++, chociaż podkreślenia są bardzo szeroko stosowane.


0

Jest to po prostu konwencja, której niektórzy programiści używają, aby wyjaśnić, kiedy manipulujesz składnikiem klasy lub jakimś innym rodzajem zmiennej (parametrami, lokalnymi dla funkcji itp.). Inną konwencją, która jest również szeroko stosowana w przypadku zmiennych składowych, jest poprzedzanie nazwy przedrostkiem „m_”.

Zresztą to tylko konwencje i nie znajdziesz dla nich jednego źródła. Są kwestią stylu, a każdy zespół programistyczny, projekt czy firma ma swój własny (a nawet go nie ma).


0

Jest w pełni uzasadniony powód, aby używać go w C #: jeśli kod musi być również rozszerzalny z VB.NET. (W przeciwnym razie nie zrobiłbym tego.)

Ponieważ VB.NET nie rozróżnia wielkości liter, nie ma prostego sposobu na uzyskanie dostępu do chronionego fieldelementu członkowskiego w tym kodzie:

public class CSharpClass
{
    protected int field;
    public int Field { get { return field; } }
}

Np. Uzyska dostęp do metody pobierania właściwości, a nie pola:

Public Class VBClass
    Inherits CSharpClass

    Function Test() As Integer
        Return Field
    End Function

End Class

Heck, nie mogę nawet pisać fieldmałymi literami - VS 2010 po prostu ciągle to poprawia.

Aby uczynić go łatwo dostępnym dla klas pochodnych w VB.NET, trzeba wymyślić inną konwencję nazewnictwa. Przedrostek podkreślenia jest prawdopodobnie najmniej uciążliwym i najbardziej „historycznie akceptowanym” z nich.


0

Teraz notacja używająca "this" jak w this.foobarbaz jest akceptowalna dla zmiennych składowych klasy C #. Zastępuje starą notację „m_” lub po prostu „__”. Czyni to kod bardziej czytelnym, ponieważ nie ma wątpliwości, co jest referencją.


0

Z mojego doświadczenia (z pewnością ograniczonego) podkreślenie będzie wskazywać, że jest to prywatna zmienna składowa. Jak powiedział Gollum, będzie to jednak zależeć od zespołu.


0

Stare pytanie, nowa odpowiedź (C #).

Innym zastosowaniem podkreślenia dla C # jest użycie DI (iniekcja zależności) ASP NET Core. Prywatne readonlyzmienne klasy, która została przypisana do wstrzykniętego interfejsu podczas budowy, powinny zaczynać się od podkreślenia. Wydaje mi się, że jest to debata, czy użyć podkreślenia dla każdego prywatnego członka klasy (chociaż sam Microsoft podąża za tym), ale ten jest pewien.

private readonly ILogger<MyDependency> _logger;

public MyDependency(ILogger<MyDependency> logger)
{
    _logger = logger;
}

-2

Taka konwencja nazewnictwa jest przydatna podczas czytania kodu, zwłaszcza kodu, który nie jest Twoim własnym. Silna konwencja nazewnictwa pomaga wskazać, gdzie jest zdefiniowany dany członek, jakiego rodzaju jest to członek, itp. Większość zespołów programistów przyjmuje prostą konwencję nazewnictwa i po prostu umieszcza przed polami elementu podkreślenie ( _fieldName). W przeszłości stosowałem następującą konwencję nazewnictwa dla języka C # (która jest oparta na konwencji Microsoftu dla kodu platformy .NET, którą można zobaczyć w programie Reflector):

Pole instancji: m_fieldName
Pole statyczne: s_fieldName
Public / Protected / Internal Member: PascalCasedName ()
Private Member: camelCasedName ()

Pomaga to ludziom bardzo szybko zrozumieć strukturę, użycie, dostępność i lokalizację członków podczas czytania nieznanego kodu.


3
W rzeczywistości Microsoft nie zaleca używania prefiksów m_, s_. Nie używaj przedrostka dla nazw pól. Na przykład nie używaj g_ ani s_ do rozróżniania pól statycznych i niestatycznych. msdn.microsoft.com/en-us/library/ms229012.aspx
Zied

1
Jak powiedziałem, spójrz na ich kod źródłowy za pomocą Reflectora. Będziesz zaskoczony, jak bardzo uchylają się od własnych zaleceń. ;) Jak wspomniałem w moim poście, pomaga to poprawić czytelność twojego kodu, a mojemu ostatniemu zespołowi bardzo podobała się konwencja nazewnictwa wymieniona powyżej.
jrista
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.