C# kódolási konvenciók Készítette: Majoros Péter

Bevezetés A C# Language Specification nem határoz meg kódolási szabványt. A továbbiakban a Microsoft által javasolt konvenciókat mutatom be. Ezeket néhol kiegészítem saját megjegyzéseimmel, tapasztalataimmal.

Elnevezési konvenciók 1 Olyan esetekben, amikor nem használjuk a using kulcsszót, mindig adjuk meg a használt osztály teljes nevét: var currentPerformanceCounterCategory = new System.Diagnostics. PerformanceCounterCategory(); Megjegyzések: Ebben az esetben amúgy is meg kellene adni. Ha túl hosszú lenne ez által a név, akkor a „.”-al engedélyezett a sortörés. Ha a nevet a Visual Studio automatikusan generálta, ne változtassunk rajta.

Elnevezési konvenciók 2 A választott nevek legyenek beszédesek! Általában: A metódus, property, publikus adattagok namespace és osztály nevek nagybetűvel kezdődnek, A privát adattagok, lokális változók, metódus paraméterek kisbetűsek, A több szóból összerakott nevek egyes komponensei nagybetűvel kezdődnek, szóközt nem tartalmazhatnak.

Elnevezési konvenciók 3 Az olyan adattagok, amelyekhez property is tartozik, vagy kisbetűvel, vagy „_”-al kezdődnek és ekkor az első igazi betű nagybetűs. Például.: private int _Count; public int Count { get { return _Count; } }

Kinézeti konvenciók 1 Használjuk a Visual Studio Code Editor-át. Soronként csak egy: utasítás, deklaráció. Az if után álló sorokat húzzuk beljebb 1 tab-nyival (4 szóköz). A metódusok és property-k között legalább 1 üres sort hagyjunk.

Kinézeti konvenciók 2 Egy kifejezésben használt klózok esetében használjunk zárójeleket, a jobb elkülöníthetőség érdekében: if ((val1 > val2) && (val1 > val3)) { // Take appropriate action. }

Kommentelési konvenciók 1 A kommenteket külön sorba helyezzük el, és ne az utasítás mögé írjuk. Kezdjük a kommentet nagybetűvel. A végére írjunk pontot. Írjunk egy szóközt a // és a komment szövege közé. // The following declaration creates a query. It does not run // the query.

Kommentelési konvenciók 2 Érdemes dokumentációs kommenteket is használni. Ezek mindig a dokumentálandó rész (osztály, metódus, adattag) előtt állnak, és „///”-el kezdődnek. Ezeket egy szóköz után valamilyen XML tag követi. Megkönnyíti a fejlesztést, javítja a kód illetve az assembly újrahasznosíthatóságát.

Kommentelési konvenciók 3 /// <summary> /// What this method does. /// </summary> /// <param name="s">Description of parameter s.</param> /// <param name="a">Description of parameter a.</param> /// <param name="o">Description of parameter o.</param> /// <exception cref="ArgumentException">The exception is thrown when...</exception> /// <returns>The return value of the method.</returns> public int MyMethod(string s, int a, object o) { // Some code. }

String-kezelés Használjuk a „+”-operátort a rövid string-ek összefűzésére: string displayName = nameList[n].LastName + ", " + nameList[n].FirstName; String-ek ciklikus összefűzésére vagy nagy méretű string-ek összefűzésére használjuk a StringBuilder-t. var phrase = "lalalalalalalalalala"; var manyPhrases = new StringBuilder(); for (var i = 0; i < 10000; i++) { manyPhrases.Append(phrase); } //Console.WriteLine("tra" + manyPhrases);

Implicit típusú lokális változók 1 Akkor használjuk ezeket, ha a kifejezés jobb oldala alapján egyértelműen meghatározható, hogy milyen típusú lesz a változó, vagy ha az objektum típusa nem bír jelentőséggel. // When the type of a variable is clear from the context, use var // in the declaration. var var1 = "This is clearly a string."; var var2 = 27; var var3 = Convert.ToInt32(Console.ReadLine());

Implicit típusú lokális változók 2 Ne használjuk a var kulcsszót, ha nem derül ki a jobb oldalból annak típusa. // When the type of a variable is not clear from the // context, use an explicit type. int var4 = ExampleClass.ResultSoFar(); Ne hagyatkozzunk arra, hogy a változó nevében feltüntetjük annak szándékolt típusát. Félrevezető lehet. // Naming the following variable inputInt is misleading. // It is a string. var inputInt = Console.ReadLine(); Console.WriteLine(inputInt);

Implicit típusú lokális változók 3 Ne használjuk, ha a dynamic kulcsszót is alkalmazzuk rá. Használjuk az implicit típust a for és foreach iterációs változói számára: for (var i = 0; i < 10; i++) string text = "ha"; foreach (var v in text)

Előjel nélküli típusok Általában használjunk int-et uint és egyéb előjel nélküli típusok helyett. Az int a leggyakoribb C# környezetben, és könnyebb dolgunk van, ha más könyvtárakkal is dolgoznunk kell.

Tömbök Ajánlott szintaxis a tömbök inicializálására (implicit, nem lehet var-t használni): string[] vowels1 = { "a", "e", "i", "o", "u" }; Explicit példányosításkor lehet var-t haszálni: var vowels2 = new string[] { "a", "e", "i", "o", "u" }; Ha megadjuk a tömb méretét, akkor az elemeket egyesével kell inicializálni: var vowels3 = new string[5]; vowels3[0] = "a"; vowels3[1] = "e"; // And so on.

Delegátumok A delegátumok példányosításakor használjuk a tömör formát: // Define the type. public delegate void Del(string message); // Define a method that has a matching signature. public static void DelMethod(string str) { Console.WriteLine("DelMethod argument: {0}", str); } // Preferred: Create an instance of Del by using // condensed syntax. Del exampleDel2 = DelMethod; // The following declaration uses the full syntax. Del exampleDel1 = new Del(DelMethod);

Try-catch és using a kivételkezelésben 1 A legtöbb esetben használjuk a szokásos try-catch-et. Ha olyan try-finally van, ahol a finally-ben csak a Dispose metódust hívjuk meg, használjuk helyette a using-ot.

Try-catch és using a kivételkezelésben 2 // This 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(); } }

Try-catch és using a kivételkezelésben 3 // You can do the same thing with a using statement. using (Font font2 = new Font("Arial", 10.0f)) { byte charset = font2.GdiCharSet; } Megjegyzés: a using rendkívül hasznos erőforrás-kezelésnél, mivel gondoskodik róla, hogy a lefoglalt erőforrás (pl file) minden esetben fel legyen szabadítva, akár hiba nélkül futott le a kód, akár nem.

&& és || operátorok Annak érdekében, hogy elkerüljük a kivételeket és jobb teljesítményt érjünk el, használjuk az &&-t a & helyett, továbbá a ||-t a | helyett (megj.: azért lehetnek kivételek ezen szabály alól). // If the divisor is 0, the second clause in the // following condition causes a run-time error. // The && operator short circuits when the first // expression is false. That is, it does not evaluate // the second expression. The & operator evaluates both, // and causes a run-time error when divisor is 0. if ((divisor != 0) && (dividend / divisor > 0))

new operátor Lehetőleg a tömör példányosítást használjuk az implicit típus segítségével: var instance1 = new ExampleClass(); Használjuk az objektum inicializálókat, hogy egyszerűsítsük a példányosítást (ha nincs megfelelő konstruktor): var instance3 = new ExampleClass { Name = "Desktop", ID = 37414, Location = "Redmond", Age = 2.3 };

Esemény kezelés és lambda 1 Ha olyan eseménykezelőt hozunk létre, amelyet nem kell később törölnünk, használjunk lambdát. Megjegyzés: a kód rövidebb lesz, és nem kell külön metódust létrehozni csak ennek a kedvéért. // You can use a lambda expression to define an event handler. this.Click += (s, e) => { MessageBox.Show( (MouseEventArgs)e).Location.ToString()); };

Esemény kezelés és lambda 2 A lambda további előnyei: Nem kell külön delegátumot definiálni, Lehetőség nyílik metóduson belüli metódusok létrehozására (alapból ez nem lenne lehetséges).

Statikus adattagok A statikus adattagokat az alábbi módon érjük el: ClassName.StaticMember. Leszármazott osztályból ne hivatkozzunk az ős egy statikus adattagjára.

LINQ 1 A lekérdezésekben lehetőleg beszédes változóneveket használjunk. Használjunk alias-okat, hogy az anonymous típusok property-ei megfelelően legyenek leírva. var localDistributors = from customer in customers join distributor in distributors on customer.City equals distributor.City select new { Customer = customer, Distributor = distributor }; A lekérdezés elemeit a from alá csoportosítsuk.

LINQ 2 Szükség esetén nevezzük át az eredmény proprty-eit, hogy egyértelműen elkülönüljenek a többi változónévtől. Az eredmény típusa legyen implicit. Használjuk a where-t a többi lekérdezési elem előtt, hogy azok már a csökkentett eredményhalmazon dolgozzanak. A belső kollekciók elérésére használjunk inkább több from-ot, mint join-t.

Köszönöm a figyelmet.