Gyakori C#-kódkonvenciák

A kódolási konvenciók elengedhetetlenek a kód olvashatóságának, konzisztenciájának és együttműködésének fenntartásához a fejlesztői csapaton belül. Az iparági gyakorlatokat és a bevált irányelveket követő kód könnyebben érthető, karbantartható és kiterjeszthető. A legtöbb projekt egységes stílust kényszerít ki kódkonvenciókon keresztül. dotnet/docs és dotnet/samples projektek nem kivételek. Ebben a cikksorozatban megismerheti a kódolási konvencióinkat és a kényszerítésükhöz használt eszközöket. A konvencióinkat igény szerint veheti át, vagy módosíthatja őket a csapat igényeinek megfelelően.

Konvencióinkat a következő célok alapján választottuk ki:

Helyesség: A mintáinkat másoljuk és illesztjük be az alkalmazásokba. Erre számítunk, ezért rugalmas és helyes kódot kell készítenünk, még több szerkesztés után is.
Tanítás: A minták célja, hogy megtanítsuk az összes .NET-et és C#-t. Ezért nem helyezünk korlátozásokat semmilyen nyelvi funkcióra vagy API-ra. Ehelyett ezek a minták azt tanítják, ha egy funkció jó választás.
Konzisztencia: Az olvasók egységes élményt várnak a tartalomban. Minden mintának meg kell felelnie ugyanannak a stílusnak.
Átvétel: Mintáinkat aktívan frissítjük, hogy új nyelvi funkciókat használjunk. Ez a gyakorlat felhívja a figyelmet az új funkciókra, és minden C#-fejlesztő számára ismerősebbé teszi őket.

Fontos

Ezeket az irányelveket a Microsoft használja minták és dokumentációk fejlesztéséhez. Ezeket a .NET Runtime, a C# kódolási stílus és a C# fordító (roslyn) irányelveiből fogadták el. Ezeket az irányelveket azért választottuk, mert több évnyi nyílt forráskódú fejlesztés során fogadták el őket. Ezek az irányelvek segítséget nyújtanak a közösség tagjainak a futtatókörnyezeti és fordítói projektekben való részvételben. Ezek a gyakori C#-konvenciók példájaként szolgálnak, nem pedig mérvadó listaként (részletes útmutatásért lásd keretrendszertervezési irányelvek).

A tanítási és bevezetési célok miatt a dokumentumok kódolási konvenciója eltér a futtatókörnyezeti és a fordítói konvencióktól. A futtatókörnyezet és a fordító is szigorú teljesítménymutatókkal rendelkezik a kritikus útvonalakhoz. Sok más alkalmazás nem. A tanítási célunk előírja, hogy ne tiltsunk be semmilyen szerkezetet. Ehelyett a minták azt mutatják, hogy mikor érdemes szerkezeteket használni. A mintákat agresszívabban frissítjük, mint a legtöbb éles alkalmazás. A bevezetési cél azt írja elő, hogy a kódokat ma kell írni, még akkor is, ha a tavaly írt kód nem igényel módosításokat.

Ez a cikk ismerteti az irányelveinket. Az irányelvek idővel fejlődnek, és olyan mintákat talál, amelyek nem követik az irányelveinket. Üdvözöljük azokat a PRS-eket, amelyek a mintákat megfelelőségre hozzák, vagy olyan problémákat, amelyek felhívják a figyelmünket a frissítendő mintákra. Irányelveink nyílt forráskódúak, és üdvözöljük a PR-kat és a kérdéseket. Ha azonban a beküldés módosítaná ezeket a javaslatokat, először kezdeményezzen egy vitát. Szívesen használja az irányelveinket, vagy az igényeihez igazíthatja őket.

Eszközök és elemzők

Az eszközök segíthetnek a csapatnak a konvenciók betartatásában. Engedélyezheti a kódelemzést a kívánt szabályok kikényszerítéséhez. Szerkesztőkonfigurációt is létrehozhat, hogy a Visual Studio automatikusan érvényesítse a stílusra vonatkozó irányelveket. Kiindulópontként másolja a dotnet/docs.editorconfig fájlokat stílusunk használatához.

Ezek az eszközök megkönnyítik a csapat számára az előnyben részesített irányelvek elfogadását. A Visual Studio az összes .editorconfig fájlban alkalmazza a szabályokat a kód formázásához. Több konfigurációt is használhat a vállalati szintű konvenciók, a csapatkonvenciók és akár a részletes projektkonvenciók kikényszerítéséhez.

A kódelemzés figyelmeztetéseket és diagnosztikát hoz létre, amikor szabálysértéseket észlel. Konfigurálja a projektre alkalmazni kívánt szabályokat. Ezután minden CI-build értesíti a fejlesztőket, ha megszegik a szabályokat.

Diagnosztikai azonosítók

Saját elemzők létrehozásakor válassza ki a megfelelő diagnosztikai azonosítókat

Nyelvi irányelvek

A következő szakaszok a .NET-dokumentumok csapata által követett eljárásokat ismertetik a kódminták és -minták elkészítéséhez. Általában kövesse az alábbi eljárásokat:

Amikor csak lehetséges, modern nyelvi funkciókat és C#-verziókat használhat.
Kerülje az elavult nyelvi szerkezeteket.
Csak a megfelelően kezelhető kivételeket fogja el; kerülje az általános kivételeket. A mintakódnak például nem szabad kivételszűrő nélkül elkapnia a System.Exception típust.
Használjon konkrét kivételtípusokat jelentőségteljes hibaüzenetek megadásához.
LINQ-lekérdezések és -metódusok használata a kód olvashatóságának javítása érdekében a gyűjteménykezeléshez.
Használjon aszinkron programozást az async és await kulcsszavakkal az I/O-kötött műveletekhez.
Legyen óvatos a holtpontokkal, és szükség esetén használja Task.ConfigureAwait.
Használja a nyelvi kulcsszavakat az adattípusokhoz a futtatókörnyezet-típusok helyett. Használja például string a helyett System.Stringvagy int helyett.System.Int32 Ez a javaslat a nint és a nuinttípusokat is tartalmazza.
Használjon int nem aláírt típusok helyett. A int használata a C#-ben gyakori, és amikor használod a int, egyszerűbb más könyvtárakkal is együttműködni. Kivételt képeznek az aláíratlan adattípusokra vonatkozó dokumentációk.
Csak akkor használható var , ha egy olvasó ki tudja következtetni a típust a kifejezésből. Az olvasók a docs platformon tekintik meg a mintákat. Nem rendelkeznek olyan rámutatási vagy eszköztippekkel, amelyek a változók típusát jelenítik meg.
Írjon kódot úgy, hogy az világos és egyszerű legyen.
Kerülje a túl összetett és konvolúciós kódlogikát.

Konkrétabb útmutatást követünk.

Karakterlánc adatok

Sztringinterpolációval rövid sztringeket fűzhet össze az alábbi kódban látható módon.
```
string displayName = $"{nameList[n].LastName}, {nameList[n].FirstName}";
```

Ha sztringeket szeretne összefűzni ciklusokban, különösen akkor, ha nagy mennyiségű szöveggel dolgozik, használjon egy System.Text.StringBuilder objektumot.

var phrase = "lalalalalalalalalalalalalalalalalalalalalalalalalalalalalala";
var manyPhrases = new StringBuilder();
for (var i = 0; i < 10000; i++)
{
    manyPhrases.Append(phrase);
}
//Console.WriteLine("tra" + manyPhrases);

Részesítse előnyben a nyers szöveges literálokat a speciális karakterek vagy a szó szerinti szövegek helyett.

var message = """
    This is a long message that spans across multiple lines.
    It uses raw string literals. This means we can 
    also include characters like \n and \t without escaping them.
    """;

Használja a kifejezésalapú sztring interpolációt a pozíciós sztring interpolációja helyett.

// Execute the queries.
Console.WriteLine("scoreQuery:");
foreach (var student in scoreQuery)
{
    Console.WriteLine($"{student.Last} Score: {student.score}");
}

Konstruktorok és inicializálás

Használja a Pascal-esetet a rekordtípusok elsődleges konstruktorparamétereihez:
```
public record Person(string FirstName, string LastName);
```
Használjon camel-case-formátumot az osztály- és struktúratípusok elsődleges konstruktorparamétereihez.

Konstruktorok helyett required tulajdonságokat használva kényszerítse a tulajdonságértékek inicializálását:

public class LabelledContainer<T>(string label)
{
    public string Label { get; } = label;
    public required T Contents 
    { 
        get;
        init;
    }
}

Tömbök és gyűjtemények

Gyűjteménykifejezések használata az összes gyűjteménytípus inicializálásához:

string[] vowels = [ "a", "e", "i", "o", "u" ];

Delegáltak

Delegálttípusok definiálása helyett használja Func<> és Action<> használja. Egy osztályban adja meg a delegálási metódust.

Action<string> actionExample1 = x => Console.WriteLine($"x is: {x}");

Action<string, string> actionExample2 = (x, y) =>
    Console.WriteLine($"x is: {x}, y is {y}");

Func<string, int> funcExample1 = x => Convert.ToInt32(x);

Func<int, int, int> funcExample2 = (x, y) => x + y;

A metódust az Func<> vagy Action<> delegátum által meghatározott aláírással hívja meg.

actionExample1("string for x");

actionExample2("string for x", "string for y");

Console.WriteLine($"The value is {funcExample1("1")}");

Console.WriteLine($"The sum is {funcExample2(1, 2)}");

Ha példányokat hoz létre egy delegált típusból, használjon tömör szintaxist. Egy osztályban adja meg a delegált típusát és egy megfelelő aláírással rendelkező metódust.
```
public delegate void Del(string message);

public static void DelMethod(string str)
{
    Console.WriteLine($"DelMethod argument: {str}");
}
```
Hozzon létre egy delegált típusú példányt, és hívja meg. Az alábbi deklaráció a sűrített szintaxist mutatja.
```
Del exampleDel2 = DelMethod;
exampleDel2("Hey");
```

Az alábbi deklaráció a teljes szintaxist használja.

Del exampleDel1 = new Del(DelMethod);
exampleDel1("Hey");

`try-catch` és `using` a kivételkezelésre vonatkozó utasítások

A legtöbb kivételkezeléshez használjon egy try-catch utasítást.

static double ComputeDistance(double x1, double y1, double x2, double y2)
{
    try
    {
        return Math.Sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
    }
    catch (System.ArithmeticException ex)
    {
        Console.WriteLine($"Arithmetic overflow or underflow: {ex}");
        throw;
    }
}

Egyszerűsítse a kódot a C# utasítással. Ha van egy try-finally utasítása, amelyben az egyetlen kód a finally blokkban egy hívás a Dispose metódusra, akkor használjon egy using utasítást helyette.

Az alábbi példában az try-finally utasítás csak a Dispose blokkban hívja meg a finally-et.
```
Font bodyStyle = new Font("Arial", 10.0f);
try
{
    byte charset = bodyStyle.GdiCharSet;
}
finally
{
    bodyStyle?.Dispose();
}
```
Ugyanezt megteheti egy using nyilatkozattal is.
```
using (Font arial = new Font("Arial", 10.0f))
{
    byte charset2 = arial.GdiCharSet;
}
```
Használja az új using szintaxist , amely nem igényel kapcsos zárójelet:
```
using Font normalStyle = new Font("Arial", 10.0f);
byte charset3 = normalStyle.GdiCharSet;
```

`&&` és `||` operátorok

Használja a && jelet az & helyett, és a || jelet a | helyett, amikor összehasonlításokat végez, ahogy azt az alábbi példában is láthatja.

Console.Write("Enter a dividend: ");
int dividend = Convert.ToInt32(Console.ReadLine());

Console.Write("Enter a divisor: ");
int divisor = Convert.ToInt32(Console.ReadLine());

if ((divisor != 0) && (dividend / divisor) is var result)
{
    Console.WriteLine($"Quotient: {result}");
}
else
{
    Console.WriteLine("Attempted division by 0 ends up here.");
}

Ha az osztó 0, az utasítás második záradéka if futásidejű hibát okozna. A && operátor rövidzárat hajt végre, amikor az első kifejezés hamis. Vagyis nem értékeli ki a második kifejezést. A & operátor mindkettőt kiértékeli, ami futásidejű hibát eredményez, ha divisor 0.

`new` operátor

Használja az objektum példányosításának egyik tömör formáját, ha a változó típusa megegyezik az objektumtípussal, ahogyan az az alábbi deklarációkban is látható. Ez az űrlap nem érvényes, ha a változó egy felülettípusú vagy a futásidei típus alaposztálya.
```
var firstExample = new ExampleClass();
```
```
ExampleClass instance2 = new();
```
Az előző deklarációk egyenértékűek a következő deklarációval.
```
ExampleClass secondExample = new ExampleClass();
```

Az objektum-inicializálók használatával egyszerűsítheti az objektumok létrehozását, ahogyan az az alábbi példában is látható.

var thirdExample = new ExampleClass { Name = "Desktop", ID = 37414,
    Location = "Redmond", Age = 2.3 };

Az alábbi példa ugyanazokat a tulajdonságokat állítja be, mint az előző példában, de nem használ inicializálókat.

var fourthExample = new ExampleClass();
fourthExample.Name = "Desktop";
fourthExample.ID = 37414;
fourthExample.Location = "Redmond";
fourthExample.Age = 2.3;

Eseménykezelés

Lambda-kifejezéssel definiálhat egy eseménykezelőt, amelyet később nem kell eltávolítania:

public Form2()
{
    this.Click += (s, e) =>
        {
            MessageBox.Show(
                ((MouseEventArgs)e).Location.ToString());
        };
}

A lambda kifejezés rövidíti a következő hagyományos definíciót.

public Form1()
{
    this.Click += new EventHandler(Form1_Click);
}

void Form1_Click(object? sender, EventArgs e)
{
    MessageBox.Show(((MouseEventArgs)e).Location.ToString());
}

Statikus tagok

Hívja meg a statikus tagokat a ClassName.StaticMember osztálynévvel. Ez a gyakorlat a statikus hozzáférés egyértelművé tételével olvashatóbbá teszi a kódot. Ne minősítse az alaposztályban definiált statikus tagot származtatott osztály nevével. A kód fordítása közben a kód olvashatósága félrevezető, és a kód a jövőben megszakadhat, ha egy azonos nevű statikus tagot ad hozzá a származtatott osztályhoz.

LINQ-lekérdezések

Használjon értelmes neveket a lekérdezési változókhoz. Az alábbi példa a Seattle-ben található ügyfelek esetét illusztrálja seattleCustomers .
```
var seattleCustomers = from customer in Customers
                       where customer.City == "Seattle"
                       select customer.Name;
```

Aliasok használatával győződjön meg arról, hogy a névtelen típusok tulajdonságnevei helyesen vannak nagybetűsítve a Pascal-casing használatával.

var localDistributors =
    from customer in Customers
    join distributor in Distributors on customer.City equals distributor.City
    select new { Customer = customer, Distributor = distributor };

Nevezze át a tulajdonságokat, ha az eredményben szereplő tulajdonságnevek nem egyértelműek. Ha például a lekérdezés egy ügyfélnevet és egy forgalmazói nevet ad vissza, ahelyett, hogy az eredményben Name formájában hagyná őket, nevezze át őket, hogy tisztázza, CustomerName az ügyfél neve, DistributorName pedig egy forgalmazó neve.
```
var localDistributors2 =
    from customer in Customers
    join distributor in Distributors on customer.City equals distributor.City
    select new { CustomerName = customer.Name, DistributorName = distributor.Name };
```
Implicit gépelés használata a lekérdezési változók és a tartományváltozók deklarációjában. Ez az útmutató a LINQ-lekérdezések implicit beírásával kapcsolatban felülbírálja az implicit módon beírt helyi változók általános szabályait. A LINQ-lekérdezések gyakran használnak névtelen típusokat létrehozó előrejelzéseket. Más lekérdezési kifejezések beágyazott általános típusokkal hoznak létre eredményeket. Az implicit típusú változók gyakran olvashatóbbak.
```
var seattleCustomers = from customer in Customers
                       where customer.City == "Seattle"
                       select customer.Name;
```
A záradék alatti from lekérdezési záradékok igazítása az előző példákban látható módon.

Más lekérdezési záradékok előtt használjon where záradékokat annak biztosítására, hogy a későbbi lekérdezési záradékok a csökkentett, szűrt adatkészleten működjenek.

var seattleCustomers2 = from customer in Customers
                        where customer.City == "Seattle"
                        orderby customer.Name
                        select customer;

Több from záradékot tartalmazó belső gyűjtemények elérése join záradék helyett. Egy objektumgyűjtemény Student például tartalmazhat teszteredmények gyűjteményét. A következő lekérdezés végrehajtásakor visszaadja a 90-esnél több pontszámot, valamint a pontszámot kapott tanuló családi nevét.
```
var scoreQuery = from student in students
                 from score in student.Scores
                 where score > 90
                 select new { Last = student.LastName, score };
```

Implicit típusmeghatározású helyi változók

Használjon implicit beírást helyi változókhoz, ha a változó típusa nyilvánvaló a hozzárendelés jobb oldalán.
```
var message = "This is clearly a string.";
var currentTemperature = 27;
```
Ne használjon varot, ha a típus nem látható a hozzárendelés jobb oldalán. Ne feltételezze, hogy a típus egy metódusnévből egyértelmű. A változótípusok akkor tekinthetők egyértelműnek, ha new operátorról, explicit leadásról vagy konstans értékhez való hozzárendelésről van szó.
```
int numberOfIterations = Convert.ToInt32(Console.ReadLine());
int currentMaximum = ExampleClass.ResultSoFar();
```
Ne használjon változóneveket a változó típusának megadásához. Lehet, hogy nem helyes. Ehelyett a típussal adja meg a típust, és a változó nevével jelezze a változó szemantikai adatait. Az alábbi példának a string típust kell használnia, valamint valami olyasmit, mint a iterations, amely jelzi a konzolról beolvasott információk jelentését.
```
var inputInt = Console.ReadLine();
Console.WriteLine(inputInt);
```
Kerüljük a var használatát a dinamikus helyett. Akkor használja dynamic , ha futásidejű típusú következtetést szeretne. További információt a Dinamikus típus használata (C# programozási útmutató) című témakörben talál.

Használja az implicit típusmegadást a hurokváltozóhoz a for hurkoknál.

Az alábbi példa implicit beírást használ egy for utasításban.

var phrase = "lalalalalalalalalalalalalalalalalalalalalalalalalalalalalala";
var manyPhrases = new StringBuilder();
for (var i = 0; i < 10000; i++)
{
    manyPhrases.Append(phrase);
}
//Console.WriteLine("tra" + manyPhrases);

Ne használjon implicit gépelést a hurokváltozó típusának meghatározásához a hurkokban foreach . A gyűjtemény elemeinek típusa a legtöbb esetben nem egyértelmű azonnal. A gyűjtemény nevére nem szabad kizárólag az elemek típusának következtetésére támaszkodni.

Az alábbi példa explicit beírást használ egy foreach utasításban.
```
foreach (char ch in laugh)
{
    if (ch == 'h')
    {
        Console.Write("H");
    }
    else
    {
        Console.Write(ch);
    }
}
Console.WriteLine();
```
implicit típust használjon a LINQ-lekérdezések eredményütemezéseihez. A LINQ szakasza azt ismerteti, hogy számos LINQ-lekérdezés névtelen típusokat eredményez, ahol implicit típusokat kell használni. Más lekérdezések beágyazott általános típusokat eredményeznek, ahol var olvashatóbbak.

Feljegyzés

Ügyeljen arra, hogy véletlenül ne módosítsa az iterálható gyűjtemény egy elemtípusát. Egy System.Linq.IQueryable utasításban például egyszerűen válthat System.Collections.IEnumerable-ról foreach, ami megváltoztatja a lekérdezés végrehajtását.

Néhány példa egy kifejezés természetes típusát ismerteti. Ezeket a mintákat úgy kell használni, hogy a fordító a var segítségével a természetes típust válassza. Annak ellenére, hogy ezek a példák kevésbé nyilvánvalóak, a mintához szükséges var használata. A szövegnek meg kell magyaráznia a viselkedést.

Fájlhatókörű névtér-deklarációk

A legtöbb kódfájl egyetlen névteret deklarál. Ezért a példáinknak a fájl hatóköre szerinti névtérdeklarációkat kell használniuk:

namespace MySampleCode;

A névtér deklaráción kívülre helyezze a using direktívákat

Ha egy using irányelv kívül esik egy névtér-deklaráción, az importált névtér teljesen kvalifikált neve. A teljesen minősített név világosabb. Ha az using irányelv a névtéren belül van, az lehet az adott névtérhez viszonyítva, vagy annak teljes neve.

using Azure;

namespace CoolStuff.AwesomeFeature
{
    public class Awesome
    {
        public void Stuff()
        {
            WaitUntil wait = WaitUntil.Completed;
            // ...
        }
    }
}

Feltételezve, hogy van egy (közvetlen vagy közvetett) hivatkozás az WaitUntil osztályra.

Most változtassuk meg kissé:

namespace CoolStuff.AwesomeFeature
{
    using Azure;

    public class Awesome
    {
        public void Stuff()
        {
            WaitUntil wait = WaitUntil.Completed;
            // ...
        }
    }
}

És ma fordítja le. És holnap. De aztán valamikor a jövő héten az előző (érintetlen) kód két hibával meghiúsul:

- error CS0246: The type or namespace name 'WaitUntil' could not be found (are you missing a using directive or an assembly reference?)
- error CS0103: The name 'WaitUntil' does not exist in the current context

Az egyik függőség, amely ezt az osztályt egy névtérben vezeti be, .Azure-ra végződik.

namespace CoolStuff.Azure
{
    public class SecretsManagement
    {
        public string FetchFromKeyVault(string vaultId, string secretId) { return null; }
    }
}

A using névtérben elhelyezett direktíva környezetfüggő, és bonyolítja a névfeloldást. Ebben a példában ez az első névtér, amelyet megtalál.

CoolStuff.AwesomeFeature.Azure
CoolStuff.Azure
Azure

Olyan új névtér hozzáadása, amely megfelel vagy a CoolStuff.Azure-nak, vagy a CoolStuff.AwesomeFeature.Azure-nek, a globális Azure névtér előtt megegyezne. Ezt úgy oldhatja meg, hogy hozzáadja a global:: módosítót a using deklarációhoz. A deklarációkat azonban egyszerűbb a névtéren kívül elhelyezni using .

namespace CoolStuff.AwesomeFeature
{
    using global::Azure;

    public class Awesome
    {
        public void Stuff()
        {
            WaitUntil wait = WaitUntil.Completed;
            // ...
        }
    }
}

Stílusra vonatkozó irányelvek

A kódmintákhoz általában a következő formátumot használja:

A behúzáshoz használjon négy szóközt. Ne használjon lapokat.
A kód következetes igazítása az olvashatóság javítása érdekében.
A dokumentumokban, különösen a mobilképernyőkön a kód olvashatóságának javítása érdekében legfeljebb 65 karakter hosszúságú sorok legyenek korlátozva.
A hosszú utasítások több sorba törésével javíthatja az egyértelműséget és a felhasználói élményt.
Használja az "Allman" stílust a kapcsos zárójelekhez: a nyitó és záró zárójelek kerüljenek saját új sorra. A kapcsos zárójelek igazodnak az aktuális behúzási szinthez.
Szükség esetén a sortöréseket bináris operátorok előtt kell elvégezni.

Megjegyzésstílus

Rövid magyarázatként használjon egysoros megjegyzéseket (//).
Kerülje a többsoros megjegyzéseket (/* */) a hosszabb magyarázatok érdekében.
A kódminták megjegyzései nincsenek honosítva. Ez azt jelenti, hogy a kódba ágyazott magyarázatok nem lesznek lefordítva. Hosszabb, magyarázó szöveget kell elhelyezni a kísérő cikkben, hogy honosítható legyen.
A metódusok, osztályok, mezők és minden nyilvános tag esetében használjon XML-megjegyzéseket.
Helyezze a megjegyzést egy külön sorra, nem pedig egy kódsor végére.
Kezdje el a megjegyzés szövegét nagybetűvel.
Megjegyzés szövegének befejezése ponttal.
Szúrjon be egy szóközt a megjegyzéselválasztó (//) és a megjegyzésszöveg közé, ahogyan az az alábbi példában látható.
```
// The following declaration creates a query. It does not run
// the query.
```

Elrendezési konvenciók

A jó elrendezés formázást használ a kód szerkezetének kiemeléséhez és a kód könnyebb olvashatóságához. A Microsoft-példák és -minták megfelelnek a következő konvencióknak:

Használja az alapértelmezett Kódszerkesztő-beállításokat (intelligens behúzás, négykarakteres behúzás, szóközként mentett lapok). További információ: Beállítások, Szövegszerkesztő, C#, Formázás.
Soronként csak egy mondat írása.
Soronként csak egy deklarációt írj.
Ha a folytatólagos sorok nincsenek automatikusan behúzva, akkor egy tabulátorral (négy szóközzel) kell őket behúzni.
Adjon hozzá legalább egy üres sort a metódusdefiníciók és a tulajdonságdefiníciók között.
Zárójelek használatával tegye láthatóvá egy kifejezés záradékait, ahogyan az az alábbi kódban is látható.
```
if ((startX > endX) && (startX > previousX))
{
    // Take appropriate action.
}
```

Kivételt képez az, ha a minta az operátor vagy a kifejezés elsőbbségét ismerteti.

Biztonság

Kövesse a biztonságos kódolási irányelvekben szereplő irányelveket.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-03-31