Type.Gettypefromhandle() Method In C#

In this article, we will discuss the "Type.GetTypeFromHandle" method in C# with its syntax, parameters, and examples.

What is the Type.GetTypeFromHandle method?

A static method in the Type class, "Type.GetTypeFromHandle" , is used in C#. It is utilized to get a Type object from a runtime handle (RuntimeTypeHandle). Using this method, developers may dynamically access type information at runtime. It is especially helpful when type manipulation, dynamic code generation, and reflection are involved.

Syntax:

It has the following syntax:

public static Type GetTypeFromHandle(RuntimeTypeHandle handle)

Parameters:

handle: The runtime handle of the type for which to obtain the Type object is represented by a RuntimeTypeHandle object.

Return Value:

The type associated with the given runtime handle is a Type object. The method returns null if the handle is invalid or does not correspond to a valid type.

The "Type.GetTypeFromHandle" method is usually used when the type has to be dynamically obtained at runtime but is unknown at compile time. Serialization, deserialization, dynamic code generation, and reflection-based scenarios are popular uses for this technique.

In some situations, compile-time information about an object's exact type is unavailable during runtime. The Type object that dynamically represents a type may be obtained by developers using the "Type.GetTypeFromHandle" method and the runtime handle of the type. It is important when dynamic access or manipulation of type information in code is required.

In order to avoid runtime errors in their applications, developers must gracefully handle such situations.

Example 1:

Let us take an example to illustrate the Type.GetTypeFromHandle method in C#.

Example


using System;
class C# Tutorial
{
    static void Main()
    {
        // Get the 'int' type's runtime handle.
        RuntimeTypeHandle h = typeof(int).TypeHandle;
        // Use GetTypeFromHandle to retrieve the Type object.
        Type t = Type.GetTypeFromHandle(h);
        // Display the full name of the retrieved type
        Console.WriteLine("Type name: " + t.FullName);
        // Get all public methods of the type
        Console.WriteLine("\nPublic methods of the type:");
        foreach (var method in t.GetMethods())
        {
            Console.WriteLine(method.Name);
        }
        // Obtain every public property of the typ
        Console.WriteLine("\nPublic properties of the type:");
        foreach (var property in t.GetProperties())
        {
            Console.WriteLine(property.Name);
        }
        // Verify whether the type is a value type.
        Console.WriteLine("\nIs the type a value type? " + t.IsValueType);
        // Verify whether the type is a generic type.
        Console.WriteLine("Is the type a generic type? " + t.IsGenericType);
        // Verify whether the type is an array type.
        Console.WriteLine("Is the type an array type? " + t.IsArray);
    }
}

Output:

Output


Type name: System.Int32
Public methods of the type:
CompareTo
CompareTo
Equals
Equals
GetHashCode
ToString
ToString
ToString
ToString
TryFormat
Parse
Parse
Parse
Parse
Parse
TryParse
TryParse
TryParse
TryParse
GetTypeCode
GetType
Public properties of the type:
Is the type a value type? True
Is the type a generic type? False
Is the type an array type? False

Explanation:

This code first retrieves the Type object for the int type, and then demonstrates how to access its methods and properties and determine if it's an array type, value type, or generic type by looking at its attributes. It gives us a thorough overview of the C# int type when it is run.

Example 2:

Let us take another example to illustrate the Type.GetTypeFromHandle method in C#.