Überprüfen, ob Instanz eines Typs

Verwenden, um zu überprüfen, ob c ist eine Instanz von TForm.

c.GetType().Name.CompareTo("TForm") == 0

Gibt es eine weitere Art sicheren Weg, es zu tun, neben der Verwendung eines string als param zu CompareTo()?

Ich hoffe, Sie tun es nicht in Java so. Java ist instanceof und C#'s is sind viel bessere Möglichkeiten, es zu tun.

InformationsquelleAutor Lennie | 2010-08-24

.net c#

367

Den verschiedenen Antworten hier haben zwei unterschiedliche Bedeutungen.

Wenn Sie möchten, um zu überprüfen, ob eine Instanz von ein genauer Typ dann
```
if (c.GetType() == typeof(TForm))
```
ist der Weg zu gehen.

Wenn Sie wissen möchten, ob c ist eine Instanz von TForm oder eine Unterklasse dann verwenden is/as:
```
if (c is TForm)
```
oder
```
TForm form = c as TForm;
if (form != null)
```
Es ist es Wert, klar in Ihrer Meinung darüber, welche dieser Verhaltensweisen Sie eigentlich wollen.
- Ein kleiner Hinweis: verwenden Sie "ist", wenn Sie nicht wollen, um das Ergebnis der Besetzung und Nutzung "als", wenn Sie tun.
- Mit C# 7 Sie können kombinieren is und as mit pattern-matching: if (x is TForm tf) {…
InformationsquelleAutor Jon Skeet
37
```
if(c is TFrom)
{
   //Do Stuff
}
```
oder wenn Sie planen, mit c als TForm verwenden Sie das folgende Beispiel:
```
var tForm = c as TForm;
if(tForm != null)
{
   //c is of type TForm
}
```
Zweiten Beispiel braucht nur zu überprüfen, um zu sehen, ob c ist der Typ TForm einmal. Whereis wenn Sie überprüfen, ob sehen, wenn c ist der Typ TForm dann warf Sie die CLR macht eine zusätzliche Kontrolle.
Hier ist ein Referenz.

Edit: Geklaut von Jon Skeet

Wenn Sie sicherstellen möchten, dass c ist TForm und nicht jede Klasse erbt von TForm, dann verwenden Sie
```
if(c.GetType() == typeof(TForm))
{
   //Do stuff cause c is of type TForm and nothing else
}
```
InformationsquelleAutor PostMan
14

Ja, das "ist" Stichwort:
```
if (c is TForm)
{
    ...
}
```
Details finden Sie auf der MSDN-Website: http://msdn.microsoft.com/en-us/library/scekt9xw(VS.80).aspx

Prüft, ob ein Objekt ist kompatibel mit einem bestimmten Typ. Es kann beispielsweise bestimmt werden, ob ein Objekt ist kompatibel mit den string-Typ wie dieser:

InformationsquelleAutor boj
9

Auch, etwas in die gleiche Richtung
```
Type.IsAssignableFrom(Type c)
```
"True, wenn c und der aktuelle Type repräsentieren die gleiche Art, oder wenn die
aktuelle Typ in der Vererbungshierarchie von c, oder wenn der aktuelle
Der Typ ist ein interface, c umsetzt, oder wenn c ist ein generischer Typ
parameter und der aktuelle Type stellt eine der Einschränkungen von c."

Hier: http://msdn.microsoft.com/en-us/library/system.type.isassignablefrom.aspx
- dies ist auch mein persönlicher Favorit. typeof(Class).IsAssignableFrom(object.getType()) ähnlich der Java - instanceof Betreiber.
- Gibt Sie false, wenn Sie nicht in der gleichen Filiale der Vererbungshierarchie aber ein conversion operator existiert?
- Gute Frage @PaulStelian. Ich bin nicht sicher, dass aus der Spitze von meinem Kopf, aber meine Vermutung wäre, würde es wieder eine falsche in dieser situation. Das würde zumindest mein Verhalten zu erwarten. Vielleicht, wenn eine implizite Konvertierung existiert, könnte es true zurück, aber das wäre seltsam.
- Wer hat Visual Studio installiert ist, es zu versuchen?
InformationsquelleAutor Brad Cunningham
7

Etwas kompakter als die anderen Antworten, wenn Sie möchten, verwenden Sie c als ein TForm:
```
if(c is TForm form){
    form.DoStuff();
}
```
InformationsquelleAutor Ali Rahman
3

Versuchen Sie die folgenden
```
if (c is TForm) { 
 ...
}
```
InformationsquelleAutor JaredPar
2

Wie andere erwähnt haben, die "ist" - Schlüsselwort. Allerdings, wenn Sie gehen, um später Stimmen Sie zu, dass die Art, wie zB.
```
TForm t = (TForm)c;
```
Dann sollten Sie das "as" Schlüsselwort.

z.B. TForm t = c as TForm.

Dann können Sie
```
if(t != null)
{
 //put TForm specific stuff here
}
```
Nicht kombinieren, wie mit ist, weil es eine doppelte Prüfung.

InformationsquelleAutor taylonr
0

Oder
```
c.getType() == typeOf(TForm)
```
InformationsquelleAutor Raynos
-1
```
bool isValid = c.GetType() == typeof(TForm) ? true : false;
```
oder einfacher
```
bool isValid = c.GetType() == typeof(TForm);
```
- sehr Niedlich. Dies ist deutlich sinnvoller.
- IMHO: ich würde vermeiden eine direkte Mitgefühl (ie. ==). Im Objekt-oder orientierte Sprachen mit Vererbung, es sei denn, Sie wissen, dass Ihre spezifische Art wird nie vererbt werden, von beispielsweise einem sealed Klasse. Auch: Nutzung von ternär Rückkehr (statisch/konstant), Boolesche Werte mich stört, ich wäre weniger Mühe, wenn es ein switch - Anweisung.
InformationsquelleAutor Gabe

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.