FAQ VB.NETConsultez toutes les FAQ

Nombre d'auteurs : 36, nombre de questions : 239, dernière mise à jour : 24 mai 2015  Ajouter une question

 

Cette FAQ a été réalisée pour répondre aux questions les plus fréquemment posées sur le forum Développement DotNET

Je tiens à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle contient sont correctes. Les auteurs font le maximum, mais l'erreur est humaine. Si vous trouvez une erreur, ou que vous souhaitez devenir rédacteur, lisez ceci.

Sur ce, je vous souhaite une bonne lecture.


SommaireLe langage VB.NET (69)
précédent sommaire suivant
 

Voici la définition du .NET framework, communément appelé dotnet telle qu'elle apparait dans MSDN :

.NET Framework est le modèle de programmation de la plate-forme .NET. Les principaux composants de .NET Framework sont le Common Language Runtime et la bibliothèque de classes .NET Framework, qui contient ADO.NET, ASP.NET et Windows Forms. .NET Framework fournit un environnement d'exécution managé, un développement et un déploiement simplifiés et l'intégration à une grande variété de langages de programmation.

Il existe plusieurs versions du .NET framework.
Les dernières sont : .NET framework 4.0, 4.5 et 4.51.

Mis à jour le 4 décembre 2013 abelman

Visual Basic .NET (VB.NET) est la nouvelle génération du langage Visual Basic. Bien que les syntaxes de Visual Basic .NET et Visual basic restent sensiblement proche, Visual Basic .NET constitue une rupture totale avec Visual Basic.
Il intègre de nouvelles fonctionnalités telles que l'héritage, les interfaces, la surcharge des fonctions, ce qui en fait un langage orienté objet à part entière.

Par ailleurs, Visual Basic .NET dispose avec Visual Studio d'un IDE et d’assistants générateurs de code avancés.
C'est à ce jour, un des langages les plus simples pour construire des applications .NET

Mis à jour le 3 décembre 2013 abelman

Pour développer des applications en Visual Basic .Net vous avez le choix entre différentes solutions, et cela quelque soit la dimension de votre projet. Voici ce que vous propose Microsoft pour créer des applications Windows Form, Console, ASP.Net ou encore des Web Services.

Les versions gratuites de Visual Studio :
Visual Studio Express 2013

  • pour Windows ;
  • pour le Web ;
  • Desktop.

Les versions Express sont entièrement gratuites et disponibles au téléchargement, à l'adresse suivante : cliquez-ici (Accessible par : Obtenez Visual Studio)

Les versions payantes :
  • Visual Studio Professional 2013 ;
  • Visual Studio Professional 2013 avec MSDN ;
  • Visual Studio Premium 2013 avec MSDN ;
  • Visual Studio Ultimate 2013 avec MSDN.

Toutes ces versions s'appuient sur le Framework .Net.

Les versions Visual Studio et le framework en corrélation :
  • Visual Studio .NET — .NET Framework 1.0
  • Visual Studio 2003 — .NET Framework 1.1
  • Visual Studio 2005 — .NET Framework 2.0
  • Visual Studio 2005 — .NET Framework 3.0
  • Visual Studio 2008 — .NET Framework 3.5
  • Visual Studio 2010 — .NET Framework 4.0
  • Visual Studio 2012 — .NET Framework 4.5
  • Visual Studio 2013 — .NET Framework 4.5.1

Note (MSDN) : Visual Studio assure le multi-ciblage. Vous n'êtes pas limité à la version du .NET Framework répertoriée.
Les détails : Versions et dépendances du .NET Framework

Enfin, il est possible de développer des applications Visual Basic .NET en utilisant n'importe quel éditeur de texte pour écrire le code de son application.
Le compilateur (vbc.exe) en ligne de commande du framework.NET SDK peut ensuite être utilisé pour générer les binaires.
Noter que les Framework .NET SDK en version 1.1 ou 2.0 sont téléchargeables gratuitement aux adresses indiquées plus bas.

Mis à jour le 4 décembre 2013 abelman Webman

Les systèmes d'exploitation suivants supportent la conception et le déploiement d'applications .NET développées avec VB.NET.

Les plates-formes Windows 98, Windows 98 Deuxième Édition et Windows ME, Microsoft Windows NT 4.0 (pour VS.NET 2002) ne sont pas prises en charge pour la conception et le développement avec Visual Studio .NET.
Vous pouvez déployer des applications dans les environnements de plates-formes Windows 98 et Windows ME, Microsoft Windows NT 4.0 (Service Pack 6a requis).

L'installation du runtime Framework.NET est indispensable sur le poste cible.

  • Microsoft Windows 8 — .NET Framework 4.5 (inclut) ;
  • Microsoft Windows Server 2012 SP1 — .NET Framework 4.5 (inclut) ;
  • Microsoft Windows Seven SP1 — .NET Framework 3.5 SP1 (inclut) ;
  • Microsoft Windows Vista SP2 — .NET Framework 3.0 SP2 (inclut) ;
  • Microsoft Windows Server 2008 SP1 — .NET Framework 2.0 SP2 (inclut) ;
  • Microsoft Windows Server 2003 — .NET Framework 2.0 SP2 (inclut) ;
  • Windows XP Professionnel ;
  • Windows XP Édition familiale (Sans possibilité de création d'applications Web et de services WEB XML) ;
  • Windows 2000 Professionnel (Service Pack 3 ou version ultérieure requis) ;
  • Windows 2000 Server (Service Pack 3 ou version ultérieure requis) ;
  • Windows NT 4.0 (VSNET 2002 exclus).


Les détails : Versions et dépendances du .NET Framework

Mis à jour le 4 décembre 2013 abelman

Avec Visual Basic .NET, il est possible de créer différents types d'applications .NET telles que :

  • les applications Winforms ;
  • les applications console ;
  • les bibliothèques de types (DLL) ;
  • les services Windows ;
  • les services Web ;
  • les applications Web ;
  • les applications Windows Presentation Foundation (WPF).

Mis à jour le 4 décembre 2013 abelman

Note à l'attention des utilisateurs de VB6 :

  • l'indice de la borne inférieure d'un tableau vaut toujours 0 en VB.NET ;
  • le chiffre dans la parenthèse lors de la déclaration représente toujours l'indice de la borne supérieure du tableau ;
  • lors de l'allocation de la mémoire pour le tableau, les accolades contiennent les éléments du tableau.

Si le tableau est vide, alors les accolades sont vides.
  • Le nombre de dimensions d'un tableau est fixé à la déclaration et n'est pas modifiable par la suite.


Voici quelques exemples de déclarations et initialisations de tableaux :

Déclaration d'un tableau dont les dimensions sont inconnues au départ

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
Dim tableau As String() 
  
' Allocation de la mémoire pour ce tableau 
  
' Tableau non initialisé de dix strings. Dans ce cas chaque élément du tableau a la valeur par défaut du type. 
' Pour String c'est "". 
tableau = New String(9} {} 
' Tableau initialisé de deux strings. 
tableau = New String(1) {"Un", "Deux"}
Déclaration d'un tableau unidimensionnel non initialisé de 10 entiers

Code vb.net : Sélectionner tout
Dim tableau As Integer() = New Integer(9) {}
Déclaration d'un tableau unidimensionnel initialisé de 10 entiers

Code vb.net : Sélectionner tout
1
2
3
4
5
6
Dim tableau As Integer() = new Integer(9) {10,  11,  12,  13, 14, 15, 16, 17, 18, 19} 
' Pour parcourir le tableau 
Dim i As Integer 
For i = 0 to tableau.GetUpperBound(0) 
    Debug.Writeline(tableau(i)) 
Next
Déclaration d'un tableau bidimensionnel non initialisé de 4x3 entiers

Code vb.net : Sélectionner tout
Dim tableau As Integer(,) = new Integer(3, 2) {}
Déclaration d'un tableau bidimensionnel initialisé de 3x6 entiers

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
Dim tableau As Integer(,) = New Integer(2, 5) {{0, 1, 2, 3, 4, 5}, {6, 7, 8, 9, 10, 11}, {12, 13, 14, 15, 16, 17}} 
' Parcours du tableau 
Dim j,i As Integer 
For j = 0 To tableau.GetUpperBound(0) 
    For i  = 0 To tableau.GetUpperBound(1) 
        Console.WriteLine("({0},{1})={2}", j, i, tableau(j, i)) 
    Next 
Next
Et enfin on peut déclarer un tableau de tableaux comme ceci

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
' Sans initialisation 
Dim tableau As Integer()() 
' Allocation mémoire 
tableau = New Integer(1) (){New Integer(2) {0,1,2}, New Integer(1) {0,1}} 
' Avec initialisation 
Dim tableau As Integer()() = {New Integer(2) {0, 1, 2}, New Integer(5) {0, 1, 2, 3, 4, 5}} 
' Parcours du tableau 
Dim i ,j As Integer 
For j = 0 to tableau.GetUpperBound(0) 
    For i = 0 To tableau(j).GetUpperBound(0) 
        Console.WriteLine("({0},{1})={2}", j, i, tableau(j)(i)) 
    Next 
Next

Mis à jour le 11 décembre 2013 abelman

Pour mettre une seule instruction sur plusieurs lignes il faut utiliser le caractère « _ » comme ceci

Code vb.net : Sélectionner tout
1
2
3
4
Dim s As String 
s = "Un" & _ 
  "Deux" & _ 
  "Trois"
Pour mettre plusieurs instructions sur la même ligne

Code vb.net : Sélectionner tout
Dim i As integer : i=5

Mis à jour le 28 octobre 2013 abelman

Suite à une action utilisateur sur le clavier, nous devons parfois effectuer un long traitement. Et nous souhaiterions que les actions clavier ne soient pas enregistrées pendant ce traitement. Cette suspension peut être implémentée de la façon suivante

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Imports  System 
Imports  System.Windows.Forms 
' ... 
Private Sub maSaisie_KeyUp(ByVal sender As Object, ByVal e As KeyEventArgs) Handles maSaisie.KeyUp 
    ' Exemple après l'appui de la touche "Enter" 
    If e.KeyCode = Keys.Enter Then 
  
        ' Arrêter la capture d’événement clavier sur le contrôle 
        RemoveHandler Me.maSaisie.KeyUp, AddressOf Me.maSaisie_KeyUp 
  
        ' Traitements longs 
  
        ' Reprendre la capture d’événement clavier sur le contrôle 
        AddHandler Me.maSaisie.KeyUp, AddressOf Me.maSaisie_KeyUp 
  
    End If 
End Sub

Mis à jour le 17 novembre 2013 neguib

Bien souvent, il est nécessaire de limiter le type de caractères qu'un utilisateur peut saisir. On ne voudrait pas, par exemple, qu'il puisse saisir des lettres dans un TextBox prévu pour un code postal ou un numéro de téléphone.
Néanmoins, on doit pouvoir autoriser la saisie de certains caractères spéciaux comme la virgule dans un nombre décimal par exemple.

Dans l'exemple suivant, nous allons créer une méthode qui permet la saisie d'un nombre décimal dans un TextBox en autorisant la saisie d'une virgule.

Commençons par créer la méthode :

Code vb.net : Sélectionner tout
1
2
3
Public Sub myFiltre(ByVal e As System.Windows.Forms.KeyPressEventArgs, ByVal autorise As String) 
    e.Handled = Not (Char.IsDigit(e.KeyChar) Or Char.IsControl(e.KeyChar) Or e.KeyChar = autorise) 
End Sub
Pour appeler cette méthode nous allons utiliser l'événement KeyPress de notre TextBox :

Code vb.net : Sélectionner tout
1
2
3
Private Sub myTextBox_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles myTextBox.KeyPress 
    myFiltre(e, ",") 
End Sub
Pour la saisie d'une date au format jj/mm/aa nous aurions pu appeler la méthode de cette façon :

Code vb.net : Sélectionner tout
myFiltre(e, "/")

Mis à jour le 28 octobre 2013 Cyrilange

Rien de tel qu'un exemple concret pour voir comment formater une date pour l'affichage :

Code vb.net : Sélectionner tout
1
2
Dim dt As New DateTime(1978, 5, 18) 
dt.ToString(param)
Voici les différents résultats que l'on obtient suivant la valeur de param :
  • "d" : 18/5/1978" ;
  • "D" : "jeudi 15 mai 1978" ;
  • "f" : "jeudi 15 mai 1978 08:05" ;
  • "F" : "jeudi 15 mai 1978 08:05:01" ;
  • "g" : "18/5/1978 08:05" ;
  • "G" : "18/5/1978 08:05:01" ;
  • "M" : "18 mai" ;
  • "R" : Date GMT en anglais --> Thu, 14 may 1978 09:05:01 GMT ;
  • "s" : Date pour les tris --> 1978-05-18T09:05:01 ;
  • "t" : "08:05" ;
  • "T" : "08:05:01" ;
  • "u" : même chose que s mais en temps GMT.

Et pour les formats personnalisés :
  • d : jour 1 à 31 ;
  • dd : jour 01 à 31 ;
  • ddd : abréviation d'un jour ex: sam. pour samedi ;
  • dddd : nom complet du jour ;
  • M : mois 1 à 12 ;
  • MM : mois 01 à 12 ;
  • MMM : abr d'un moi ax:jan. pour janvier ;
  • MMMM : nom complet du mois ;
  • y : année 1 à 99 ;
  • yy : année 01 à 99 ;
  • yyy : année 1 à 9999 ;
  • h : heure 0 à 11 ;
  • hh : heure 00 à 11 ;
  • H : heure 0 à 23 ;
  • HH : heure 00 à 23 ;
  • m : minute 0 à 59 ;
  • mm : minute 00 à 59 ;
  • s : seconde 0 à 59 ;
  • ss : seconde 00 à 59.

Code vb.net : Sélectionner tout
dt.ToString("dddd, le d MM yyyy")
Donnera : Jeudi, le 18 05 1978

Mis à jour le 28 octobre 2013 neo.51

Tout d'abord, ajoutez en entête de votre classe :

Code vb.net : Sélectionner tout
Imports System.Text.RegularExpressions
Un exemple vaut mieux qu'un long discours :
Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
Dim monTexte As String = "Une astuce de dvp.com ! Une astuce de dvp.com !"  
  
' Paramétrage de notre expression régulière :  
' Ici on spécifie que l'on ne veut pas tenir compte dela casse du  
' texte dans nos remplacements.  
Dim maRegEx As New Regex("\bdvp.com\b", RegexOptions.IgnoreCase)  
  
' Remplacement des occurences de "dvp.com" par "Developpez.com"  
monTexte = maRegEx.Replace(monTexte, "Developpez.com")

Mis à jour le 28 octobre 2013 Webman

Une classe partielle est tout simplement une classe dont la définition est séparée dans plusieurs fichiers sources distincts.

Exemple :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
' Fichier MaClasse.1.vb 
Public Partial Class MaCLasse 
    Private infos As List(Of String) 
End Class 
  
' Fichier MaClasse.2.vb 
Public Partial Class MaCLasse 
    Public Sub New() 
        Me.infos = New List(Of String)() 
    End Sub 
End Class

Mis à jour le 28 octobre 2013 dev01

Tout d'abord, ajoutez en entête de votre classe :

Code vb.net : Sélectionner tout
Imports System.Diagnostics
Ensuite, ajoutez ceci dans la partie de code qui vous intéresse :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
' Instanciation d'un objet StopWatch 
Dim monStopWatch As New Stopwatch 
  
' Déclenchement du "chronomètre" 
monStopWatch.Start() 
  
' /////////////////////////////// 
' Placez ici le code que vous voulez évaluer, cela peut être par exemple  
' du code 'brut' ou alors l'appel d'un méthode... 
' /////////////////////////////// 
  
' Arrêt du "chronomètre" 
monStopWatch.Stop() 
  
' Le temps écoulé peut être récupéré très facilement avec un membre de StopWatch, 
' de la façon suivante. Le résultat est exprimé en millisecondes 
Dim tempsExecution As Long 
tempsExecution = monStopWatch.ElapsedMilliseconds

Mis à jour le 17 novembre 2013 Webman

Voici une méthode permettant de convertir un tableau de bytes en image :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
Public Shared Function ByteArray2Image(ByVal BArray As Byte()) As Image 
    Try 
        Dim mstImage As MemoryStream = New MemoryStream(BArray) 
        Dim img As Image = Image.FromStream(mstImage) 
        Return img 
    Catch ex As Exception 
        Return Nothing 
    End Try 
End Function

Mis à jour le 1er décembre 2013 sam_XIII

Voici une méthode permettant de convertir une image (ici au format Jpeg) en un tableau de bytes :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
Public Shared Function Image2ByteArray(ByVal img As Image) As Byte() 
    Try 
        Dim mstImage As MemoryStream = New MemoryStream 
        img.Save(mstImage, System.Drawing.Imaging.ImageFormat.Jpeg) 
        Dim bytImage As Byte() = mstImage.GetBuffer 
        Return bytImage 
    Catch ex As Exception 
        Return Nothing 
End Try 
End Function

Mis à jour le 1er décembre 2013 sam_XIII

FlagsAttribute permet de définir si une énumération peut être traitée comme un champ de bits. Généralement, les éléments d'une énumération sont mutuellement exclusifs. Dans certain cas, ils peuvent être combinés dans un masque de bits que l'on obtient par combinaison à l'aide de OR.
Toutefois attention. C'est à vous de définir des valeurs permettant de traiter correctement un masque de bits. Prenons l'exemple suivant :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Module Module1 
    <Flags()> Enum MonEnum As Integer 
        PosUn = 1 
        PosDeux = 2 
        PosTrois = 3 
        PosQuatre = 4 
    End Enum 
  
    Sub Main() 
        Dim MaVar As MonEnum = MonEnum.PosUn Or MonEnum.PosDeux 
        Console.WriteLine(MaVar.ToString) 
    End Sub 
  
End Module
Dans ce cas la console renvoie PosTrois, ce qui est faux puisque le fait de mettre les bits 1 et 2 à vrai n'induit pas que le bit 3 l'est. Vous devez déclarer l'énumération telle que :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
<Flags()> Enum MonEnum As Integer 
    PosUn = 1 
    PosDeux = 2 
    PosTrois = 4 
    PosQuatre = 8 
End Enum
Pour que la console renvoie bien PosUn, PosDeux. Si vous n'avez pas l'habitude de manipuler des masques de bits, le FrameWork met à votre disposition une structure BitVector32 plus facile à appréhender.

Mis à jour le 28 octobre 2013 bidou

Pour manipuler les évènements dans Visual Basic, il faut procéder aux étapes suivantes

  • Création d'un argument personnalisé si besoin est ;
  • Déclaration d'un délégué dans la classe générant l'évènement ;
  • Déclaration de l'évènement dans la classe générant l'évènement ;
  • Consommation de l'évènement.

Imaginons la classe très simple suivante :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Public Class Personne 
  
    Private m_Nom, m_Prenom As String 
    Private m_BirthDay As Date 
  
    Public Sub New(ByVal Nom As String, ByVal Prenom As String, ByVal Birthday As Date) 
        m_Nom = Nom 
        m_Prenom = Prenom 
        m_BirthDay = Birthday 
    End Sub 
  
    Public ReadOnly Property Identite() As String 
        Get 
            Return Me.m_Nom & " " & Me.m_Prenom 
        End Get 
    End Property 
  
    Public ReadOnly Property Age() As Int32 
        Get 
            Return DateDiff(DateInterval.Year, m_BirthDay, Now.Date, FirstDayOfWeek.Monday, FirstWeekOfYear.Jan1) 
        End Get 
    End Property 
  
End Class
Je souhaite qu'un évènement se déclenche si c'est l'anniversaire de mon objet personne.
Dans cet exemple, je vais créer un argument particulier HappyBirthDayEventArgs qui contiendra l'âge de la personne. Cet argument sera de la forme

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Public Class HappyBirthDayEventArgs 
    Inherits System.EventArgs 
  
    Private m_Age As Int32 
  
    Public Sub New(ByVal MonAge As Int32) 
        m_Age = MonAge 
    End Sub 
  
    Public ReadOnly Property Age() As Int32 
        Get 
            Return m_Age 
        End Get 
    End Property 
End Class
Au début de la classe 'Personne' je dois ajouter un délégué. Un délégué est un pointeur de fonction qui doit reprendre exactement la signature de la fonction qu'il cible. Pour schématiser, c'est le délégué qui permet de faire la liaison entre l'évènement et le gestionnaire d'évènement.
Je dois aussi déclarer l'évènement dans ma classe. J'aurais donc :

Code vb.net : Sélectionner tout
1
2
3
4
5
Public Class Personne 
  
Delegate Sub HappyBirthDayEventHandler(ByVal sender As Object, ByVal e As HappyBirthDayEventArgs) 
Public Event HappyBirthDayEvent As HappyBirthDayEventHandler 
...
Je vais modifier ma propriété Age de la classe personne pour lever l'évènement :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
Public ReadOnly Property Age() As Int32 
    Get 
        If Me.m_BirthDay.Day = Now.Day AndAlso Me.m_BirthDay.Month = Now.Month Then 
            RaiseEvent HappyBirthDayEvent(Me, New HappyBirthDayEventArgs(DateDiff(DateInterval.Year, m_BirthDay, Now.Date, FirstDayOfWeek.Monday, FirstWeekOfYear.Jan1))) 
        End If 
            Return DateDiff(DateInterval.Year, m_BirthDay, Now.Date, FirstDayOfWeek.Monday, FirstWeekOfYear.Jan1) 
    End Get 
End Property
Je peux alors consommer l'évènement, par exemple :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
Private Sub Button1_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles Button1.Click 
    Dim bidou As New Personne("Rabilloud", "Jean-Marc", #10/12/1967#) 
    AddHandler bidou.HappyBirthDayEvent, AddressOf Anniversaire 
    Dim MonAge As Int32 = bidou.Age 
End Sub 
  
Private Sub Anniversaire(ByVal sender As Object, ByVal e As HappyBirthDayEventArgs) 
    MsgBox("aujourd'hui " & CType(sender, Personne).Identite & " a " & e.Age.ToString & " ans") 
End Sub

Mis à jour le 28 octobre 2013 bidou

En VB.NET il existe deux méthodes pour gérer la gestion d'évènements. L'utilisation du mot clé WithEvents et de la clause Handles permet un abonnement statique au gestionnaire d'évènements. Il est statique dans le sens qu'il a lieu lors de la compilation et qu'il n'est pas possible de se désabonner. Dans le principe on déclare l'objet avec le mot clé WithEvents

Code vb.net : Sélectionner tout
Friend WithEvents txtEntree1 As System.Windows.Forms.TextBox
Et on s'abonne à l'évènement par la clause Handles

Code vb.net : Sélectionner tout
Private Sub cmdSomme_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles cmdSomme.Click
Notez que l'on peut abonner plusieurs objets à un même évènement en séparant ceux-ci par une virgule dans la clause Handles, tel que :

Code vb.net : Sélectionner tout
1
2
Private Sub txtEntree_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs)  
  Handles txtEntree1.KeyPress, txtEntree2.KeyPress
Les instructions AddHandler et RemoveHandler sont une approche dynamique des gestionnaires d'évènements. L'abonnement par AddHandler a lieu lors de l'exécution et il est possible de se désabonner avec RemoveHandler.
Imaginons comme exemple, un bouton qui ne marcherait qu'une fois :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load 
    ' Je m'abonne 
    AddHandler Button1.Click, AddressOf BoutonUnClick 
End Sub 
  
Private Sub BoutonUnClick(ByVal sender As System.Object, ByVal e As System.EventArgs) 
    MsgBox("ce bouton ne marche qu'une fois") 
    ' Je me désabonne 
    RemoveHandler Button1.Click, AddressOf BoutonUnClick 
End Sub

Mis à jour le 17 novembre 2013 bidou

Comme toute autre classe, vous pouvez créer vos propres Exception. De l'ancêtre Exception, héritent deux classes, SystemException et ApplicationException. Par convention, vous devez hériter d'ApplicationException.
Par exemple, je veux lever une exception si on attribue une chaîne vide à une valeur de clés. Je crée l'exception :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
Public Class ChaineVideException 
    Inherits ApplicationException 
  
    Public Sub New() 
        MyBase.New() 
    End Sub 
  
    Public Sub New(ByVal message As String) 
        MyBase.New(message) 
    End Sub 
  
End Class
Puis pour la lever j'utilise :

Code vb.net : Sélectionner tout
1
2
3
4
5
Sub New(ByVal NomCle As String, ByVal Valeur As String) 
    MyBase.New() 
    If Valeur.Length = 0 Then Throw New ChaineVideException("Vous ne pouvez pas attribuer une chaine vide comme valeur de clé") 
    MyBase.Add(NomCle, Valeur) 
End Sub

Mis à jour le 28 octobre 2013 bidou

En premier lieu, il faut savoir que le decimal possède une limite d'affichage de 28 digits significatifs. Au delà, le chiffre sera arrondi à cette limite.

En second lieu, l'utilisation de la méthode surchargée ToString() prend un paramètre format (par exemple ici de type "N") fixe. Ce qui est ennuyeux lorsqu'on ne peut anticiper le nombre de chiffres après la virgule.

Nous proposons ici l'implémentation d'une méthode qui permet de déterminer le format N de façon dynamique. Et par là même, nous montrons l'utilisation de la classe NumberFormatInfo.

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Imports System.Globalization 
  
Private Shared Function SetFormat(ByVal d As Decimal, ByVal nfi As NumberFormatInfo) As String 
    Dim format As String= "N" 
    Dim sep As String 
    sep = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator 
  
    Try 
        Dim s As String = d.ToString() 
        Dim i As Integer = s.IndexOf(sep) 
  
        If i >= 0 Then: format &= (s.Length - i - 1).ToString() 
        Else: format &= 0.ToString() 
        End If 
    Catch(ex As Exception) 
        Console.WriteLine(ex.Message) 
    End Try 
    Return d.ToString(format,nfi) 
End Function

Mis à jour le 30 novembre 2013 neguib

Depuis l'arrivée du Framework 2.0, la classe ConfigurationSettings est devenue obsolète. Il faut utiliser à la place la classe ConfigurationManager. Le Framework 2.0 possède un nouveau fichier System.Configuration.dll qui n'est pas inclus par défaut dans les références.

Il ne faut donc pas oublier d'ajouter cette librairie dans la liste des références de votre projet.

Mis à jour le 30 novembre 2013 StormimOn

Afin d'avoir une variable accessible de n'importe quel endroit de son application il faut la déclarer Shared.

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Public Class Configuration 
  
    Private Shared _StringConnection As String = "" 
  
    Public Shared Property StringConnection() As String 
        Get 
            Return _StringConnection 
        End Get 
        Set(ByVal value As String) 
            _StringConnection = value 
        End Set 
    End Property 
  
End Class
Ce code permet d'avoir une variable globale et un accès « propre » et sécurisé.

Mis à jour le 28 octobre 2013 Olivier Delmotte

Une propriété est définie ainsi :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Public Class A 
  
    Private _MaVariable As String = "" 
  
    Public Property MaVariable() As String 
        Get 
            Return _MaVariable 
        End Get 
        Set(ByVal value As String) 
            _MaVariable = value 
        End Set 
    End Property 
  
End Class

Mis à jour le 28 octobre 2013 Olivier Delmotte

Nous avons vu dans cette FAQ comment lire un fichier avec les classes XPath. Dans le cas de la présence de namespace dans le fichier Xml, nous avons utilisé la classe XmlNamespaceManager pour gérer ces espaces de noms. Le seul défaut c'est que nous alimentions manuellement ces données, nous allons donc maintenant créer ce XmlNamespaceManager de manière automatique.

Fichier Xml utilisé pour l'exemple

Code xml : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
<rd:Recordbook xmlns:rd="http://myexemple/myschema/record"> 
    <rd:Records> 
        <rd:Record> 
            <rd:FirstValue>10</rd:FirstValue> 
            <rd:SecondValue>51</rd:SecondValue> 
        </rd:Record> 
        <rd:Record> 
            <rd:FirstValue>25</rd:FirstValue> 
            <rd:SecondValue>38</rd:SecondValue> 
        </rd:Record> 
    </rd:Records> 
</rd:Recordbook>
Son implémentation :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Imports System.Collections.Generic 
Imports System.Xml 
Imports System.Xml.XPath 
  
Private Function GetXmlNamespaceManager(ByVal nav As XPathNavigator) _ 
    As XmlNamespaceManager 
    Dim mgr As XmlNamespaceManager = Nothing 
  
    nav.MoveToFirstChild 
    For Each keyPair As KeyValuePair(Of String, String) In _ 
        nav.GetNamespacesInScope(XmlNamespaceScope.Local) 
        If mgr Is Nothing Then 
            mgr = New XmlNamespaceManager(nav.NameTable) 
        End If 
        mgr.AddNamespace(keyPair.Key, keyPair.Value) 
    Next 
    nav.MoveToRoot 
    Return mgr 
End Function 
  
Private Sub TraiteXml(ByVal fileName As String) 
    Dim doc As XPathDocument = New XPathDocument(fileName) 
    Dim nav As XPathNavigator = doc.CreateNavigator 
    Dim mgr As XmlNamespaceManager = GetXmlNamespaceManager(nav) 
  
    If Not (mgr Is Nothing) Then 
        Dim iter As XPathNodeIterator = nav.Select _ 
        ("rd:Recordbook/rd:Records/rd:Record", mgr) 
        While iter.MoveNext 
            Dim firstValue As String = iter.Current.SelectSingleNode _ 
            ("rd:FirstValue", mgr).Value 
            Dim secondValue As String = iter.Current.SelectSingleNode _ 
            ("rd:SecondValue", mgr).Value 
        End While 
    End If 
End Sub

Mis à jour le 28 octobre 2013 StormimOn

Une propriété est une façon d'accéder à une variable de manière simple en lecture et/ou écriture. Elles sont utilisées dans les cas où l'accès est fait sans traitement « lourd ». D'après les bonnes pratiques de Microsoft, elles ne doivent pas renvoyer de collection (par exemple : string() ).

Mis à jour le 28 octobre 2013 dev01

Il suffit d'utiliser la variable prédéfinie par le framework

Code vb.net : Sélectionner tout
Dim monTexte As String = "du texte" & Environment.NewLine & "du texte ..."

Mis à jour le 16 novembre 2013 dev01

Lors du chargement d'une image dans un PictureBox avec la fonction Image.FromFile, le fichier sous-jacent se trouve en utilisation et donc non disponible jusqu'à la fermeture de l'application. Il est ainsi par exemple impossible de le supprimer.

Pour pallier ce problème, il faut en conséquence pouvoir libérer la ressource du flux sur ce fichier.

Plusieurs solutions permettent d'atteindre cet objectif. Nous vous proposons ici celui de gérer directement le flux et notamment par l'implémentation de la méthode Image.FromStream.

L'exemple suivant charge une image via un FileStream, l'affecte à un PictureBox (appelé pictureBox1) par Image.FromStream, puis libère les ressources du flux (appelé photoStream) sur le fichier pour pouvoir le supprimer :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
' Créer le FileStream sur le fichier monimage.jpeg 
Dim photoStream As FileStream = New FileStream("C:\monimage.jpeg", FileMode.Open) 
' Affecter l'image à pictureBox1 
pictureBox1.Image = Image.FromStream(photoStream) 
' Libérer les ressources 
photoStream.Close 
' Supprimer le fichier monimage.jpeg 
File.Delete("C:\monimage.jpeg")

Mis à jour le 30 novembre 2013 neguib

Il faudra tout d'abord importer l'assembly System.Management. Pour récupérer une valeur, il faudra utiliser la méthode GetPropertyValue associée à un nom de propriété.

L'exemple suivant commence par lister toutes les propriétés existantes puis récupère la valeur de la propriété VolumeSerialNumber.

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Imports System.Management 
  
Dim disque As ManagementObject = New ManagementObject("win32_logicaldisk.deviceid="c:"") 
disque.Get() 
  
' Afficher toutes les propriétés du disque 
Dim strProp As String = "" 
For Each d As PropertyData In disque.Properties 
    strProp &= d.Name & "" & Environment.NewLine & "" 
Next 
  
MessageBox.Show(strProp) 
  
' Obtenir une propriété en particulier 
strProp = disque.GetPropertyValue("VolumeSerialNumber").ToString 
MessageBox.Show("n° série volume : " & strProp)

Mis à jour le 28 octobre 2013 dev01

L'intérêt est ici d'implémenter de façon appropriée la récursivité. L'espace de noms privilégié est System.IO, notamment sa classe Directory. Pour l'exemple nous allons explorer le répertoire particulier des « Favoris », ce qui nous permet à ce propos de nous inspirer de la Q/R d'abelman : Comment obtenir la liste des fichiers et des sous-répertoires d'un répertoire ?

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
''' <summary> 
'''      Méthode résursive qui affiche tous les dossiers, sous-dossiers 
'''      et fichiers d'un répertoire 
''' </summary> 
''' <param name="folder">String : chemin du dossier à explorer</param> 
''' <param name="indent"> 
    '''  Int32 : représente le nombre d'espaces à écrire pour indentation 
''' </param> 
Private Shared Sub WriteFileEntries(ByVal folder As String, ByVal indent As Int32) 
    ' Créer une indentation du texte 
    Dim tab As StringBuilder = New StringBuilder([String].Empty) 
    For i As Integer = 0 To indent - 1 
        tab.Append(" ") 
    Next 
    ' Afficher les dossiers présents et leur contenu par récursivité 
    Dim subdirs As String() = Directory.GetDirectories(folder) 
  
    ' SI le dossier contient des sous-dossiers 
    If subdirs.Length <> 0 Then 
        For Each s As String In subdirs 
            ' Afficher le nom du dossier à explorer 
            Console.WriteLine(tab.ToString() + Path.GetFileName(s)) 
            ' Utiliser la récursivité avec une indentation 
            WriteFileEntries(s, indent + 3) 
        Next 
    End If 
  
    ' Afficher les noms des fichiers présents 
    Dim files As String() = Directory.GetFiles(folder) 
    ' Si le dossier contient des fichiers 
    If files.Length <> 0 Then 
        For Each s As String In files 
            Console.WriteLine(tab.ToString() + Path.GetFileName(s)) 
        Next 
    End If 
End Sub

Mis à jour le 6 décembre 2013 neguib

Il peut être intéressant de faire en sorte que ses classes personnelles puissent être parcourues grâce au mot clé for each.

Pour ceci, il faut que la classe soit en mesure de fournir un objet IEnumerator et implémente l'interface IEnumerable afin de surcharger les méthodes MoveNext et Reset tout en permettant l'accès à la propriété Current.

Une solution est d'avoir une classe implémentant les interfaces IEnumerable et IEnumerator. Voici l'exemple d'une classe MyString, qui en l'occurence permet le parcours d'une chaîne avec for each (ce qui sert bien sur uniquement d'exemple, dans la mesure où la classe String le permet déjà).

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
Imports System.Collections 
  
Public Class MyString 
    Implements System.Collections.IEnumerable 
    Implements System.Collections.IEnumerator 
  
    Private string_ As String 
    Private i As Integer 
  
    Sub New() 
        string_ = "" 
        i = -1 
    End Sub 
  
    Sub New(ByVal c As String) 
        string_ = c 
        i = -1 
    End Sub 
  
    Public Function GetEnumerator() As System.Collections.IEnumerator 
        Implements System.Collections.IEnumerable.GetEnumerator 
        Return Me 
    End Function 
  
    Public ReadOnly Property Current() As Object Implements 
        System.Collections.IEnumerator.Current 
        Get 
            Return string_(i) 
        End Get 
    End Property 
  
    Public Function MoveNext() As Boolean Implements 
        System.Collections.IEnumerator.MoveNext 
        If i < string_.Length - 1 Then 
            i = i + 1 
            Return True 
        End If 
        Return False 
    End Function 
  
    Public Sub Reset() Implements System.Collections.IEnumerator.Reset 
    End Sub 
End Class 
  
Module Module1 
  
    Sub Main() 
        Dim maChaine As New MyString("abcd") 
        Dim c As Object 
        For Each c In maChaine 
            Console.WriteLine(c) 
        Next 
    End Sub 
  
End Module
On remarquera la méthode GetEnumerator qui renvoie Me.

Une autre solution pourrait être d'utiliser une structure Nested implémentant IEnumerator.

Mis à jour le 28 octobre 2013 nico-pyright(c)

On utilise le mot réservé ParamArray pour passer un nombre variable d'arguments à une fonction. Pour ce qui est de pouvoir passer des types différents, il suffit d'utiliser Object étant donné que tout type dérive de cette classe :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
Shared Sub Main()  
     MaFonctionVariableEnType("Bonjour")  
     MaFonctionVariableEnType("Bonjour", 2007)  
     MaFonctionVariableEnType("Bonjour", 2007, True)  
     MaFonctionVariableEnType("Bonjour", 2007, True, 10.1)  
End Sub  
Shared Sub MaFonctionVariableEnType(ByRef ParamArray MesParams As Object())  
    For Each courantObject As Object In MesParams  
        Console.WriteLine("Valeur du paramètre : {0}", courantObject)  
    Next  
End Sub

Mis à jour le 28 octobre 2013 Jérôme Lambert

On utilise le mot réservé params pour passer un nombre variable d'arguments à une fonction :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
Shared Sub Main()  
    MaFonctionVariable("Bonjour")  
    MaFonctionVariable("Bonjour", "Au revoir")  
End Sub  
  
Shared Sub MaFonctionVariable(ByRef ParamArray MesParams As String())  
    For Each courantString As String In MesParams  
        Console.WriteLine("Valeur du paramètre : {0}", courantString)  
    Next  
End Sub

Mis à jour le 28 octobre 2013 Jérôme Lambert

Il suffit d'utiliser const devant la déclaration de la variable. L'initialisation devra se faire en même temps que la déclaration car il ne sera plus possible de modifier la valeur de la variable par après :

Code vb.net : Sélectionner tout
const int maConstante = 2007;

Mis à jour le 28 octobre 2013 Jérôme Lambert

La classe Interlocked fournit des méthodes afin d'effectuer des opérations mathématiques de manière atomique lorsque plusieurs threads se partagent des variables.

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Dim SharedValue As Integer = 100 
  
' Addition 
Interlocked.Add(SharedValue, 10)  
' Soustraction 
Interlocked.Add(SharedValue, -10) 
' Incrémentation 
Interlocked.Increment(SharedValue)  
' Décrémentation 
Interlocked.Decrement(SharedValue) 
' Copie 
Dim SharedValue2 As Integer = 50  
Interlocked.Exchange(SharedValue, SharedValue2)  
  
' Comparaison et Copie 
' Comparaison entre paramètres 1 et 3 
' si égalité, SharedValue = 100 
Interlocked.CompareExchange(SharedValue, 100, 50)  
  
' Lecture 
Dim SharedValueLong As Long = 30  
Dim ValueSafe As Long = Interlocked.Read(SharedValueLong)
À noter que les membres de cette classe ne lèvent pas d'exception.

Mis à jour le 30 novembre 2013 Jérôme Lambert

La ligne suivante permet de mettre un terme à la tranche de temps que le Thread a pour utiliser le processeur :

Code vb.net : Sélectionner tout
Thread.Sleep(0)

Mis à jour le 28 octobre 2013 Jérôme Lambert

Il suffit de la qualifier du mot réservé NotInheritable.

Code vb.net : Sélectionner tout
1
2
3
NotInheritable Class ClassImpossibleAHeriter  
   ' ... 
End Class

Mis à jour le 28 octobre 2013 Jérôme Lambert

La classe Stack vous permet de stocker une liste d'objets et les récupérer avec la technique LIFO (Last In First Out) - Dernier arrivé, premier retiré - tout simplement comme une pile.

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
' Création de la pile 
Dim maPile As Stack = New Stack  
  
' Ajout de 2 entiers 
maPile.Push(5)  
maPile.Push(10)  
' Affiche succesivement 10 puis 5 
Console.WriteLine("Valeur {0}", maPile.Pop)  
Console.WriteLine("Valeur {0}", maPile.Pop)

Mis à jour le 30 novembre 2013 Jérôme Lambert

Code vb.net : Sélectionner tout
1
2
' maValeurHexa contient 64 
Dim maValeurHexa as Integer = 0x40;

Mis à jour le 28 octobre 2013 Jérôme Lambert

En VB.Net, il est possible d'accéder aux membres de l'objet courant par l'intermédiaire du mot réservé Me :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Class ExempleMe  
    Private MonString As String  
  
    Public Sub New()  
        MonString = "Hello"  
    End Sub  
  
    Private Function ReturnWorld() As String  
        Return "World"  
    End Function  
  
    Public Sub DisplayHelloWorld()  
        Dim message As String = Me.MonString & " " & Me.ReturnWorld  
        Console.WriteLine(message)  
    End Sub  
End Class

Mis à jour le 28 octobre 2013 Jérôme Lambert

La classe Monitor permet à un thread de mettre un verrou sur des objets. Ainsi, aucun autre thread ne pourra mettre son verrou sur les objets déjà verrouillés.

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
' Met un verrou sur this 
Monitor.Enter(Me)  
  
' ... 
  
' Retire le verrou sur this 
Monitor.Exit(Me)

Mis à jour le 30 novembre 2013 Jérôme Lambert

La classe Type est la base de la réflexion. Elle permet d'obtenir des informations concernant un type donné comme les constructeurs, méthodes, champs, évènements.

Le mot clé GetType, quant à lui, permet de récupérer une instance de la classe Type par rapport au type de la classe passé en paramètre.

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Public Shared Sub Main()  
    For Each Mi As MemberInfo In GetType(Customer).GetMembers  
        If Mi.MemberType = MemberTypes.Method Then  
            Console.WriteLine("Méthode : {0}", Mi.ToString)  
        Else  
            If Mi.MemberType = MemberTypes.Field Then  
                Console.WriteLine("Champs : {0}", Mi.ToString)  
            Else  
                If Mi.MemberType = MemberTypes.Constructor Then  
                    Console.WriteLine("Constructeur : {0}", Mi.ToString)  
                End If  
            End If  
        End If  
    Next  
End Sub  
  
Public Class Customer  
    Public Id As Integer  
    Public Name As String  
  
    Public Sub MethodA(ByVal paramA As String, ByVal paramB As Integer)  
    End Sub  
End Class

Mis à jour le 28 octobre 2013 Jérôme Lambert

Il existe 2 solutions pour déterminer si un objet est d'un type donné :

La première est d'utiliser le mot clé is Ce dernier renvoie vrai si la condition est vérifiée :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
Dim monString As String = "Ceci est un test !"  
  
If TypeOf monString Is String Then  
    Console.WriteLine("monString est bien de type String !")  
Else  
    Console.WriteLine("monString n'est pas de type String !")  
End If
La seconde solution est d'utiliser as La différence est que as va faire le casting en même temps. Si le casting n'est pas possible, null sera renvoyé :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Class Customer  
End Class  
  
Class Vendor  
End Class  
  
Public Shared Sub Main()  
    Dim obj As Object = New Vendor  
    Dim testCustomer As Object = CType(ConversionHelpers.AsWorkaround(obj, GetType(Customer)), Customer)  
    Dim testVendor As Object = CType(ConversionHelpers.AsWorkaround(obj, GetType(Vendor)), Vendor)  
  
    If testCustomer Is Nothing Then  
        Console.WriteLine("L'objet testé n'est pas de type Customer !")  
    Else  
        Console.WriteLine("L'objet testé est de type Customer !")  
    End If  
    If testVendor Is Nothing Then  
        Console.WriteLine("L'objet testé n'est pas de type Vendor !")  
    Else  
        Console.WriteLine("L'objet testé est de type Vendor !")  
    End If  
End Sub

Mis à jour le 28 octobre 2013 Jérôme Lambert

Avec la version 2 du Framework, il est apparu la classe StopWatch qui permet de mesurer un intervalle de temps avec grande précision :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
Dim maMesureDeTemps As Stopwatch = New Stopwatch  
' Démarrage de l'intervalle de temps 
maMesureDeTemps.Start  
' ... 
' Fin de l'intervalle de temps 
maMesureDeTemps.Stop  
Console.WriteLine("L'exécution du code a pris : {0}", maMesureDeTemps.Elapsed.ToString)

Mis à jour le 30 novembre 2013 Jérôme Lambert

La classe Queue vous permet de stocker une liste d'objets et les retirer avec la technique FIFO (First In First Out) - Premier arrivé, premier retiré - tout simplement comme une file.

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
' Création de la file 
Dim maFile As Queue = New Queue  
  
' Ajout de 2 chaînes de caractères 
maFile.Enqueue("Bonjour")  
maFile.Enqueue("Au revoir")  
' Affiche succesivement "Bonjour" puis "Au revoir" 
Console.WriteLine("Valeur {0}", maFile.Dequeue)  
Console.WriteLine("Valeur {0}", maFile.Dequeue)

Mis à jour le 30 novembre 2013 Jérôme Lambert

La méthode Main est le point d'entrée de tout programme. Il existe 4 signatures différentes :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Class DifferentsMain  
  
    ' Méthode sans paramètres 
    ' Ni code de retour 
    Public Shared Sub Main()  
    End Sub  
  
    ' Méthode sans paramètres 
    ' Avec code de retour 
    Public Shared Function Main() As Integer  
        Return 0  
    End Function  
  
    ' Méthode avec paramètres 
    ' Mais sans code de retour 
    Public Shared Sub Main(ByRef ParamArray param As String())  
    End Sub  
  
    ' Méthode avec paramètres 
    ' Et code de retour 
    Public Shared Function Main(ByRef ParamArray param As String()) As Integer  
        Return param.Length  
    End Function  
End Class
Contrairement à ce que vous pourriez penser, il n'y a pas 6 signatures possibles mais bien 4 car il n'est pas possible d'utiliser la classe de base Object à la place de String.

Mis à jour le 28 octobre 2013 Jérôme Lambert

Grâce à la redéfinition de l'opérateur - (mais aussi de +, ==, !=, >, >=, <, <=) avec la classe TimeSpan, il est possible de faire la différence entre deux objets DateTime

Calculons le nombre de jours écoulés depuis la création de cette question :

Code vb.net : Sélectionner tout
1
2
3
4
5
Dim DateCourante As DateTime = DateTime.Now  
Dim DateCreationquestion As DateTime = New DateTime(2007, 1, 3)  
  
Dim Ts As TimeSpan = DateCourante - DateCreationquestion  
Console.WriteLine("Il s'est écoulé {0} jour(s) depuis la création de cette question !", Ts.Days)

Mis à jour le 28 octobre 2013 Jérôme Lambert

const et readonly permettent tout deux de mettre en constante un champ à la différence que const oblige à faire la déclaration et l'initialisation en une fois alors que readonly permet de faire l'initialisation du champ dans le constructeur de la classe.

Code vb.net : Sélectionner tout
1
2
3
4
5
6
Const maConst As Integer = 2007  
ReadOnly monReadOnly As String  
  
Public Sub New(ByVal monParam As String)  
    monReadOnly = monParam  
End Sub

Mis à jour le 28 octobre 2013 Jérôme Lambert

Cette définition est tirée de MSDN

Le Common Language Runtime recourt à une implémentation avancée de l'interface graphique (GDI, Graphics Design Interface) Windows, appelée GDI+. GDI+ vous permet de créer des graphiques, de dessiner du texte et de manipuler des images graphiques en tant qu'objets. Cette interface est conçue pour allier performances et simplicité d'utilisation. Vous pouvez l'utiliser en vue du rendu des images graphiques sur des Windows Forms et des contrôles. GDI+ a entièrement remplacé GDI et constitue aujourd'hui la seule option disponible pour le rendu des graphiques par programme dans les applications Windows Forms.

Mis à jour le 30 novembre 2013 Jérôme Lambert

Vous pouvez effectuer un décalage à gauche ou droite d'un certain nombre de bits de la manière suivante :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Dim value As Integer = 8  
Dim res As Integer  
  
Console.WriteLine("La valeur de départ vaut {0}", value)  
  
' Décalage vers la gauche 
' res est multiplié par 2 
res = value << 1  
Console.WriteLine("Après un décalage de 1 vers la gauche, res vaut {0}", res) 
  
' Décalage vers la droite 
' res est divisé par 2 
res = value >> 1 
Console.WriteLine("Après un décalage de 1 vers la droite, res vaut {0}", res) 
  
' Décalage vers la gauche 
' res est multiplié par 4 
res = value << 2 
Console.WriteLine("Après un décalage de 2 vers la gauche, res vaut {0}", res)

Mis à jour le 28 octobre 2013 Jérôme Lambert

La classe BitArray permet de stocker une liste de « vrai » - « faux » :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
' Création du tableau de 3 bits 
' Les 3 valeurs sont initialisées à false 
Dim monTableauBits(3) As BitArray  
  
' Accès à l'index 1 
monTableauBits(1) = True  
' Affiche false, true puis false 
For Each curBool As Boolean In monTableauBits  
    Console.WriteLine("Valeur : {0}", curBool)  
Next

Mis à jour le 30 novembre 2013 Jérôme Lambert

Il suffit d'utiliser MyClass ou Me dans le header du constructeur (c'est-à-dire juste après la liste des paramètres) :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
Class Employee  
    Private PrenomNom As String  
  
    Public Sub New(ByVal param_PrenomNom As String)  
        PrenomNom = param_PrenomNom  
    End Sub  
  
    Public Sub New(ByVal param_Prenom As String, ByVal param_Nom As String)  
        MyClass.New(param_Prenom + " " + param_Nom)  
    End Sub  
End Class

Mis à jour le 17 novembre 2013 Jérôme Lambert

Cette définition est tirée de MSDN

Le .NET Compact Framework est un environnement indépendant du matériel permettant d'exécuter des programmes sur divers périphériques informatiques à ressources limitées : assistants numériques personnels (PDA, Personal Data Assistant) tels que le Pocket PC, téléphones mobiles, décodeurs, périphériques informatiques automobiles et périphériques personnalisés intégrés au système d'exploitation Windows CE .NET.

Le .NET Compact Framework est un sous-ensemble de la bibliothèque de classes du .NET Framework, mais contient également des classes spécialement conçues à son intention. Il hérite la totalité de l'architecture de Common Language Runtime et d'exécution de code managé du .NET Framework.

Mis à jour le 30 novembre 2013 Jérôme Lambert

Pour instancier une classe à partir d'un type, il vous faudra utiliser la classe Activator :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Namespace ConsoleApplication1 
    Public Class Test 
    End Class 
  
    Class Program 
        Private Shared Sub Main(ByVal args As String()) 
            ' Récupération du type à instancier dynamiquement 
            Dim objType As System.Type = GetType(Test) 
  
            ' Instance dynamique à partir du type donné 
            Dim objInstanceDynamique As Object = System.Activator.CreateInstance(objType) 
  
            ' Casting de l'objet 
            Dim objTest As Test = TryCast(objInstanceDynamique, Test) 
        End Sub 
    End Class 
End Namespace

Mis à jour le 30 novembre 2013 Jérôme Lambert

.NET 3.0 est la dernière version en date du framework .NET de Microsoft.

Il n'apporte pas de changement au niveau des langages eux-mêmes mais introduit un ensemble de nouvelles technologies qui ont fait leur apparition avec Windows Vista

Le framework 3.0 est constitué de :

  • WCF : Windows Communication Foundation ;
  • WPF : Windows Presentation Foundation ;
  • WF : Workflow Foundation ;
  • Cardspace.

Le framework 3.0 est une extension du framework 2.0 sur lequel il s'appuie. Il n'introduit aucun changement dans les langages, seulement des ajouts d'API.

Mis à jour le 28 octobre 2013 dev01

Le XAML (eXtensible Application Markup Language) est un langage de description d'élément d'application basé sur le XML (eXtensible Markup Langage).

Il est utilisé par exemple dans les nouvelles interfaces graphiques WPF, ou dans WF.

Mis à jour le 28 octobre 2013 dev01

Windows Presentation Foundation (WPF) est la nouvelle technologie de création des interfaces graphiques.

Elle permet de séparer la conception des interfaces graphiques de l'ajout du code logique grâce à l'introduction du XAML (eXtensible Application Markup Language) pour la description de l'interface graphique.

WPF repose sur un nouveau moteur de rendu: le Graphics Processing Unit.
Ce moteur permet un rendu vectoriel améliorant ainsi la qualité finale. De plus les fonctionnalités de lecture de média comme de la vidéo ou du son sont directement prises en charge par WPF

Mis à jour le 28 octobre 2013 dev01

Windows CardSpace (WC) est le système de gestion des identités numériques introduit par le framework 3.0.

Ce système permet une gestion sécurisé des diverses identités numériques qu'un utilisateur peut être amené à avoir.
De plus WC doit permettre aux applications d'accéder aux informations de l'utilisateur sans que celui-ci ait besoin d'intervenir.
Cela permet par exemple de remplir certain champs d'état civil automatiquement.

Mis à jour le 28 octobre 2013 dev01

Par défaut en VB.Net, les casting implicites sont autorisés. Ce qui veut dire que vous pouvez faire ceci :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
Dim monObject As Object 
Dim monInt As Int32 
  
monInt = 100 
  
monObject = monInt 
  
monInt = monObject
Pour interdire ce genre de pratique et donc s'obliger à faire un casting explicite :

Code vb.net : Sélectionner tout
monInt = CType(monObject, Int32)
Il suffit d'aller dans les propriétés du projet, allez dans l'onglet Compile, puis mettez Option Strict à On.
Il est également possible de définir Option Strict au niveau de chaque fichier de code en ajoutant Option Strict On au début de celui.

Mis à jour le 28 octobre 2013 Jérôme Lambert

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load 
        Dim ResultatSansAccent As String = SansAccent("j'ai été en vacances à Noel où j'ai bien rigolé") 
        'Resultat : ResultatSansAccent = "j'ai ete en vacances à Noel ou j'ai bien rigole" 
    End Sub 
    Private Function SansAccent(ByVal Chaine As String) As String 
        Dim aOctets() As Byte = System.Text.Encoding.GetEncoding(1251).GetBytes(Chaine) 'converti en byte la chaine avec accents 
        Dim sEnleverAccents As String = System.Text.Encoding.ASCII.GetString(aOctets) 'converti en string la chaine sans accents 
        Return sEnleverAccents 'retourne le résultat 
    End Function

Mis à jour le 28 octobre 2013 Aspic Jérôme Lambert

La classe Graphics possède une méthode MeasureString permettant de connaître la taille exacte d'une chaine de caractères en fonction de la Font utilisée :

Code vb : Sélectionner tout
1
2
3
Dim g As System.Drawing.Graphics = TextBox1.CreateGraphics() ' Crée un objet Graphics 
Dim objSizeF As System.Drawing.SizeF = g.MeasureString(TextBox1.Text, TextBox1.Font) ' Récupère la taille  
MessageBox.Show(String.Format("Votre texte '{0}' a une longueur de {1} pixels.", TextBox1.Text, objSizeF.Width)) ' Affiche le résultat

Mis à jour le 30 novembre 2013 Aspic Jérôme Lambert

Les classes WebRequest et WebResponse vous permettent respectivement de créer des requêtes HTTP et récupérer les résultats de celles-ci.

Code vb : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
' Création de la requête 
Dim objWebRequest As System.Net.WebRequest = System.Net.HttpWebRequest.Create("http://dotnet.developpez.com") 
' Envoi de la requête au serveur 
Dim objWebResponse As System.Net.WebResponse = objWebRequest.GetResponse() 
' Stream pour récupérer le résultat 
Dim objStreamReader As System.IO.StreamReader = Nothing 
  
Try 
    ' Récupération du résultat 
    objStreamReader = New System.IO.StreamReader(objWebResponse.GetResponseStream()) 
    ' Lecture du résultat 
    TextBox1.Text = objStreamReader.ReadToEnd() 
Finally 
    ' Fermeture de la connexion 
    If Not objWebResponse Is Nothing Then 
        objWebResponse.Close() 
    End If 
End Try

Mis à jour le 30 novembre 2013 Aspic Jérôme Lambert

Grâce à la réflexion, il est possible d'obtenir énormément d'information à partir du type d'une classe. Pour vérifier si une classe implémente une interface, il vous suffira d'utiliser la méthode GetInterface de la classe Type :

Code vb : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Namespace ConsoleApplication1 
    Public Interface IMonInterface 
    End Interface 
  
    Public Class Test 
        Implements IMonInterface 
    End Class 
  
    Class Program 
        Shared Sub Main(ByVal args() As String) 
            Dim objType As System.Type = Type.GetType(Test) 
            Dim objTypeInterface As System.Type = objType.GetInterface("ConsoleApplication1.IMonInterface", False) 
  
            If Not objTypeInterface Is Nothing Then 
                System.Console.WriteLine("La classe 'Test' implémente l'interface 'IMonInterface' !") 
            Else 
                System.Console.WriteLine("La classe 'Test' n'implémente pas l'interface 'IMonInterface' !") 
            End If 
        End Sub 
    End Class 
End Namespace

Mis à jour le 30 novembre 2013 Aspic Jérôme Lambert

Pour instancier une classe à partir d'une chaîne de caractères, il vous faudra dans un premier temps transformer cette chaîne en un objet de type Type. A partir de l'objet Type obtenu, vous pourrez créer une instance grâce à la classe Activator :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Namespace ConsoleApplication1 
    Public Class Test 
    End Class 
  
    Class Program 
        Private Shared Sub Main(ByVal args As String()) 
            ' Récupération du type à instancier dynamiquement à partir d'une chaîne de caractères 
            Dim objType As System.Type = System.Type.[GetType]("ConsoleApplication1.Test") 
  
            ' Vérification si le type a bien été retrouvé 
            If objType IsNot Nothing Then 
                ' Instance dynamique à partir du type donné 
                Dim objInstanceDynamique As Object = System.Activator.CreateInstance(objType) 
  
                ' Casting de l'objet 
                Dim objTest As Test = TryCast(objInstanceDynamique, Test) 
            Else 
                System.Console.WriteLine("Le type semble être incorrect!") 
            End If 
        End Sub 
    End Class 
End Namespace

Mis à jour le 30 novembre 2013 Jérôme Lambert

Prenons le cas de deux classes, classA et classB :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
<Serializable()> _ 
Public Class classA 
    Private m_MembreInt As Integer = 0 
    Private m_B As classB = Nothing 
  
    Public Property MembreInt() As Integer 
        Get 
            Return m_MembreInt 
        End Get 
        Set 
            m_MembreInt = value 
        End Set 
    End Property 
  
    Public Property B() As classB 
        Get 
            Return m_B 
        End Get 
        Set 
            m_B = value 
        End Set 
    End Property 
End Class 
  
<Serializable()> _ 
Public Class classB 
    Private m_MembreFloat As Single = 0 
    Private m_A As classA = Nothing 
  
    Public Property MembreFloat() As Single 
        Get 
            Return m_MembreFloat 
        End Get 
        Set 
            m_MembreFloat = value 
        End Set 
    End Property 
  
    Public Property A() As classA 
        Get 
            Return m_A 
        End Get 
        Set 
            m_A = value 
        End Set 
    End Property 
End Class
Comme vous pouvez le voir, classA a une référence vers classB et classB a une référence vers classA. Si nous essayons de sérialiser un objet de type classA ou classB (et à condition que les références correspondantes ne soient pas NULL), nous aurons une erreur de référence circulaire et la sérialisation s'avèrera impossible :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
Dim objA As New classA() 
Dim objB As New classB() 
  
objA.B = objB 
objB.A = objA 
  
Serialize(objA)
Le code ci-dessus génèrera le message d'erreur suivant à l'exécution :

Code : Sélectionner tout
Référence circulaire détectée lors de la sérialisation d'un objet de type ConsoleApplication2.classA.
Afin de retirer les références circulaires, il suffira d'exclure les objets en question de la sérialisation en utilisant l'attribut System.Xml.Serialization.XmlIgnore sur les propriétés concernées :

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<System.Xml.Serialization.XmlIgnore()> _ 
Public Property B() As classB 
    Get 
        Return m_B 
    End Get 
    Set 
        m_B = value 
    End Set 
End Property 
  
  
<System.Xml.Serialization.XmlIgnore()> _ 
Public Property A() As classA 
    Get 
        Return m_A 
    End Get 
    Set 
        m_A = value 
    End Set 
End Property

Mis à jour le 17 novembre 2013 Jérôme Lambert

L'objet application offre la possibilité de s'abonner à l'évènement ThreadException permettant d'être notifié lorsqu'un thread génère une exception non interceptée. Etant donné que la fenêtre est gérée par un thread, vous pourrez ainsi éviter tout "plantage" de votre application ou effectuer un traitement adapté avant la fermeture de votre application.

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
' S'abonne à l'évènement permettant d'être averti qu'un thread génère une exception 
AddHandler System.Windows.Forms.Application.ThreadException, AddressOf Application_ThreadException 
  
''' <summary> 
'''     Lancé lorsque un thread n'intercepte pas une exception qu'il a généré 
''' </summary> 
Shared Sub Application_ThreadException(ByVal sender As Object, ByVal e As System.Threading.ThreadExceptionEventArgs) 
    MessageBox.Show("L'exeption générée est : " + e.Exception.Message) 
End Sub

Mis à jour le 28 octobre 2013 Jérôme Lambert

Pour cela, rien de plus simple :

Code vb.net : Sélectionner tout
1
2
3
4
Dim val As Integer = 510 
Dim binaryVal As String = Convert.ToString(val, 2) 
  
MsgBox("The value of " & val & " is " & binaryVal & ".", MsgBoxStyle.Information)

Mis à jour le 28 octobre 2013 Merlin

Tout est dans le titre.

Il faut rajouter dans les Imports

Code vb.net : Sélectionner tout
Imports Microsoft.Win32
et voici le code.

Code vb.net : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
Public Function AGetExtentionDescription(ByVal ext As String) As String 
    Dim description As String = GetExtentionDescription(ext) 
    If description Is Nothing OrElse description = "" Then 
        Return [String].Format("Fichier {0}", ext) 
    Else 
        Return description 
    End If 
End Function 
  
Public Function GetExtentionDescription(ByVal ext As String) As String 
    If ext Is Nothing OrElse ext = "" OrElse ext = "." Then 
        Return Nothing 
    End If 
  
    Dim description As String = "" 
  
    Try 
        Dim keyDesc As RegistryKey = Registry.ClassesRoot.OpenSubKey(ext, False) 
        If keyDesc Is Nothing Then 
            Return Nothing 
        Else 
            Try 
                If keyDesc.GetValueKind("") <> RegistryValueKind.[String] Then 
                    Return Nothing 
                Else 
                    description = TryCast(keyDesc.GetValue(""), String) 
                    If description Is Nothing OrElse description = "" Then 
                        Return Nothing 
                    End If 
  
                    Dim optionnalRedirection As RegistryKey = Registry.ClassesRoot.OpenSubKey(description, False) 
                    If optionnalRedirection Is Nothing Then 
                        Return description 
                    Else 
                        Try 
                            If optionnalRedirection.GetValueKind("") <> RegistryValueKind.[String] Then 
                                Return description 
                            Else 
                                Return TryCast(optionnalRedirection.GetValue(""), String) 
                            End If 
                        Finally 
                            If Not optionnalRedirection Is Nothing Then 
                                optionnalRedirection.Close() 
                            End If 
                        End Try 
                    End If 
                End If 
            Finally 
                If Not keyDesc Is Nothing Then 
                    keyDesc.Close() 
                End If 
            End Try 
        End If 
    Catch 
        Return Nothing 
    End Try 
End Function 
Private Sub button1_Click(ByVal sender As Object, ByVal e As EventArgs) Handles Button1.Click 
    MessageBox.Show(AGetExtentionDescription(".exe")) 
    MessageBox.Show(AGetExtentionDescription(".jpg")) 
    MessageBox.Show(AGetExtentionDescription(".dat")) 
    MessageBox.Show(AGetExtentionDescription(".iso")) 
    MessageBox.Show(AGetExtentionDescription(".bmp")) 
End Sub

Mis à jour le 28 octobre 2013 nico-pyright(c) smyley

Il faut mettre en préambule l'attribut KeyPreview de la form à true, pour dire que la form doit traiter tous les événements clavier en premier et ensuite surcharger le KeyDown de la form.

Exemple pour faire un raccourci CTRL+M :

Code vb.net : Sélectionner tout
1
2
3
4
5
Private Sub Form1_KeyDown(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyEventArgs) Handles Me.KeyDown 
    If e.Control And e.KeyCode = Keys.M Then 
        MsgBox("Vous avez appuyer sur Ctrl + M") 
    End If 
End Sub

Mis à jour le 17 novembre 2013 nico-pyright(c)

En utilisant un itérateur :

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
' interface publique (contrôle immédiat des arguments) 
Public Function SplitEvery(str As String, chunkSize As Integer) As IEnumerable(Of String) 
    If str Is Nothing Then Throw New ArgumentNullException("str") 
    If chunkSize < 0 Then Throw New ArgumentOutOfRangeException("chunkSize") 
    ' appel au bloc itérateur 
    Return SplitEveryIterator(str, chunkSize) 
End Function 
 
' bloc itérateur privé (permet l'évaluation tardive) 
Private Iterator Function SplitEveryIterator(str As String, chunkSize As Integer) As IEnumerable(Of String) 
    If str.Length <= chunkSize Then 
        ' si le texte est plus court que la taille demandée ; le renvoyer directement 
        Yield str 
    Else 
        ' bien veiller à utiliser la division entière \ plutôt que la divison flottante / 
        Dim chunkCount = str.Length \ chunkSize ' nombre de morceaux 
        Dim remainingSize = str.Length Mod chunkSize ' taille du morceau final 
 
        For offset = 0 To chunkCount - 1 
            Yield str.Substring(offset * chunkSize, chunkSize) 
        Next 
 
        ' renvoyer le morceau final s'il existe 
        If remainingSize > 0 Then Yield str.Substring (chunkCount * chunkSize, remainingSize) 
    End If 
End Function 
 
' exemple d'utilisation 
ForEach str In SplitEvery("hello", 2) 
    Console.WriteLine(str) 
Next 
 
' affichera : 
 
' he 
' ll 
' o

Mis à jour le 24 mai 2015 Sehnsucht

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsable bénévole de la rubrique Microsoft DotNET : Hinault Romaric -