Wie kann ich den Datentyp einer Variablen in C # abrufen?

Wie kann ich herausfinden, welchen Datentyp eine Variable enthält? (zB int, string, char usw.)

Ich habe jetzt so etwas:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Testing
{
    class Program
    {
        static void Main()
        {
            Person someone = new Person();
            someone.setName(22);
            int n = someone.getName();
            Console.WriteLine(n.typeOf());
        }
    }

    class Person
    {
        public int name;

        public void setName(int name)
        {
            this.name = name;
        }

        public int getName()
        {
            return this.name;
        }
    }
}

Es gibt ein wichtiges und subtiles Problem, das keiner von ihnen direkt anspricht. Es gibt zwei Möglichkeiten, den Typ in C # zu berücksichtigen: den statischen Typ und den Laufzeittyp .

Der statische Typ ist der Typ einer Variablen in Ihrem Quellcode. Es ist daher ein Konzept zur Kompilierungszeit. Dies ist der Typ, den Sie in einem Tooltip sehen, wenn Sie mit der Maus über eine Variable oder Eigenschaft in Ihrer Entwicklungsumgebung fahren.

Sie können einen statischen Typ erhalten, indem Sie eine generische Hilfsmethode schreiben, damit die Typinferenz dies für Sie erledigt:

   Type GetStaticType<T>(T x) { return typeof(T); }

Der Laufzeittyp ist der Typ eines Objekts im Speicher. Es ist daher ein Laufzeitkonzept. Dies ist der von der GetType()Methode zurückgegebene Typ .

Der Laufzeittyp eines Objekts unterscheidet sich häufig vom statischen Typ der Variablen, Eigenschaft oder Methode, die es enthält oder zurückgibt. Sie können beispielsweise folgenden Code verwenden:

object o = "Some string";

Der statische Typ der Variablen ist object, aber während der Laufzeit, die Art der Variable referent ist string. Daher wird in der nächsten Zeile "System.String" auf der Konsole gedruckt:

Console.WriteLine(o.GetType()); // prints System.String

Wenn Sie jedoch mit der Maus über die Variable oin Ihrer Entwicklungsumgebung fahren, wird der Typ System.Object(oder das entsprechende objectSchlüsselwort) angezeigt. Sie sehen dasselbe auch mit unserer Hilfsfunktion von oben:

Console.WriteLine(GetStaticType(o)); // prints System.Object

Für Value-Typen Variablen, wie int, double, System.Guid, wissen Sie , dass der Laufzeittyp immer gleich den statischen Typen sein, da die Value - Typen können nicht als Basisklasse für eine andere Art dienen; Der Werttyp ist garantiert der am meisten abgeleitete Typ in seiner Vererbungskette. Dies gilt auch für versiegelte Referenztypen: Wenn der statische Typ ein versiegelter Referenztyp ist, muss der Laufzeitwert entweder eine Instanz dieses Typs sein oder null.

Wenn umgekehrt der statische Typ der Variablen ein abstrakter Typ ist, ist garantiert, dass der statische Typ und der Laufzeittyp unterschiedlich sind.

Um dies im Code zu veranschaulichen:

// int is a value type
int i = 0;
// Prints True for any value of i
Console.WriteLine(i.GetType() == typeof(int));

// string is a sealed reference type
string s = "Foo";
// Prints True for any value of s
Console.WriteLine(s == null || s.GetType() == typeof(string));

// object is an unsealed reference type
object o = new FileInfo("C:\\f.txt");
// Prints False, but could be true for some values of o
Console.WriteLine(o == null || o.GetType() == typeof(object));

// FileSystemInfo is an abstract type
FileSystemInfo fsi = new DirectoryInfo("C:\\");
// Prints False for all non-null values of fsi
Console.WriteLine(fsi == null || fsi.GetType() == typeof(FileSystemInfo));

Es ist sehr einfach

variable.GetType().Name

Es wird Ihren Datentyp Ihrer Variablen zurückgeben

Im Allgemeinen müssen Sie kaum Typvergleiche durchführen, es sei denn, Sie tun etwas mit Reflexion oder Schnittstellen. Dennoch:

Wenn Sie den Typ kennen, mit dem Sie ihn vergleichen möchten, verwenden Sie die Operatoren isoder as:

if( unknownObject is TypeIKnow ) { // run code here

Der asOperator führt eine Umwandlung durch, die null zurückgibt, wenn dies fehlschlägt, und keine Ausnahme:

TypeIKnow typed = unknownObject as TypeIKnow;

Wenn Sie den Typ nicht kennen und nur Informationen zum Laufzeittyp wünschen, verwenden Sie die Methode .GetType ():

Type typeInformation = unknownObject.GetType();

In neueren Versionen von C # können Sie den isOperator verwenden, um eine Variable zu deklarieren, ohne Folgendes verwenden zu müssen as:

if( unknownObject is TypeIKnow knownObject ) {
    knownObject.SomeMember();
}

Zuvor mussten Sie Folgendes tun:

TypeIKnow knownObject;
if( (knownObject = unknownObject as TypeIKnow) != null ) {
    knownObject.SomeMember();
}

Halten Sie einfach den Mauszeiger über das Mitglied, an dem Sie interessiert sind, und sehen Sie den Tooltip - es wird der Typ des Mitglieds angezeigt:

Verwenden Sie die GetType () -Methode

http://msdn.microsoft.com/en-us/library/system.object.gettype.aspx

Eine Möglichkeit wäre die Verwendung einer Helfererweiterungsmethode wie folgt:

public static class MyExtensions
{
    public static System.Type Type<T>(this T v)=>typeof(T);
}

var i=0;
console.WriteLine(i.Type().FullName);

GetType() Methode

int n=34;
Console.WriteLine(n.GetType());
string name="Smome";
Console.WriteLine(name.GetType());

Schauen Sie sich einen der einfachen Wege an, dies zu tun

// Read string from console
        string line = Console.ReadLine(); 
        int valueInt;
        float valueFloat;
        if (int.TryParse(line, out valueInt)) // Try to parse the string as an integer
        {
            Console.Write("This input is of type Integer.");
        }
        else if (float.TryParse(line, out valueFloat)) 
        {
            Console.Write("This input is of type Float.");
        }
        else
        {
            Console.WriteLine("This input is of type string.");
        }