Konwencje kodowania języka Visual Basic

Artykuł
03/12/2013

Microsoft rozwija się próbki i dokumentacji, które należy przestrzegać zasad w tym temacie.Jeśli się do tych samych konwencji kodowania, może uzyskać następujące korzyści:

Twój kod będzie miał jednolity wygląd, tak, że czytelnik może lepiej skupić się na zawartości, układu nie.
Czytelnicy zrozumieć swój kod bardziej szybko ponieważ mogą one założenia, na podstawie poprzednich doświadczeń.
Można skopiować, zmienić i łatwiej utrzymać kod.
Możesz pomóc zapewnić, że Twój kod pokazuje "Najważniejsze wskazówki" dla programu Visual Basic.

Konwencje nazewnictwa

Aby uzyskać informacje o zasadach nazywania, zobacz Guidelines for Names tematu.
Nie należy używać "My" lub "my" jako część nazwy zmiennej.Praktyka ta tworzy pomylenia ich z My obiektów.
Nie trzeba zmieniać nazwy obiektów w automatycznie wygenerowany kod, aby nadawały się wytycznymi.

Konwencje układu

Wstaw tabulatory jako spacje, a następnie Użyj inteligentnego wcięcia z wcięciami cztery miejsca.Aby uzyskać więcej informacji, zobacz Jak: Ustaw opcje wcięcie i kartę Edytor.
Użycie całkiem aukcji (formatowanie) kodu sformatować kodu w edytorze kodu.Aby uzyskać więcej informacji, zobacz Podstawowe opcje edytora tekstów (Visual Basic).
Za pomocą instrukcji tylko jeden na wiersz.Nie używaj znak separatora wiersza języka Visual Basic (:).)
Unikaj używania znaku kontynuacji wiersza jawne "_" na rzecz kontynuacji wiersza niejawna, wszędzie tam, gdzie język pozwala na to.
Użyj tylko jedna deklaracja na wiersz.
Jeśli całkiem aukcji (formatowanie) kodu nie Formatuj linie kontynuacji automatycznie, ręcznie wcięcie kontynuacji jednego tabulatora wierszy.Jednak zawsze po lewej stronie wyrównanie elementów na liście.
```
a As Integer,
b As Integer
```
Dodaj co najmniej jeden pusty wiersz między definicje metod i właściwości.

Konwencje komentowania

Umieścić komentarze w osobnym wierszu zamiast na końcu wiersza kodu.
Rozpocząć tekst komentarza od wielkiej litery, a tekst komentarza koniec o takim samym okresie.
Włóż jedną spację między ogranicznika komentarza (') i tekst komentarza.
```
' Here is a comment.
```
Nie otaczają komentarze z sformatowanych bloków gwiazdek.

Struktura programu

Podczas korzystania z Main metoda, używać konstruują domyślne dla nowych aplikacji konsoli, a My dla argumentów wiersza polecenia.

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

Wskazówki dotyczące języka

Typ danych String

Do połączenia ciągów, użyty znak (&).
```
MsgBox("hello" & vbCrLf & "goodbye")
```

Aby dołączyć ciągów w pętli, należy użyć StringBuilder obiektu.

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

Obniżone delegatów w procedurach obsługi zdarzeń

Nie są jawnie transakcjami argumenty (obiekt i EventArgs) do obsługi zdarzeń.Jeśli argumenty zdarzeń, które są przekazywane do zdarzenia (na przykład nadawcy jako obiekt, e EventArgs) nie jest używany, użycie delegatów swobodnej i pominąć argumenty zdarzeń w kodzie:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Typ danych bez znaku

Użycie Integer zamiast niepodpisane typów, z wyjątkiem przypadków, jeżeli są niezbędne.

Tablice

Podczas inicjowania tablic w wierszu deklaracji, użyj skróconej składni.Na przykład należy użyć następującej składni.
```
Dim letters1 As String() = {"a", "b", "c"}
```
Nie należy używać następującej składni.
```
Dim letters2() As String = New String() {"a", "b", "c"}
```
W typie, a nie na zmiennej, należy umieścić oznaczenie tablicy.Na przykład użyć następującej składni:
```
Dim letters4 As String() = {"a", "b", "c"}
```
Nie należy używać następującej składni:
```
Dim letters3() As String = {"a", "b", "c"}
```
Po zadeklarowaniu i zainicjować tablice typów podstawowych danych, należy użyć składni {}.Na przykład użyć następującej składni:
```
Dim letters5() As String = {"a", "b", "c"}
```
Nie należy używać następującej składni:
```
Dim letters6(2) As String
letters6(0) = "a"
letters6(1) = "b"
letters6(2) = "c"
```

Użyj ze słowem kluczowym

Podczas dokonywania kolejnych zaproszeń do jednego obiektu, należy rozważyć użycie With słowa kluczowego:

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

Należy używać instrukcji Try...CATCH i za pomocą instrukcji, korzystając z obsługi wyjątków

Nie należy używać On Error Goto.

Za pomocą słowa kluczowego IsNot

Użycie IsNot słowa kluczowego, a nie Not...Is Nothing.

Nowe słowo kluczowe

Używać krótkich podczas tworzenia wystąpienia.Na przykład użyć następującej składni:
```
Dim employees As New List(Of String)
```
Poprzedzającego go wiersza jest równoważne to:
```
Dim employees2 As List(Of String) = New List(Of String)
```

Użyj obiektu Inicjatory dla nowych obiektów zamiast konstruktora bez parametrów:

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

Obsługa zdarzeń

Use Handles rather than AddHandler:

Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

Użycie AddressOfi nie instancji pełnomocnik jawnie:

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

Podczas definiowania zdarzenie, użyj skróconej składni i kompilator zdefiniować delegata:

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

Sprawdza, czy zdarzenie jest Nothing (null), zanim zadzwonisz do RaiseEvent metoda.RaiseEventsprawdza, czy Nothing przed go wywołuje zdarzenie.

Za pomocą udostępnionych elementów członkowskich

Call Shared elementów członkowskich przy użyciu nazwy klasy, nie ze zmienną instancji.

Używaj literałów XML

Literały XML uprościć do najczęściej wykonywanych zadań, które można napotkać podczas pracy z danymi XML (na przykład, obciążenia, kwerendy i transformacji).Gdy tworzysz za pomocą języka XML, należy przestrzegać następujących zasad:

Literały XML umożliwia tworzenie dokumentów XML i fragmentów zamiast wywoływania interfejsów API XML bezpośrednio.
Importowanie obszarów nazw XML na poziomie pliku lub projektu, aby skorzystać z optymalizacji wydajności w literałach XML.
Właściwości osi XML umożliwia dostęp do elementów i atrybutów w dokumencie XML.

Aby uwzględnić wartości i utworzyć XML na podstawie istniejących wartości, a nie za pomocą wywołania interfejsu API, takie jak za pomocą wyrażeń osadzony Add 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

Zapytań LINQ

Użyj znaczące nazwy dla zmiennych kwerendy:

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

Nazwy elementów w kwerendzie, aby upewnić się, że właściwość nazwy typów anonimowy poprawnie kapitalizacji przy użyciu języka Pascal obudowy:

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

Zmień nazwę właściwości, gdy nazwy właściwości, w wyniku będzie niejednoznaczne.Na przykład, jeśli kwerenda zwraca klienta, nazwę i identyfikator zamówienia, zmienić je zamiast pozostawić je jako Name i ID w wyniku:

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

Użyj wnioskowanie w deklaracji zmiennych kwerendy i zakresu zmiennych:
```
Dim customerList = From cust In customers
```

Wyrównaj klauzul kwerendy pod From instrukcji:

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

Użycie Where klauzule przed inne kwerendy klauzule tak, aby później klauzule kwerendy działają na filtrowanej zestaw danych:

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

Użycie Join klauzuli do jednoznacznego określania operacji join, zamiast korzystać z Where klauzula niejawnie określenie operacji sprzężenia:

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

Zobacz też

Inne zasoby

Secure, wytyczne dotyczące programowania

Udostępnij za pośrednictwem