Javatpoint Logo
Javatpoint Logo

Type.GetCustomAttributes() method in C#

In this article, we will discuss the Type.GetCustomAttribures() in C# with its syntax, parameters, and examples.


In C#, the Type.GetCustomAttributes() procedure presents an expandable way to obtain specific characteristics that correspond to the types inside a program. Custom features constitute metadata that programmers may affix to different program elements, including fields, properties, methods, and classes, to communicate extraneous information or behavior not defined in the programming language itself. Developers can provide adaptable and adaptive behavior for programs by dynamically inspecting these properties throughout runtime using Type.GetCustomAttributes().

Type.GetCustomAttributes() method in C#

Developers need to first obtain a Type object that represents the desired type to use the Type.GetCustomAttributes() method. It is typically accomplished by calling the GetType () function on an instance or simply by using the typeof() operator. Upon obtaining the Type object, employing GetCustomAttributes () yields an array of objects that correspond to the custom attributes that were recently added to the type.

After that, if required, these qualities may be scrutinized, changed, or applied to affect the logic of the program.

An argument in Type.GetCustomAttributes()'s method signature determines whether or not the type's inheritance chain deserves to be included when performing the attribute search. The second choice allows programmers to personalize the search behavior to meet their particular needs by passing in true or false. Set this setting to false limits the search to attributes applied directly to the type itself, hence boosting efficiency in situations when inheritance traversal may not be required. Setting it to true broadens the search to include inherited attributes.

Type.GetCustomAttributes() is useful in many different kinds of applications that are practical, including serialization, dependency injection, and runtime reflection.

For example, developers might implement it to identify and set up components based on attributes, check program parts based on attribute restrictions, or record objects containing unique attributes in various formats. When everything is considered, the technique gives developers a greater degree of control over introspection, allowing for more exciting and adaptable C# programs.


It has the following syntax:

Example 1:

Let us take an example to illustrate the Type.GetCustomAttributes() method in C#.


Custom Attribute Message: This is a custom attribute


Definition of a Custom Parameter (MyCustomAttribute):

By deriving from Attribute, we develop a custom attribute entitled MyCustomAttribute. Classes (AttributeTargets.Class) can employ this attribute. The information associated with the attribute can be represented by a string argument labeled message, which is processed by the attribute constructor.

Using the Custom Attribute:

By positioning [MyCustom("This is a custom attribute")] beforehand the class declaration, we apply the MyCustomAttribute to the MyClass class. The attribute constructor is provided with the message "This is a custom attribute" in this instance.

Principal Technique:

In the main() function, the program's entrance point represents where they begin.

Sorting and Obtaining:

We make use of typeof(MyClass) to get a Type object that represents the MyClass type. As a result, we may operate within the MyClass type at runtime employing reflection.

Retrieve Attribute:

We invoke the GetCustomAttributes() function within the Kind object (type) to obtain an array of custom attributes applied to the MyClass type. They don't wish to begin searching for characteristics along the inheritance tree, according to the false argument.

Repetition and Presentation:

We use a function loop to traverse over the attributes array.

Using pattern matching, we ascertain if each attribute (which corresponds to the type MyCustomAttribute) is inside the loop.

In order to show the related message, we cast the attribute to be of type MyCustomAttribute and access its Message property if it corresponds to that type.


The message that is related to the MyCustomAttribute that was included in the MyClass class is shown in the program's output. This code illustrates the way to use the Type to define, are applicable, and receive custom characteristics.

Uses of Type.GetCustomAttributes() Method:

We can use the Type.GetCustomAttributes() function to obtain custom attributes that belong to certain types of objects in C#. We may add behavior or metadata to their code's types, techniques, characteristics, and other elements by using custom attributes. The following represent a few typical applications for Type.GetCustomAttributes():

  1. Reflection: In the context of reflection, GetCustomAttributes() allows individuals to dynamically inspect types at runtime. Frameworks and libraries that need to evaluate types or write general programming that adjusts to different properties might benefit from this.
  2. Annotation and info: Types can have extra info appended to them via custom attributes. For instance, attributes can be employed to establish a type's database mappings, validation rules, or serialization behavior.
  3. Runtime Behavior: The way our application's code behaves at runtime can be affected by custom characteristics. We may build a custom attribute, for example, to regulate authorization rights or simply to indicate specific types as "singleton".
  4. Code Generation: Tools for code generation can also employ characteristics as markers. Custom tools may have been written for use with reflection to examine your code in order to produce extra code based on the presence or absence among specific characteristics.

Example 2:


Description: This is a custom attribute


First, an individualized attribute called MyCustomAttribute has been established by the software. The constructor of this attribute, whose derives from the Attribute class, requires a string parameter to configure the Description value to them. These varieties of custom properties are frequently employed to give types in a C# program additional behavior or metadata.

Next, the [MyCustom("This is a custom attribute")] syntax is used to apply the custom attribute to a class called MyClass. This parameter allows us to correlate the given descriptions with the class, MyClass.

The application uses reflection to look into the MyClass type in the Main function. By utilizing the Type.GetCustomAttributes() function, it obtains an array of custom attributes that were previously assigned to MyClass.

The application limits the information it receives attributes to contain only instances of the MyCustomAttribute by putting in typeof(MyCustomAttribute) as a parameter to the application.

After that, the software loops throughout the elements of the attributes array, verifying that every one of them is of the MyCustomAttribute type. In such a scenario, it retrieves the Description property by casting the attribute to MyCustomAttribute. The console subsequently displays the following explanation.

Ultimately, after execution of the program, the description found in the custom attribute attached to MyClass-in this example, "This is a custom attribute" is produced.

In conclusion, the program shows how to make use of reflection for collecting attribute information at runtime using the type parameter and how to develop and make use of custom attributes in C# to annotate types using additional metadata.


In conclusion, the C# Type.GetCustomAttributes() function provides an effective tool for examining types to determine the custom characteristics that have recently been added to each. It additionally renders it possible to analyze types' information and behavior programmatically during runtime, which helps with a number of scenarios like code generation, metadata-driven programming, reflection-based frameworks, and runtime behavior customization.

Developers may write more extensible and dynamic code that responds to the presence or absence of particular characteristics by utilizing Type.GetCustomAttributes(). The above method is essential for realizing the full potential of custom attributes in C# programs, whether or not it is for producing code according to attribute markers, annotating types with additional metadata, or managing runtime behavior.

Youtube For Videos Join Our Youtube Channel: Join Now


Help Others, Please Share

facebook twitter pinterest

Learn Latest Tutorials


Trending Technologies

B.Tech / MCA