Comment vérifier si un objet est d'un certain type

Je suis de passage d'objets divers à un sous-programme à exécuter le même processus, mais en utilisant un objet différent à chaque fois. Par exemple, dans un cas, je suis l'aide d'une ListView et dans un autre cas, je suis de passage d'un DropDownList.

Je veux vérifier si l'objet est transmis est un DropDownList, puis d'exécuter du code si il est. Comment puis-je faire cela?

Mon code si loin, qui ne fonctionne pas:

Sub FillCategories(ByVal Obj As Object)
    Dim cmd As New SqlCommand("sp_Resources_Categories", Conn)
    cmd.CommandType = CommandType.StoredProcedure
    Obj.DataSource = cmd.ExecuteReader
    If Obj Is System.Web.UI.WebControls.DropDownList Then

    End If
    Obj.DataBind()
End Sub

InformationsquelleAutor Leah | 2011-07-05

139

Dans VB.NET, vous devez utiliser le GetType méthode pour récupérer le type d'une instance d'un objet, et le GetType() de l'opérateur pour récupérer le type d'un autre type connu.

Une fois que vous avez les deux types, il vous suffit de les comparer à l'aide de la Is opérateur.

De sorte que votre code doit effectivement être écrit comme ceci:
```
Sub FillCategories(ByVal Obj As Object)
    Dim cmd As New SqlCommand("sp_Resources_Categories", Conn)
    cmd.CommandType = CommandType.StoredProcedure
    Obj.DataSource = cmd.ExecuteReader
    If Obj.GetType() Is GetType(System.Web.UI.WebControls.DropDownList) Then

    End If
    Obj.DataBind()
End Sub
```
Vous pouvez également utiliser le TypeOf de l'opérateur au lieu de la GetType méthode. Notez que ce test si votre objet est compatible avec un type donné, non pas que c'est le même type. Qui ressemblerait à ceci:
```
If TypeOf Obj Is System.Web.UI.WebControls.DropDownList Then

End If
```
Totalement banal, sans importance pinaille: Traditionnellement, les noms de paramètres sont en camelcase (ce qui signifie qu'ils commencent toujours par une minuscule) lors de l'écriture .NET code (soit VB.NET ou C#). Cela les rend faciles à distinguer d'un coup d'oeil dans les classes, les types, les méthodes, etc.
- Merci pour votre réponse. J'ai essayé ce code mais en réalité, la seule chose est qu'il ne fonctionne pas avec l'opérateur'='. J'ai dû changer de "Est". L'erreur que j'ai eu quand il était '=' était "Opérateur" = " n'est pas défini pour les types de Système.Type et du Système.Type"."
- Ouais, désolé à ce sujet. On dirait que je doit commencer à payer plus d'attention lors de la rédaction des réponses. TypeOf est probablement encore plus simple, au moins en termes de lisibilité du code; j'ai mis à jour la réponse avec un exemple, trop.
- Merci, cela fonctionne aussi
- Il existe une différence importante entre les deux, qui est ce qui m'a amené à ce poste. La TypeOf vérifier renvoie True si l'objet est une classe qui hérite du type de la vérification, alors que GetType ne retourne True si elle est exactement de la même classe.
- Totalement banal, sans importance contrepoint: Même si le VS CodeAnalysis se plaint, je sens encore l'argument noms font partie de l'interface publique et sont donc PascalCase dans mon code.
- Est-il une différence de performance entre les deux? - Est-ce que Select Case (Obj.GetType()) avec de multiples cas de test Vs plusieurs IF TypeOf Obj is ...?
InformationsquelleAutor Cody Gray
1

Un peu plus de détails en rapport avec l'intervention de Cody Gris. Comme il m'a fallu un certain temps pour digérer tout ça je pensais qu'il pourrait être utile à d'autres.

D'abord, quelques définitions:
1. Il y a TypeNames, qui sont des représentations de chaîne du type d'un objet, interface, etc. Par exemple, Bar est un TypeName dans Public Class Bar, ou dans Dim Foo as Bar. TypeNames pourraient être considérés comme des "étiquettes" utilisé dans le code pour indiquer au compilateur le type de définition à rechercher dans un dictionnaire où tous les types disponibles pourraient être décrits.
2. Il y a System.Type des objets qui contiennent une valeur. Cette valeur indique un type; tout comme un String serait prendre un certain texte ou un Int serait prendre un certain nombre, à l'exception de nous de stocker des types plutôt que du texte ou des chiffres. Type objets contiennent les définitions de type, ainsi que son correspondant TypeName.
Seconde, la théorie de l':
1. Foo.GetType() renvoie une Type objet qui contient le type de la variable Foo. En d'autres termes, il vous indique ce que Foo est une instance de.
2. GetType(Bar) renvoie une Type objet qui contient le type de la propriété TypeName Bar.
3. Dans certains cas, le type d'un objet a été Cast est différente du type d'un objet a d'abord été instancié à partir d'. Dans l'exemple suivant, MyObj est un Integer jeté dans un Object:
  
  Dim MyVal As Integer = 42 Dim MyObj As Object = CType(MyVal, Object)
Donc, est MyObj de type Object ou de type Integer? MyObj.GetType() vous dira que c'est un Integer.
1. Mais voici le Type Of Foo Is Bar fonctionnalité, qui permet de déterminer une variable Foo est compatible avec un TypeName Bar. Type Of MyObj Is Integer et Type Of MyObj Is Object permettra à la fois de retourner la valeur True. Pour la plupart des cas, TypeOf indique une variable est compatible avec un TypeName si la variable est d'un Type ou d'un Type qui en découle.
  Plus d'infos ici: https://docs.microsoft.com/en-us/dotnet/visual-basic/language-reference/operators/typeof-operator#remarks
Le test ci-dessous illustrent assez bien le comportement et l'utilisation de chaque de la cité des mots clés et des propriétés.
```
Public Sub TestMethod1()
Dim MyValInt As Integer = 42
Dim MyValDble As Double = CType(MyValInt, Double)
Dim MyObj As Object = CType(MyValDble, Object)
Debug.Print(MyValInt.GetType.ToString) 'Returns System.Int32
Debug.Print(MyValDble.GetType.ToString) 'Returns System.Double
Debug.Print(MyObj.GetType.ToString) 'Returns System.Double
Debug.Print(MyValInt.GetType.GetType.ToString) 'Returns System.RuntimeType
Debug.Print(MyValDble.GetType.GetType.ToString) 'Returns System.RuntimeType
Debug.Print(MyObj.GetType.GetType.ToString) 'Returns System.RuntimeType
Debug.Print(GetType(Integer).GetType.ToString) 'Returns System.RuntimeType
Debug.Print(GetType(Double).GetType.ToString) 'Returns System.RuntimeType
Debug.Print(GetType(Object).GetType.ToString) 'Returns System.RuntimeType
Debug.Print(MyValInt.GetType = GetType(Integer)) '# Returns True
Debug.Print(MyValInt.GetType = GetType(Double)) 'Returns False
Debug.Print(MyValInt.GetType = GetType(Object)) 'Returns False
Debug.Print(MyValDble.GetType = GetType(Integer)) 'Returns False
Debug.Print(MyValDble.GetType = GetType(Double)) '# Returns True
Debug.Print(MyValDble.GetType = GetType(Object)) 'Returns False
Debug.Print(MyObj.GetType = GetType(Integer)) 'Returns False
Debug.Print(MyObj.GetType = GetType(Double)) '# Returns True
Debug.Print(MyObj.GetType = GetType(Object)) 'Returns False
Debug.Print(TypeOf MyObj Is Integer) 'Returns False
Debug.Print(TypeOf MyObj Is Double) '# Returns True
Debug.Print(TypeOf MyObj Is Object) '# Returns True
End Sub
```
MODIFIER

Vous pouvez également utiliser de l'Information.TypeName(Objet) pour obtenir le Nom d'un objet donné. Par exemple,
```
Dim Foo as Bar
Dim Result as String
Result = TypeName(Foo)
Debug.Print(Result) 'Will display "Bar"
```
InformationsquelleAutor Ama

Vous devez vous connecter pour publier un commentaire.