Visual Basic Kódolási Konvenciók

A Microsoft olyan mintákat és dokumentációkat fejleszt, amelyek a jelen témakörben szereplő irányelveket követik. Ha ugyanazokat a kódolási konvenciókat követi, a következő előnyöket élvezheti:

A kód egységes megjelenésű lesz, így az olvasók jobban összpontosíthatnak a tartalomra, nem pedig az elrendezésre.
Az olvasók gyorsabban megértik a kódot, mert a korábbi tapasztalatok alapján tehetnek feltételezéseket.
A kódot egyszerűbben másolhatja, módosíthatja és karbantarthatja.
Segít meggyőződni arról, hogy a kód bemutatja a Visual Basic "ajánlott eljárásait".

Elnevezési egyezmények

Az elnevezési irányelvekről további információt az elnevezési irányelvek témakörében talál.
Ne használd a "Saját" vagy a "saját" szót változónév részeként. Ez a gyakorlat összezavarja az My objektumokat.
Az automatikusan létrehozott kódban nem kell módosítania az objektumok nevét, hogy azok megfeleljenek az irányelveknek.

Elrendezési konvenciók

Tabulátorok beszúrása szóközökként, valamint intelligens behúzás alkalmazása négy szóköznyi behúzással.
A kód szerkesztéséhez használja a Szép lista (újraformázás) elemet a kódszerkesztőben. További információ: Beállítások, Szövegszerkesztő, Alapszintű (Visual Basic).
Soronként csak egy utasítást használjon. Ne használja a Visual Basic vonalelválasztó karaktert (:).
Kerülje a "_" explicit sorfolytató karakter használatát az implicit sorfolytatás mellett, ahol a nyelv lehetővé teszi.
Soronként csak egy deklarációt használjon.
Ha a kód szép lista formázása (újraformázása) nem formázza automatikusan a folytatási sorokat, manuálisan behúzzuk a folytatási sorokat egy tabulátorral. A lista elemeit azonban mindig balra igazítsa.
```
a As Integer,  
b As Integer  
```
Adjon hozzá legalább egy üres sort a metódus és a tulajdonságdefiníciók között.

Megjegyzésekre vonatkozó egyezmények

A megjegyzéseket ne a kódsor végén, hanem egy külön sorban tegye.
Kezdje el a megjegyzés szövegét nagybetűvel, a záró megjegyzés szövegét pedig ponttal.
Szúrjon be egy szóközt a megjegyzéselválasztó (') és a megjegyzésszöveg közé.
```
' Here is a comment.
```
Ne vegye körül a megjegyzéseket csillagokkal formázott blokkokkal.

Programstruktúra

A metódus használatakor Main használja az új konzolalkalmazások alapértelmezett szerkezetét, és használja My parancssori argumentumokhoz.
```
Sub Main()
  For Each argument As String In My.Application.CommandLineArgs
    ' Add code here to use the string variable.
  Next
End Sub
```

Nyelvi irányelvek

Sztring adattípusa

Sztringinterpolációval rövid sztringeket fűzhet össze az alábbi kódban látható módon.
```
MsgBox($"hello{vbCrLf}goodbye")
```

A sztringek hurkokban való hozzáfűzéséhez használja az StringBuilder objektumot.

Dim longString As New System.Text.StringBuilder
For count As Integer = 1 To 1000
  longString.Append(count)
Next

Rugalmas delegáltak az eseménykezelőkben

Ne minősítse explicit módon az argumentumokat (Object és EventArgs) az eseménykezelőknek. Ha nem használja az eseménynek átadott eseményargumentumokat (például sender As Object, e As EventArgs), használjon lazított delegáltakat, és hagyja ki az eseményargumentumokat a kódban.

Public Sub Form1_Load() Handles Form1.Load
End Sub

Aláíratlan adattípus

Használjon Integer nem aláírt típusok helyett, kivéve, ha szükség van rájuk.

Tömbök

Használja a rövid szintaxist, amikor tömböket inicializál a deklarációs sorban. Használja például a következő szintaxist.
```
Dim letters1 As String() = {"a", "b", "c"}
```
Ne használja a következő szintaxist.
```
Dim letters2() As String = New String() {"a", "b", "c"}
```
A tömb kijelölőt ne a változóra, hanem a típusra helyezze. Használja például a következő szintaxist:
```
Dim letters4 As String() = {"a", "b", "c"}
```
Ne használja a következő szintaxist:
```
Dim letters3() As String = {"a", "b", "c"}
```
Az alapszintű adattípusok tömbjeinek deklarálása és inicializálásakor használja a { } szintaxist. Használja például a következő szintaxist:
```
Dim letters5 As String() = {"a", "b", "c"}
```
Ne használja a következő szintaxist:
```
Dim letters6(2) As String
letters6(0) = "a"
letters6(1) = "b"
letters6(2) = "c"
```

A kulcsszó használata

Amikor egy objektumra irányuló hívássorozatot indít, fontolja meg a With kulcsszó használatát:

With orderLog
  .Log = "Application"
  .Source = "Application Name"
  .MachineName = "Computer Name"
End With

Használd a Try...Catch és Using utasításokat, amikor kivételkezelést alkalmazol.

Ne használja az On Error Goto-t.

Az IsNot kulcsszó használata

... IsNot Nothinghelyett használja Not ... Is Nothing.

Új kulcsszó

Használjon rövid példányosítást. Használja például a következő szintaxist:
```
Dim employees As New List(Of String)
```
Az előző sor a következőnek felel meg:
```
Dim employees2 As List(Of String) = New List(Of String)
```

A paraméter nélküli konstruktor helyett használjon objektum inicializálókat új objektumokhoz:

Dim orderLog As New EventLog With { 
    .Log = "Application", 
    .Source = "Application Name", 
    .MachineName = "Computer Name"}

Eseménykezelés

Használja Handles a következő helyett AddHandler:

Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

Használja AddressOf, és ne hozza létre explicit módon a meghatalmazottat:

Dim closeItem As New ToolStripMenuItem( 
    "Close", Nothing, AddressOf ToolStripMenuItem1_Click)
Me.MainMenuStrip.Items.Add(closeItem)

Esemény definiálásakor használja a rövid szintaxist, és hagyja, hogy a fordító definiálja a meghatalmazottat:

Public Event SampleEvent As EventHandler(Of SampleEventArgs)
' or
Public Event SampleEvent(ByVal source As Object, 
                          ByVal e As SampleEventArgs)

A metódus meghívása Nothing előtt ne ellenőrizze, hogy egy RaiseEvent esemény null értékű-e. RaiseEvent ellenőrzi Nothing mielőtt az eseményt kiváltaná.

Megosztott tagok használata

A tagok hívása Shared az osztálynév használatával, nem példányváltozóból.

XML-literálok használata

Az XML-literálok leegyszerűsítik az XML használata során leggyakrabban előforduló feladatokat (például betöltés, lekérdezés és átalakítás). Ha XML-lel fejleszt, kövesse az alábbi irányelveket:

XML-literálok használatával xml-dokumentumokat és -töredékeket hozhat létre az XML API-k közvetlen meghívása helyett.
Importálja az XML-névtereket a fájl vagy a projekt szintjén, hogy kihasználhassa az XML-literálok teljesítményoptimalizálási előnyeit.
Az XML-tengely tulajdonságaival elérheti az XML-dokumentumok elemeit és attribútumait.

Beágyazott kifejezések használata értékek belefoglalására és xml-fájl létrehozására meglévő értékekből API-hívások, például a Add metódus használata helyett:

Private Function GetHtmlDocument( 
    ByVal items As IEnumerable(Of XElement)) As String

  Dim htmlDoc = <html>
                  <body>
                    <table border="0" cellspacing="2">
                      <%= 
                        From item In items 
                        Select <tr>
                                 <td style="width:480">
                                   <%= item.<title>.Value %>
                                 </td>
                                 <td><%= item.<pubDate>.Value %></td>
                               </tr> 
                      %>
                    </table>
                  </body>
                </html>

  Return htmlDoc.ToString()
End Function

LINQ-lekérdezések

Használjon értelmes neveket a lekérdezési változókhoz:

Dim seattleCustomers = From cust In customers 
                       Where cust.City = "Seattle"

Adja meg a lekérdezés elemeinek nevét, hogy a névtelen típusú tulajdonságnevek helyesen legyenek nagybetűsítve Pascal-casing használatával:

Dim customerOrders = From customer In customers 
                     Join order In orders 
                       On customer.CustomerID Equals order.CustomerID 
                     Select Customer = customer, Order = order

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 rendelésazonosítót ad vissza, nevezze át őket, ahelyett hogy Name és ID-ként hagyná az eredményben.
```
Dim customerOrders2 = From cust In customers 
                      Join ord In orders
                        On cust.CustomerID Equals ord.CustomerID 
                      Select CustomerName = cust.Name, 
                             OrderID = ord.ID
```
Használjon típuskövető következtetést a lekérdezési változók és a tartományváltozók deklarációjában:
```
Dim customerList = From cust In customers
```

A lekérdezési záradékokat egyeztesse az From utasítással:

Dim newyorkCustomers = From cust In customers 
                       Where cust.City = "New York" 
                       Select cust.LastName, cust.CompanyName

Más lekérdezési záradékok előtt használjon Where záradékokat, hogy a későbbi lekérdezési záradékok a szűrt adathalmazon működjenek:

Dim newyorkCustomers2 = From cust In customers 
                        Where cust.City = "New York" 
                        Order By cust.LastName

Join A záradék használatával explicit módon definiálhat illesztési műveletet a Where záradék használata helyett, hogy implicit módon definiáljon egy illesztési műveletet:

Dim customerList2 = From cust In customers 
                    Join order In orders 
                      On cust.CustomerID Equals order.CustomerID 
                    Select cust, order

Lásd még

biztonságos kódolási irányelvek

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-06-17