How can I get the data type of a variable in C#?
C#TypesC# Problem Overview
How can I find out what data type some variable is holding? (e.g. int, string, char, etc.)
I have something like this now:
private static void Main()
{
var someone = new Person();
Console.WriteLine(someone.Name.typeOf());
}
public class Person
{
public int Name { get; set; }
}
C# Solutions
Solution 1 - C#
Other answers offer good help with this question, but there is an important and subtle issue that none of them addresses directly. There are two ways of considering type in C#: static type and run-time type.
Static type is the type of a variable in your source code. It is therefore a compile-time concept. This is the type that you see in a tooltip when you hover over a variable or property in your development environment.
Run-time type is the type of an object in memory. It is therefore a run-time concept. This is the type returned by the GetType()
method.
An object's run-time type is frequently different from the static type of the variable, property, or method that holds or returns it. For example, you can have code like this:
object o = "Some string";
The static type of the variable is object
, but at run time, the type of the variable's referent is string
. Therefore, the next line will print "System.String" to the console:
Console.WriteLine(o.GetType()); // prints System.String
But, if you hover over the variable o
in your development environment, you'll see the type System.Object
(or the equivalent object
keyword).
For value-type variables, such as int
, double
, System.Guid
, you know that the run-time type will always be the same as the static type, because value types cannot serve as the base class for another type; the value type is guaranteed to be the most-derived type in its inheritance chain. This is also true for sealed reference types: if the static type is a sealed reference type, the run-time value must either be an instance of that type or null
.
Conversely, if the static type of the variable is an abstract type, then it is guaranteed that the static type and the runtime type will be different.
To illustrate that in code:
// 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));
Another user edited this answer to incorporate a function that appears below in the comments, a generic helper method to use type inference to get a reference to a variable's static type at run time, thanks to typeof
:
Type GetStaticType<T>(T x) => typeof(T);
You can use this function in the example above:
Console.WriteLine(GetStaticType(o)); // prints System.Object
But this function is of limited utility unless you want to protect yourself against refactoring. When you are writing the call to GetStaticType
, you already know that o's static type is object. You might as well write
Console.WriteLine(typeof(object)); // also prints System.Object!
This reminds me of some code I encountered when I started my current job, something like
SomeMethod("".GetType().Name);
instead of
SomeMethod("String");
Solution 2 - C#
Its Very simple
variable.GetType().Name
it will return your datatype of your variable
Solution 3 - C#
Generally speaking, you'll hardly ever need to do type comparisons unless you're doing something with reflection or interfaces. Nonetheless:
If you know the type you want to compare it with, use the is
or as
operators:
if( unknownObject is TypeIKnow ) { // run code here
The as
operator performs a cast that returns null if it fails rather than an exception:
TypeIKnow typed = unknownObject as TypeIKnow;
If you don't know the type and just want runtime type information, use the .GetType() method:
Type typeInformation = unknownObject.GetType();
In newer versions of C#, you can use the is
operator to declare a variable without needing to use as
:
if( unknownObject is TypeIKnow knownObject ) {
knownObject.SomeMember();
}
Previously you would have to do this:
TypeIKnow knownObject;
if( (knownObject = unknownObject as TypeIKnow) != null ) {
knownObject.SomeMember();
}
Solution 4 - C#
Just hold cursor over member you interested in, and see tooltip - it will show memeber's type:
Solution 5 - C#
Use the GetType() method
http://msdn.microsoft.com/en-us/library/system.object.gettype.aspx
Solution 6 - C#
One option would be to use a helper extension method like follows:
public static class MyExtensions
{
public static System.Type Type<T>(this T v) => typeof(T);
}
var i = 0;
console.WriteLine(i.Type().FullName);
Solution 7 - C#
GetType()
method
int n = 34;
Console.WriteLine(n.GetType());
string name = "Smome";
Console.WriteLine(name.GetType());
Solution 8 - C#
Use the Object.GetType
Method, this will do the job.
If you just wanna know the type of a variable:
var test = (byte)1;
Console.WriteLine(test.GetType());
Solution 9 - C#
Check out one of the simple way to do this
// 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.");