Come posso ottenere il tipo di dati di una variabile in C #?

Come posso sapere quale tipo di dati contiene una variabile? (es. int, string, char, ecc.)

Ho qualcosa di simile ora:

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;
        }
    }
}

C'è una questione importante e sottile che nessuno di loro affronta direttamente. Esistono due modi per considerare il tipo in C #: tipo statico e tipo in fase di esecuzione .

Il tipo statico è il tipo di una variabile nel codice sorgente. È quindi un concetto in fase di compilazione. Questo è il tipo visualizzato in una descrizione comando quando passi il mouse su una variabile o una proprietà nel tuo ambiente di sviluppo.

Puoi ottenere il tipo statico scrivendo un metodo generico di supporto per lasciare che l'inferenza del tipo se ne occupi per te:

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

Il tipo di runtime è il tipo di un oggetto in memoria. È quindi un concetto di runtime. Questo è il tipo restituito dal GetType()metodo.

Il tipo di runtime di un oggetto è spesso diverso dal tipo statico della variabile, della proprietà o del metodo che lo contiene o lo restituisce. Ad esempio, puoi avere un codice come questo:

object o = "Some string";

Il tipo statico della variabile è object, ma in fase di esecuzione, il tipo di referente della variabile è string. Pertanto, la riga successiva stamperà "System.String" sulla console:

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

Tuttavia, se passi il mouse sulla variabile onel tuo ambiente di sviluppo, vedrai il tipo System.Object(o la objectparola chiave equivalente ). Puoi anche vedere lo stesso usando la nostra funzione di supporto dall'alto:

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

Per le variabili tipo valore, come ad esempio int, double, System.Guid, si sa che il tipo run-time sarà sempre lo stesso tipo statico, perché i tipi di valore non possono servire come classe base per un altro tipo; il tipo di valore è garantito come il tipo più derivato nella sua catena di ereditarietà. Questo vale anche per i tipi di riferimento sigillati: se il tipo statico è un tipo di riferimento sigillato, il valore di runtime deve essere un'istanza di quel tipo o null.

Al contrario, se il tipo statico della variabile è un tipo astratto, è garantito che il tipo statico e il tipo runtime saranno diversi.

Per illustrarlo nel codice:

// 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));

È molto semplice

variable.GetType().Name

restituirà il tipo di dati della variabile

In generale, non avrai quasi mai bisogno di fare confronti di tipo a meno che tu non stia facendo qualcosa con la riflessione o le interfacce. Ciò nonostante:

Se conosci il tipo con cui vuoi confrontarlo, utilizza gli operatori iso as:

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

L' asoperatore esegue un cast che restituisce null se fallisce piuttosto che un'eccezione:

TypeIKnow typed = unknownObject as TypeIKnow;

Se non conosci il tipo e desideri solo informazioni sul tipo di runtime, utilizza il metodo .GetType ():

Type typeInformation = unknownObject.GetType();

Nelle versioni più recenti di C #, puoi usare l' isoperatore per dichiarare una variabile senza bisogno di usare as:

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

In precedenza avresti dovuto fare questo:

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

Tieni semplicemente il cursore sul membro che ti interessa e visualizza il suggerimento: mostrerà il tipo di memeber:

Usa il metodo GetType ()

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

Un'opzione potrebbe essere quella di utilizzare un metodo di estensione helper come segue:

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

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

GetType() metodo

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

controlla uno dei modi più semplici per farlo

// 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.");
        }