Visual Basic .NET Language
Introduction à la syntaxe

.NET Framework ASP.NET asp.net-mvc C# Language JavaScript MySQL Regular Expressions SQL Microsoft SQL Server wpf
Recherche…


commentaires

La première chose intéressante à savoir, c'est comment écrire des commentaires.

Dans VB .NET, vous écrivez un commentaire en écrivant une apostrophe ou en écrivant REM . Cela signifie que le reste de la ligne ne sera pas pris en compte par le compilateur. 

'This entire line is a comment
Dim x As Integer = 0 'This comment is here to say we give 0 value to x

REM There are no such things as multiline comments
'So we have to start everyline with the apostrophe or REM

Intellisense Helper

Une chose intéressante est la possibilité d'ajouter vos propres commentaires dans Visual Studio Intellisense. Ainsi, vous pouvez rendre vos propres fonctions et classes écrites explicites. Pour ce faire, vous devez taper le symbole de commentaire trois fois la ligne au-dessus de votre fonction.

Une fois cela fait, Visual Studio ajoutera automatiquement une documentation XML: 

''' <summary>
''' This function returns a hello to your name
''' </summary>
''' <param name="Name">Your Name</param>
''' <returns></returns>
''' <remarks></remarks>
Public Function Test(Name As String) As String
    Return "Hello " & Name
End Function

Après cela, si vous tapez votre fonction de test quelque part dans votre code, cette petite aide apparaîtra:

Aide Intellisense

Déclaration d'une variable

Dans VB.NET, chaque variable doit être déclarée avant son utilisation (si l' option Option Explicit est définie sur On ). Il y a deux manières de déclarer des variables:

  • Dans une Function ou un Sub : 
Dim w 'Declares a variable named w of type Object (invalid if Option Strict is On)
Dim x As String 'Declares a variable named x of type String
Dim y As Long = 45 'Declares a variable named y of type Long and assigns it the value 45
Dim z = 45 'Declares a variable named z whose type is inferred
           'from the type of the assigned value (Integer here) (if Option Infer is On)
           'otherwise the type is Object (invalid if Option Strict is On)
           'and assigns that value (45) to it

Voir cette réponse pour plus de détails sur Option Explicit , Strict et Infer .

  • À l'intérieur d'une Class ou d'un Module :

Ces variables (également appelées champs dans ce contexte) seront accessibles pour chaque instance de la Class , ils sont déclarés. Ils pourraient être accessibles à partir de l' extérieur de la déclaration de Class en fonction du modificateur ( Public , Private , Protected , Protected Friend ou Friend ) 

Private x 'Declares a private field named x of type Object (invalid if Option Strict is On)
Public y As String 'Declares a public field named y of type String
Friend z As Integer = 45 'Declares a friend field named z of type Integer and assigns it the value 45

Ces champs peuvent également être déclarés avec Dim mais le sens change en fonction du type englobant: 

Class SomeClass
    Dim z As Integer = 45 ' Same meaning as Private z As Integer = 45
End Class

Structure SomeStructure
    Dim y As String ' Same meaning as Public y As String
End Structure

Modificateurs

Les modificateurs permettent d'indiquer comment les objets externes peuvent accéder aux données d'un objet.

  • Publique

Signifie que tout objet peut y accéder sans restriction

  • Privé

Signifie que seul l'objet déclarant peut accéder et voir ceci

  • Protégé

Signifie uniquement l'objet déclarant et tout objet qui en hérite peut y accéder et l'afficher.

  • Ami

Signifie uniquement l'objet delcaring, tout objet qui en hérite et tout objet dans le même espace de noms peut y accéder et le visualiser. 

Public Class MyClass
    Private x As Integer

    Friend Property Hello As String
  
    Public Sub New()
    End Sub

    Protected Function Test() As Integer
        Return 0
    End Function
End Class

Écrire une fonction

Une fonction est un bloc de code qui sera appelé plusieurs fois pendant l'exécution. Au lieu d'écrire le même morceau de code encore et encore, on peut écrire ce code dans une fonction et appeler cette fonction chaque fois que cela est nécessaire.

Une fonction :

  • Doit être déclaré dans une classe ou un module
  • Retourne une valeur (spécifiée par le type de retour)
  • A un modificateur
  • Peut prendre des paramètres pour effectuer son traitement 
Private Function AddNumbers(X As Integer, Y As Integer) As Integer
    Return X + Y
End Function

Un nom de fonction, pourrait être utilisé comme déclaration de retour 

Function sealBarTypeValidation() as Boolean
    Dim err As Boolean = False

    If rbSealBarType.SelectedValue = "" Then
        err = True
    End If

    Return err
End Function

est la même chose que 

Function sealBarTypeValidation() as Boolean
    sealBarTypeValidation = False        

    If rbSealBarType.SelectedValue = "" Then
        sealBarTypeValidation = True
    End If

End Function

Initialiseurs d'objet

  • Types nommés 

     Dim someInstance As New SomeClass(argument) With {
     .Member1 = value1,
     .Member2 = value2
     '...
 }

    Est équivalent à 

     Dim someInstance As New SomeClass(argument)
 someInstance.Member1 = value1
 someInstance.Member2 = value2
 '...

  • Types anonymes (l'option Infer doit être activée) 

      Dim anonymousInstance = New With {
      .Member1 = value1,
      .Member2 = value2
      '...
  }

    Bien que similaire anonymousInstance ne pas même type que someInstance

    Le nom du membre doit être unique dans le type anonyme et peut provenir d'une variable ou d'un autre nom de membre d'objet 

      Dim anonymousInstance = New With {
      value1,
      value2,
      foo.value3
      '...
  }
  ' usage : anonymousInstance.value1 or anonymousInstance.value3

    Chaque membre peut être précédé du mot clé Key . Ces membres seront des propriétés ReadOnly , ceux sans seront des propriétés de lecture / écriture 

      Dim anonymousInstance = New With {
      Key value1,
      .Member2 = value2,
      Key .Member3 = value3
      '...
  }

    Deux instances anonymes définies avec les mêmes membres (nom, type, présence de Key et ordre) auront le même type anonyme. 

      Dim anon1 = New With { Key .Value = 10 }
  Dim anon2 = New With { Key .Value = 20 }

  anon1.GetType Is anon2.GetType ' True

    Les types anonymes sont structurellement équitables. Deux instances du même type anonyme ayant au moins une propriété Key avec les mêmes valeurs Key seront égales. Vous devez utiliser la méthode Equals pour le tester, utiliser = ne compilera pas et Is comparera la référence de l'objet. 

      Dim anon1 = New With { Key .Name = "Foo", Key .Age = 10, .Salary = 0 }
  Dim anon2 = New With { Key .Name = "Bar", Key .Age = 20, .Salary = 0 }
  Dim anon3 = New With { Key .Name = "Foo", Key .Age = 10, .Salary = 10000 }

  anon1.Equals(anon2) ' False
  anon1.Equals(anon3) ' True although non-Key Salary isn't the same

Les initialiseurs de types Named et Anonymous peuvent être imbriqués et mélangés 

    Dim anonymousInstance = New With {
        value,
        Key .someInstance = New SomeClass(argument) With {
            .Member1 = value1,
            .Member2 = value2
            '...
        }
        '...
    }

Initialiseur de collection

  • Tableaux 

     Dim names = {"Foo", "Bar"} ' Inferred as String()
 Dim numbers = {1, 5, 42} ' Inferred as Integer()

  • Conteneurs ( List(Of T) , Dictionary(Of TKey, TValue) , etc.) 

     Dim names As New List(Of String) From {
     "Foo",
     "Bar"
     '...
 }

 Dim indexedDays As New Dictionary(Of Integer, String) From {
     {0, "Sun"},
     {1, "Mon"}
     '...
 }

    Est équivalent à 

     Dim indexedDays As New Dictionary(Of Integer, String)
 indexedDays.Add(0, "Sun")
 indexedDays.Add(1, "Mon")
 '...

    Les éléments peuvent être le résultat d'un constructeur, d'un appel de méthode, d'un accès à une propriété. Il peut également être mélangé avec l'initialiseur d'objet. 

     Dim someList As New List(Of SomeClass) From {
     New SomeClass(argument),
     New SomeClass With { .Member = value },
     otherClass.PropertyReturningSomeClass,
     FunctionReturningSomeClass(arguments)
     '...
 }

    Il est impossible d'utiliser la syntaxe de l'initialiseur d'objet ET la syntaxe d'initialiseur de collection pour le même objet en même temps. Par exemple, cela ne fonctionnera pas 

     Dim numbers As New List(Of Integer) With {.Capacity = 10} _
                                     From { 1, 5, 42 }

 Dim numbers As New List(Of Integer) From {
     .Capacity = 10,
     1, 5, 42
 }

 Dim numbers As New List(Of Integer) With {
     .Capacity = 10,
     1, 5, 42
 }

  • Type personnalisé

    Nous pouvons également autoriser la syntaxe de l'initialiseur de collection en fournissant un type personnalisé.
    Il doit implémenter IEnumerable et avoir une méthode accessible et compatible avec les règles de surcharge Add (instance, méthode d'extension partagée ou même d'extension)

    Exemple contruit: 

     Class Person
     Implements IEnumerable(Of Person) ' Inherits from IEnumerable

     Private ReadOnly relationships As List(Of Person)

     Public Sub New(name As String)
         relationships = New List(Of Person)
     End Sub

     Public Sub Add(relationName As String)
         relationships.Add(New Person(relationName))
     End Sub

     Public Iterator Function GetEnumerator() As IEnumerator(Of Person) _
         Implements IEnumerable(Of Person).GetEnumerator

         For Each relation In relationships
             Yield relation
         Next
     End Function

     Private Function IEnumerable_GetEnumerator() As IEnumerator _ 
         Implements IEnumerable.GetEnumerator

         Return GetEnumerator()
     End Function
 End Class

 ' Usage
 Dim somePerson As New Person("name") From {
     "FriendName",
     "CoWorkerName"
     '...
 }

    Si nous voulions ajouter l'objet Person à une List(Of Person) en mettant simplement le nom dans l'initialiseur de collection (mais nous ne pouvons pas modifier la classe List (Of Person)), nous pouvons utiliser une méthode d'extension 

     ' Inside a Module
 <Runtime.CompilerServices.Extension>
 Sub Add(target As List(Of Person), name As String)
     target.Add(New Person(name))
 End Sub

 ' Usage
 Dim people As New List(Of Person) From {
     "Name1", ' no need to create Person object here
     "Name2"
 }


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow