Konvence kódování jazyka Visual Basic

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.

Názvové konvence

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í

Nahraďte tabulátory mezerami a používejte inteligentní odsazení se čtyřmi mezerníky.
K přeformátování vašeho kódu v editoru kódu použijte funkci Pěkné zobrazení (přeformátování kódu). Další informace naleznete v tématu Možnosti, Textový editor, Základní (Visual Basic).
Pro každý řádek použijte pouze jeden výrok. 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í.

Komentářové konvence

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.
```
Neobklopujte komentáře formátovanými bloky hvězdiček.

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

Jazykové pokyny

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čkách použijte objekt StringBuilder.

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í

Nekvalifikujte explicitně argumenty (Object a EventArgs) pro obslužné rutiny událostí. Pokud nepoužíváte argumenty, které jsou předávány události (například sender As Object, e As EventArgs), použijte jednoduché delegáty a argumenty události z kódu vynechte:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Datový typ Bez znaménka

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"}
```
Umístěte indikátor pole 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 příkazy Try...Catch a Using při zpracování výjimek

Nepoužívejte On Error Goto.

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

Místo ... IsNot Nothingpoužijte 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 AddressOf, a explicitně nevytvářejte instanci delegáta:

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)

Neověřujte, zda je událost Nothing (null), před voláním metody RaiseEvent. RaiseEvent kontroluje Nothing před jeho vyvoláním události.

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

Členy Shared volejte pomocí jména třídy, ne pomocí 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 výrokem 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í

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-06-17