Visual Basic – konvence kódování

Článek
03/13/2024

Microsoft vyvíjí ukázky a dokumentaci, které se řídí pokyny v tomto tématu. Pokud dodržujete stejné konvence kódování, můžete získat následující výhody:

Váš kód bude mít konzistentní vzhled, aby se čtenáři mohli lépe soustředit na obsah, ne na rozložení.
Čtenáři můžou kód rychleji pochopit, protože můžou na základě předchozích zkušeností vytvářet předpoklady.
Kód můžete snadněji kopírovat, měnit a udržovat.
Pomůžete zajistit, aby váš kód předvádí osvědčené postupy pro Visual Basic.

Konvence vytváření názvů

Informace o pokynech pro pojmenování najdete v tématu Pokyny pro pojmenování.
Nepoužívejte "My" nebo "my" jako součást názvu proměnné. Tento postup vytváří nejasnosti s My objekty.
Názvy objektů v automaticky generovaném kódu nemusíte měnit, aby odpovídaly pokynům.

Konvence rozložení

Vložte tabulátory jako mezery a používejte inteligentní odsazení se čtyřmi mezerami.
K přeformátování kódu v editoru kódu použijte funkci Pretty listing (přeformátování). Další informace naleznete v tématu Možnosti, Textový editor, Základní (Visual Basic).
Pro každý řádek použijte pouze jeden příkaz. Nepoužívejte znak oddělovače řádků jazyka Visual Basic (:).
Nepoužívejte explicitní znak pokračování řádku "_" ve prospěch implicitního pokračování řádku všude, kde to jazyk umožňuje.
Pro každý řádek použijte pouze jednu deklaraci.
Pokud aplikace Pretty listing (přeformátování) kódu automaticky nenaformátuje řádky pokračování, ručně odsadíte řádky pokračování o jednu zarážku tabulátoru. Vždy však položky v seznamu zarovnávejte doleva.
```
a As Integer,  
b As Integer  
```
Přidejte alespoň jeden prázdný řádek mezi definice metody a vlastností.

Konvence při psaní komentářů

Umístěte komentáře na samostatný řádek místo na konec řádku kódu.
Začněte text komentáře velkým písmenem a ukončete text komentáře tečkou.
Vložte jednu mezeru mezi oddělovač komentáře (') a text komentáře.
```
' Here is a comment.
```
Nezakřikujte komentáře formátovanými bloky hvězdičky.

Struktura programu

Při použití Main metody použijte výchozí konstruktor pro nové konzolové aplikace a použijte My pro argumenty příkazového řádku.

Sub Main()
  For Each argument As String In My.Application.CommandLineArgs
    ' Add code here to use the string variable.
  Next
End Sub

Pokyny pro jazyk

Datový typ String

K zřetězení krátkých řetězců použijte interpolaci řetězců, jak je znázorněno v následujícím kódu.
```
MsgBox($"hello{vbCrLf}goodbye")
```

K připojení řetězců ve smyčce použijte StringBuilder objekt.

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

Uvolnění delegáti v obslužných rutinách událostí

Neudělujte explicitně kvalifikovat argumenty (Object a EventArgs) na obslužné rutiny událostí. Pokud nepoužíváte argumenty události, které jsou předány události (například sender As Object, e As EventArgs), použijte uvolněné delegáty a vynecháte argumenty události v kódu:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Nepodepsaný datový typ

Používejte Integer místo nepodepsaných typů, s výjimkou případů, kdy jsou nezbytné.

Pole

Při inicializaci polí na řádku deklarace použijte krátkou syntaxi. Použijte například následující syntaxi.
```
Dim letters1 As String() = {"a", "b", "c"}
```
Nepoužívejte následující syntaxi.
```
Dim letters2() As String = New String() {"a", "b", "c"}
```
Vložte maticový návrh na typ, ne na proměnnou. Použijte například následující syntaxi:
```
Dim letters4 As String() = {"a", "b", "c"}
```
Nepoužívejte následující syntaxi:
```
Dim letters3() As String = {"a", "b", "c"}
```
Syntaxi { } použijte, když deklarujete a inicializujete pole základních datových typů. Použijte například následující syntaxi:
```
Dim letters5 As String() = {"a", "b", "c"}
```
Nepoužívejte následující syntaxi:
```
Dim letters6(2) As String
letters6(0) = "a"
letters6(1) = "b"
letters6(2) = "c"
```

Použití klíčového slova With

Když provedete řadu volání jednoho objektu, zvažte použití klíčového With slova:

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

Použijte try... Zachycení a použití příkazů při použití zpracování výjimek

Nepoužívejte On Error Goto.

Použití klíčového slova IsNot

Používejte ... IsNot Nothing místo Not ... Is Nothing.

Nové klíčové slovo

Používejte krátkou instanci. Použijte například následující syntaxi:
```
Dim employees As New List(Of String)
```
Předchozí řádek je ekvivalentní tomuto:
```
Dim employees2 As List(Of String) = New List(Of String)
```

Místo konstruktoru bez parametrů použijte inicializátory objektů pro nové objekty:

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

Zpracování událostí

Používejte Handles místo AddHandler:

Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

Použijte AddressOfa nevyužít instanci delegáta explicitně:

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

Při definování události použijte krátkou syntaxi a nechte kompilátor definovat delegáta:

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

Před voláním RaiseEvent metody neověřujte, zda je Nothing událost (null). RaiseEventNothing zkontroluje, jestli se událost nevolá.

Použití sdílených členů

Volání Shared členů pomocí názvu třídy, ne z proměnné instance.

Použití literálů XML

Literály XML zjednodušují nejběžnější úlohy, se kterými se setkáte při práci s XML (například načítání, dotazování a transformace). Při vývoji pomocí XML postupujte podle těchto pokynů:

Literály XML slouží k vytváření dokumentů XML a fragmentů místo přímého volání rozhraní XML API.
Naimportujte obory názvů XML na úrovni souboru nebo projektu, abyste mohli využít optimalizaci výkonu pro literály XML.
Vlastnosti osy XML slouží k přístupu k elementům a atributům v dokumentu XML.

Vložené výrazy použijte k zahrnutí hodnot a vytvoření XML z existujících hodnot místo použití volání rozhraní API, jako Add je metoda:

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

Dotazy LINQ

Pro proměnné dotazu použijte smysluplné názvy:

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

Zadejte názvy prvků v dotazu, abyste měli jistotu, že názvy vlastností anonymních typů jsou správně velkými písmeny pomocí písmen Pascalu:

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

Přejmenujte vlastnosti, pokud by názvy vlastností ve výsledku byly nejednoznačné. Pokud například dotaz vrátí jméno zákazníka a ID objednávky, přejmenujte je místo toho, abyste je opustili jako NameID a ve výsledku:

Dim customerOrders2 = From cust In customers 
                      Join ord In orders
                        On cust.CustomerID Equals ord.CustomerID 
                      Select CustomerName = cust.Name, 
                             OrderID = ord.ID

Použití odvození typu v deklaraci proměnných dotazu a proměnných rozsahu:
```
Dim customerList = From cust In customers
```

Zarovnejte klauzule dotazu pod příkazem From :

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

Použijte Where klauzule před jinými klauzulemi dotazu, aby pozdější klauzule dotazu fungovaly s filtrovanou sadou dat:

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

Klauzule Join slouží k explicitní definici operace spojení místo použití Where klauzule k implicitní definici operace spojení:

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

Viz také

Pokyny pro zabezpečené kódování