Les traits cachés de VB.NET Je ne sais pas.

j'ai appris pas mal de choses en parcourant de C# et a été surpris quand je ne pouvais pas trouver quelque chose similaire pour VB.NET.

quelles sont donc certaines de ses caractéristiques cachées ou moins connues?

121
demandé sur Sean Gough 2008-09-19 18:07:01
la source

30 ответов

la clause Exception When est largement inconnue.

considérez ceci:

Public Sub Login(host as string, user as String, password as string, _
                            Optional bRetry as Boolean = False)
Try
   ssh.Connect(host, user, password)
Catch ex as TimeoutException When Not bRetry
   ''//Try again, but only once.
   Login(host, user, password, True)
Catch ex as TimeoutException
   ''//Log exception
End Try
End Sub
128
répondu torial 2011-12-20 22:05:33
la source

Personnalisé Enum s

un des réels hidden caractéristiques de VB est le completionlist étiquette de documentation XML qui peut être utilisé pour créer ses propres Enum - comme des types avec une fonctionnalité étendue. Cette fonctionnalité ne fonctionne pas en C#, cependant.

un exemple tiré d'un de mes codes récents:

'
''' <completionlist cref="RuleTemplates"/>
Public Class Rule
    Private ReadOnly m_Expression As String
    Private ReadOnly m_Options As RegexOptions

    Public Sub New(ByVal expression As String)
        Me.New(expression, RegexOptions.None)
    End Sub

    Public Sub New(ByVal expression As String, ByVal options As RegexOptions)
        m_Expression = expression
        m_options = options
    End Sub

    Public ReadOnly Property Expression() As String
        Get
            Return m_Expression
        End Get
    End Property

    Public ReadOnly Property Options() As RegexOptions
        Get
            Return m_Options
        End Get
    End Property
End Class

Public NotInheritable Class RuleTemplates
    Public Shared ReadOnly Whitespace As New Rule("\s+")
    Public Shared ReadOnly Identifier As New Rule("\w+")
    Public Shared ReadOnly [String] As New Rule("""([^""]|"""")*""")
End Class

maintenant, en assignant une valeur à une variable déclarée comme Rule , L'IDE offre une Liste IntelliSense des valeurs possibles de RuleTemplates .

/EDIT:

Puisqu'il s'agit D'une fonctionnalité qui s'appuie sur L'IDE, il est difficile de montrer à quoi cela ressemble lorsque vous l'utilisez, mais je vais juste utiliser une capture d'écran:

l'Achèvement de la liste dans l'action http://page.mi.fu-berlin.de/krudolph/stuff/completionlist.png

en fait, L'IntelliSense est 100% identique à ce que vous obtenez en utilisant un Enum .

82
répondu Konrad Rudolph 2009-06-02 20:07:41
la source

avez-vous remarqué L'opérateur de comparaison similaire?

Dim b As Boolean = "file.txt" Like "*.txt"

plus de MSDN "151980920

Dim testCheck As Boolean

' The following statement returns True (does "F" satisfy "F"?)'
testCheck = "F" Like "F"

' The following statement returns False for Option Compare Binary'
'    and True for Option Compare Text (does "F" satisfy "f"?)'
testCheck = "F" Like "f"

' The following statement returns False (does "F" satisfy "FFF"?)'
testCheck = "F" Like "FFF"

' The following statement returns True (does "aBBBa" have an "a" at the'
'    beginning, an "a" at the end, and any number of characters in '
'    between?)'
testCheck = "aBBBa" Like "a*a"

' The following statement returns True (does "F" occur in the set of'
'    characters from "A" through "Z"?)'
testCheck = "F" Like "[A-Z]"

' The following statement returns False (does "F" NOT occur in the '
'    set of characters from "A" through "Z"?)'
testCheck = "F" Like "[!A-Z]"

' The following statement returns True (does "a2a" begin and end with'
'    an "a" and have any single-digit number in between?)'
testCheck = "a2a" Like "a#a"

' The following statement returns True (does "aM5b" begin with an "a",'
'    followed by any character from the set "L" through "P", followed'
'    by any single-digit number, and end with any character NOT in'
'    the character set "c" through "e"?)'
testCheck = "aM5b" Like "a[L-P]#[!c-e]"

' The following statement returns True (does "BAT123khg" begin with a'
'    "B", followed by any single character, followed by a "T", and end'
'    with zero or more characters of any type?)'
testCheck = "BAT123khg" Like "B?T*"

' The following statement returns False (does "CAT123khg" begin with'
'    a "B", followed by any single character, followed by a "T", and'
'    end with zero or more characters of any type?)'
testCheck = "CAT123khg" Like "B?T*"
49
répondu Eduardo Molteni 2011-10-19 12:59:36
la source

Typedefs

VB connaît un type primitif de typedef via Import alias:

Imports S = System.String

Dim x As S = "Hello"

ceci est plus utile lorsqu'il est utilisé en conjonction avec des types génériques:

Imports StringPair = System.Collections.Generic.KeyValuePair(Of String, String)
48
répondu Konrad Rudolph 2009-07-13 21:37:30
la source

Oh! et n'oubliez pas XML Literals .

Dim contact2 = _
        <contact>
          <name>Patrick Hines</name>
          <%= From p In phoneNumbers2 _
            Select <phone type=<%= p.Type %>><%= p.Number %></phone> _
          %>
        </contact>
45
répondu Nescio 2008-09-19 18:34:09
la source

l'initialisation de l'Objet est là aussi!

Dim x as New MyClass With {.Prop1 = foo, .Prop2 = bar}
39
répondu Nescio 2008-09-19 18:17:56
la source

DirectCast

DirectCast est une merveille. En surface, il fonctionne comme l'opérateur CType en ce qu'il convertit un objet d'un type en un autre. Toutefois, il fonctionne selon un ensemble de règles beaucoup plus strictes. CType ' s comportement réel est donc souvent opaque et il n'est pas du tout évident quel type de conversion est exécutée.

DirectCast supporte seulement deux opérations distinctes:

  • Unboxing d'un type de valeur, et
  • upcasting dans la hiérarchie de classe.

toute autre distribution ne fonctionnera pas (par exemple, essayer de décompiler un Integer vers un Double ) et résultera en une erreur de temps de compilation/exécution (en fonction de la situation et de ce qui peut être détecté par vérification de type statique). J'utilise donc DirectCast chaque fois que c'est possible, car c'est ce qui rend le mieux mon intention: selon la situation, je veux soit valeur du type connu ou effectuer une upcast. Fin de l'histoire.

en utilisant CType , d'autre part, laisse le lecteur du code se demander ce que le programmeur a réellement voulu parce qu'il résout à toutes sortes d'opérations différentes, y compris l'appel de code défini par l'utilisateur.

Pourquoi est-ce une caractéristique cachée? L'équipe de VB a publié une ligne directrice 1 qui décourage l'utilisation de DirectCast (même si c'est en fait plus vite!) afin de rendre le code plus uniforme. Je soutiens qu'il s'agit d'une mauvaise ligne directrice qui devrait être inversée: dans la mesure du possible, favoriser DirectCast par rapport à l'opérateur plus général CType . il rend le code beaucoup plus clair. CType , d'autre part, ne doit être appelé que si cela est effectivement prévu, c'est-à-dire lorsqu'un opérateur de rétrécissement CType (cf. la surcharge d'opérateur ) doit être appelée.


1) Je ne suis pas en mesure de trouver un lien vers la ligne directrice mais j'ai trouvé Paul Vick's take on it (développeur en chef de l'équipe VB):

dans le monde réel, vous n'allez presque jamais remarquer la différence, donc vous pourriez aussi bien aller avec les opérateurs de conversion plus flexibles comme CType, CInt, etc.


(modifier par Zack: en savoir plus ici: Comment dois-je lancer VB.NET Je ne sais pas. )

38
répondu Konrad Rudolph 2017-05-23 13:30:52
la source

If conditionnel et fusionner opérateur

Je ne sais pas comment vous l'appelleriez caché, mais la fonction IIF([expression],[valeur si true],[valeur si false]) En tant qu'objet pourrait compter.

ce n'est pas tant caché que déprécié ! VB 9 a l'opérateur If qui est beaucoup mieux et fonctionne exactement comme l'opérateur conditionnel et coalesce de C#(Selon ce que vous voulez):

Dim x = If(a = b, c, d)

Dim hello As String = Nothing
Dim y = If(hello, "World")

édité pour montrer un autre exemple:

cela fonctionnera avec If() , mais cause une exception avec IIf()

Dim x = If(b<>0,a/b,0)
37
répondu Konrad Rudolph 2008-10-01 20:40:54
la source

C'est une belle. L'énoncé de cas sélectionné à l'intérieur VB.Net c'est très puissant.

bien Sûr, il est la norme

Select Case Role
  Case "Admin"
         ''//Do X
  Case "Tester"
         ''//Do Y
  Case "Developer"
         ''//Do Z
  Case Else
       ''//Exception case
End Select

mais il y a plus...

vous pouvez faire des gammes:

Select Case Amount
 Case Is < 0
    ''//What!!
 Case 0 To 15
   Shipping = 2.0
 Case 16 To 59
    Shipping = 5.87
 Case Is > 59
    Shipping = 12.50
 Case Else
    Shipping = 9.99
 End Select

et encore plus...

vous pouvez (bien que peut ne pas être une bonne idée) faire des vérifications booléennes sur les variables multiples:

Select Case True
 Case a = b
    ''//Do X
 Case a = c
    ''//Do Y
 Case b = c
    ''//Do Z
 Case Else
   ''//Exception case
 End Select
32
répondu torial 2011-09-27 18:10:04
la source

un épargnant temps majeur que j'utilise tout le temps est le avec mot clé:

With ReallyLongClassName
    .Property1 = Value1
    .Property2 = Value2
    ...
End With

Je n'aime pas taper plus que je n'ai à le faire!

31
répondu Jasha87 2008-09-19 18:10:48
la source

Le meilleur et facile CSV analyseur:

Microsoft.VisualBasic.FileIO.TextFieldParser

en ajoutant une référence à Microsoft.VisualBasic, ceci peut être utilisé dans n'importe quelle autre langue. net, par exemple C#

31
répondu cjk 2009-06-02 20:13:53
la source
  • AndAlso/OrElse opérateurs logiques

(EDIT: en Savoir plus ici: dois-je toujours utiliser le AndAlso et OrElse opérateurs? )

26
répondu Joel Coehoorn 2017-05-23 15:02:54
la source

membres Statiques dans les méthodes.

par exemple:

Function CleanString(byval input As String) As String
    Static pattern As New RegEx("...")

    return pattern.Replace(input, "")
End Function

dans la fonction ci-dessus, l'expression régulière du motif ne sera créée qu'une seule fois, peu importe le nombre de fois où la fonction est appelée.

une autre utilisation est de conserver une instance de "random" autour de:

Function GetNextRandom() As Integer
    Static r As New Random(getSeed())

    Return r.Next()
End Function 

en outre, ce n'est pas la même chose que simplement la déclarer comme un membre partagé de la classe; articles déclarés de cette façon sont garantis pour être fil-safe aussi bien. Cela n'a pas d'importance dans ce scénario puisque l'expression ne changera jamais, mais il y en a d'autres où elle pourrait changer.

25
répondu Joel Coehoorn 2009-06-02 19:13:46
la source

en vb il y a une différence entre ces opérateurs:

/ est Double

\ est Integer en ignorant le reste

Sub Main()
    Dim x = 9 / 5  
    Dim y = 9 \ 5  
    Console.WriteLine("item x of '{0}' equals to {1}", x.GetType.FullName, x)
    Console.WriteLine("item y of '{0}' equals to {1}", y.GetType.FullName, y)

    'Results:
    'item x of 'System.Double' equals to 1.8
    'item y of 'System.Int32' equals to 1
End Sub
25
répondu Shimmy 2010-04-03 09:29:47
la source

j'aime vraiment le "Mon" espace de Noms qui a été introduit dans Visual Basic 2005. Mon est un raccourci de plusieurs groupes d'informations et de fonctionnalités. Il offre un accès rapide et intuitif aux types d'information suivants:

  • Mon.Ordinateur : accès aux informations relatives à l'ordinateur telles que le système de fichiers, le réseau, les périphériques, les informations système, etc. Il donne accès à un certain nombre de ressources très importantes, y compris mon.Ordinateur.Réseau, Mon.Ordinateur.Système de fichiers, et Mon.Ordinateur.Imprimante.
  • My.Application : accès aux informations relatives à l'application particulière telles que le nom, la version, le répertoire courant, etc.
  • My.Utilisateur : accès aux informations relatives à l'utilisateur authentifié actuel.
  • My.Ressources : Accès des ressources utilisées par l'application résidant dans les fichiers de ressources dans un typage fort.
  • My.Paramètres : accès aux paramètres de configuration de l'application d'une manière fortement typée.
23
répondu splattne 2008-10-10 15:13:39
la source

Événements Personnalisés

bien que rarement utile, la manipulation d'événements peut être fortement personnalisé:

Public Class ApplePie
    Private ReadOnly m_BakedEvent As New List(Of EventHandler)()

    Custom Event Baked As EventHandler
        AddHandler(ByVal value As EventHandler)
            Console.WriteLine("Adding a new subscriber: {0}", value.Method)
            m_BakedEvent.Add(value)
        End AddHandler

        RemoveHandler(ByVal value As EventHandler)
            Console.WriteLine("Removing subscriber: {0}", value.Method)
            m_BakedEvent.Remove(value)
        End RemoveHandler

        RaiseEvent(ByVal sender As Object, ByVal e As EventArgs)
            Console.WriteLine("{0} is raising an event.", sender)
            For Each ev In m_BakedEvent
                ev.Invoke(sender, e)
            Next
        End RaiseEvent
    End Event

    Public Sub Bake()
        ''// 1. Add ingredients
        ''// 2. Stir
        ''// 3. Put into oven (heated, not pre-heated!)
        ''// 4. Bake
        RaiseEvent Baked(Me, EventArgs.Empty)
        ''// 5. Digest
    End Sub
End Class

cela peut ensuite être testé de la manière suivante:

Module Module1
    Public Sub Foo(ByVal sender As Object, ByVal e As EventArgs)
        Console.WriteLine("Hmm, freshly baked apple pie.")
    End Sub

    Sub Main()
        Dim pie As New ApplePie()
        AddHandler pie.Baked, AddressOf Foo
        pie.Bake()
        RemoveHandler pie.Baked, AddressOf Foo
    End Sub
End Module
23
répondu Konrad Rudolph 2009-06-02 19:11:39
la source

je viens de trouver un article parlant du "!"de l'opérateur, également connu comme le "dictionnaire de l'opérateur de recherche". Voici un extrait de l'article à: http://panopticoncentral.net/articles/902.aspx

le nom technique du ! opérateur est le " opérateur de recherche de dictionnaire." Un le dictionnaire est n'importe quel type de collection qui est indexée par une clé plutôt qu'une nombre, de la même manière que le les entrées dans un anglais dictionnaire sont indexé par le mot que vous voulez définition de l'. L'exemple le plus commun d'un type de dictionnaire est l' Système.Collection.Table de hachage, qui vous permet d'ajouter (clé, valeur) paires dans le hashtable et puis récupérer les valeurs à l'aide des touches. Exemple, le code suivant ajoute trois entrées pour une table de hachage, et regarde l'un d'eux avec la clé "porc".

Dim Table As Hashtable = New Hashtable
Table("Orange") = "A fruit"
Table("Broccoli") = "A vegetable"
Table("Pork") = "A meat" 
Console.WriteLine(Table("Pork"))

The ! l'opérateur peut être utilisé pour rechercher des les valeurs de n'importe quel type de dictionnaire qui indexe ses valeurs à l'aide de chaînes. Le identificateur après le ! est utilisé comme clé dans l'opération de recherche. De sorte que le le code ci-dessus, pourrait au contraire avoir été écrit:

Dim Table As Hashtable = New Hashtable
Table!Orange = "A fruit"
Table!Broccoli = "A vegetable"
Table!Pork = "A meat"
Console.WriteLine(Table!Pork)

Le deuxième exemple est complètement équivalente à la première, mais juste semble beaucoup plus agréable, du moins à mon oeil. Je trouve qu'il y a beaucoup de des lieux où ! peut être utilisé, en particulier en ce qui concerne le XML et le web, où il y a juste des tonnes de les collections qui sont indexées par chaîne. Une limitation regrettable est que la chose après le ! encore doit être un identificateur valide, donc si la chaîne que vous voulez utiliser comme clé a quelques identifiant invalide caractère en elle, vous ne pouvez pas utiliser la ! opérateur. (Vous ne pouvez pas, par exemple, dire "La Table!AB $ CD = 5 " parce que $ n'est pas juridique dans les identificateurs.) En VB6 et avant, vous pouvez utiliser des crochets pour échapper non valide identifiants (c'est à dire "La Table![AB$CD]"), mais lorsque nous avons commencé en utilisant des crochets pour échapper aux mots-clés, nous perdu la capacité de le faire. Dans la plupart des cas, cependant, ce n'est pas trop limitation.

pour être vraiment technique, x!y fonctionne si x a une propriété par défaut qui prend Chaîne ou objet comme paramètre. Dans ce cas, x!y est changé en x.DefaultProperty ("y"). Une intéressante note de côté, il est spécial règle dans la grammaire lexicale de la de la langue au travail. L' ! le caractère est aussi utilisé comme type caractère dans la langue, et tapez les personnages sont mangés avant les opérateurs. Donc, sans une règle spéciale, x!y aurait être scanné comme " x! y" au lieu de "x ! y". Heureusement, car il n'est pas lieu dans la langue où deux identifiants dans une rangée sont valides, nous vient d'introduire la règle que si le caractère suivant après le ! est le début d'un identifiant, nous considérons l' ! pour être un opérateur et non un type de caractère.

21
répondu torial 2009-03-14 19:22:55
la source

C'est intégré, et un avantage certain sur C#. La possibilité d'implémenter une méthode d'interface sans avoir à utiliser le même nom.

tels que:

Public Sub GetISCSIAdmInfo(ByRef xDoc As System.Xml.XmlDocument) Implements IUnix.GetISCSIInfo

End Sub
19
répondu torial 2008-09-19 18:28:48
la source

Forcer ByVal

dans VB, si vous enveloppez vos arguments dans un ensemble supplémentaire de parenthèses, vous pouvez outrepasser la déclaration ByRef de la méthode et la transformer en ByVal. Par exemple, le code suivant produit 4, 5, 5 au lieu de 4,5,6

Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
    Dim R = 4
    Trace.WriteLine(R)
    Test(R)
    Trace.WriteLine(R)
    Test((R))
    Trace.WriteLine(R)
End Sub
Private Sub Test(ByRef i As Integer)
    i += 1
End Sub

Voir "151980920 Argument de" ne Pas Être Modifiée par la Procédure d'Appel Variable sous-jacente

17
répondu Chris Haas 2010-05-15 00:45:28
la source

passer les paramètres par leur nom et les réorganiser ainsi

Sub MyFunc(Optional msg as String= "", Optional displayOrder As integer = 0)

    'Do stuff

End function

Utilisation:

Module Module1

    Sub Main()

        MyFunc() 'No params specified

    End Sub

End Module

peut aussi être appelé en utilisant la spécification de paramètre ":=" dans n'importe quel ordre:

MyFunc(displayOrder:=10, msg:="mystring")
16
répondu rich 2009-07-14 14:03:36
la source

la déclaration D'utilisation est nouvelle à partir de VB 8, C# l'avait depuis le début. Il appelle disposent automatiquement pour vous.

E. G.

Using lockThis as New MyLocker(objToLock)

End Using
15
répondu torial 2008-09-19 18:24:00
la source

les pseudonymes importés sont également largement inconnus:

Import winf = System.Windows.Forms

''Later
Dim x as winf.Form
14
répondu torial 2008-09-19 18:22:04
la source

considérer la déclaration d'événement suivante

Public Event SomethingHappened As EventHandler

dans C#, vous pouvez vérifier pour les abonnés d'événement en utilisant la syntaxe suivante:

if(SomethingHappened != null)
{
  ...
}

cependant, le VB.NET compilateur ne supporte pas cela. Il crée en fait un champ de membre privé caché qui n'est pas visible dans IntelliSense:

If Not SomethingHappenedEvent Is Nothing OrElse SomethingHappenedEvent.GetInvocationList.Length = 0 Then
...
End If

Plus D'Informations:

http://jelle.druyts.net/2003/05/09/BehindTheScenesOfEventsInVBNET.aspx http://blogs.msdn.com/vbteam/archive/2009/09/25/testing-events-for-nothing-null-doug-rothaus.aspx

14
répondu Technobabble 2009-09-26 01:48:40
la source

Si vous avez besoin d'un nom de variable qui correspond à un mot-clé, placez-le entre parenthèses. Pas de nec. la meilleure pratique, mais il peut être utilisé à bon escient.

p.ex.

Class CodeException
Public [Error] as String
''...
End Class

''later
Dim e as new CodeException
e.Error = "Invalid Syntax"

exemple tiré des commentaires (@Pondidum):

Class Timer
Public Sub Start()
''...
End Sub

Public Sub [Stop]()
''...
End Sub
14
répondu torial 2009-11-21 02:26:38
la source

il y a quelques réponses à propos de la littérature XML, mais pas à propos de ce cas précis:

vous pouvez utiliser les littérales XML pour enfermer les littérales chaîne qui devraient autrement être échappées. Les littérales de chaîne qui contiennent des doubles citations, par exemple.

au lieu de ceci:

Dim myString = _
    "This string contains ""quotes"" and they're ugly."

Vous pouvez faire ceci:

Dim myString = _
    <string>This string contains "quotes" and they're nice.</string>.Value

c'est particulièrement utile si vous testez un littéral pour l'analyse CSV:

Dim csvTestYuck = _
    """Smith"", ""Bob"", ""123 Anywhere St"", ""Los Angeles"", ""CA"""

Dim csvTestMuchBetter = _
    <string>"Smith", "Bob", "123 Anywhere St", "Los Angeles", "CA"</string>.Value

(vous n'avez pas à utiliser l'étiquette <string> , bien sûr; vous pouvez utiliser n'importe quelle étiquette que vous aimez.)

13
répondu Ryan Lundy 2009-12-18 01:50:43
la source

DateTime peut être initialisé en entourant votre date avec #

Dim independanceDay As DateTime = #7/4/1776#

Vous pouvez également utiliser l'inférence de type avec cette syntaxe

Dim independanceDay = #7/4/1776#

C'est beaucoup mieux que d'utiliser le constructeur

Dim independanceDay as DateTime = New DateTime(1776, 7, 4)
12
répondu danlash 2009-06-29 18:51:37
la source

vous pouvez avoir 2 lignes de code dans une seule ligne. d'où:

Dim x As New Something : x.CallAMethod
12
répondu Parsa 2009-11-27 10:58:51
la source

Paramètres Optionnels

Les options

sont tellement plus faciles que de créer de nouvelles surcharges, telles que:

Function CloseTheSystem(Optional ByVal msg AS String = "Shutting down the system...")
   Console.Writeline(msg)
   ''//do stuff
End Function
11
répondu dr. evil 2009-06-02 20:06:22
la source

titre affaire VB.Net peut être réalisé par un vieux VB6 fxn:

StrConv(stringToTitleCase, VbStrConv.ProperCase,0) ''0 is localeID
9
répondu torial 2008-09-19 18:51:41
la source

propriétés avec paramètres

j'ai fait quelques programmations C#, et j'ai découvert une fonctionnalité qui manquait que VB.Net avait, mais n'a pas été mentionné ici.

un exemple de comment faire ceci (ainsi que la limitation c#) peut être vu à: en utilisant les propriétés typiques get set dans C#... avec les paramètres

j'ai extrait le code de cette réponse:

Private Shared m_Dictionary As IDictionary(Of String, Object) = _
             New Dictionary(Of String, Object)

Public Shared Property DictionaryElement(ByVal Key As String) As Object
    Get
        If m_Dictionary.ContainsKey(Key) Then
            Return m_Dictionary(Key)
        Else
            Return [String].Empty
        End If
    End Get
    Set(ByVal value As Object)
        If m_Dictionary.ContainsKey(Key) Then
            m_Dictionary(Key) = value
        Else
            m_Dictionary.Add(Key, value)
        End If

    End Set
End Property
9
répondu torial 2017-05-23 13:30:52
la source

Autres questions sur hidden-features vb.net