Custom attribute classes in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Custom attribute classes

Define attribute class

↓

Apply attribute to target

↓

Run program

↓

Use reflection to read attribute

↓

Access attribute data

↓

Use data in program

First, you create a custom attribute class. Then you put it on something like a class or method. When the program runs, you read that attribute using reflection to get its data.

Execution Sample

C Sharp (C#)

using System;

[AttributeUsage(AttributeTargets.Class)]
class MyInfoAttribute : Attribute {
  public string Info { get; }
  public MyInfoAttribute(string info) => Info = info;
}

[MyInfo("Hello World")]
class MyClass {}

class Program {
  static void Main() {
    var attr = (MyInfoAttribute)Attribute.GetCustomAttribute(typeof(MyClass), typeof(MyInfoAttribute));
    Console.WriteLine(attr.Info);
  }
}

This code defines a custom attribute with a string, applies it to a class, then reads and prints the string at runtime.

Execution Table

Step	Action	Evaluation	Result
1	Define MyInfoAttribute class	Class created	Ready to use attribute
2	Apply [MyInfo("Hello World")] to MyClass	Attribute attached to MyClass	MyClass has attribute data
3	Start Main method	Program runs	Ready to get attribute
4	Call Attribute.GetCustomAttribute for MyClass	Find MyInfoAttribute on MyClass	Returns MyInfoAttribute instance
5	Access attr.Info	Get string value	"Hello World"
6	Print attr.Info	Output to console	Hello World
7	Program ends	No more code	Execution stops

💡 Program ends after printing the attribute's Info string

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
attr	null	MyInfoAttribute instance	MyInfoAttribute instance	MyInfoAttribute instance
attr.Info	N/A	N/A	"Hello World"	"Hello World"

Key Moments - 3 Insights

Why do we cast the result of GetCustomAttribute to MyInfoAttribute?

GetCustomAttribute returns a general Attribute object, so we cast it to MyInfoAttribute to access the Info property, as shown in step 4 of the execution_table.

What happens if the attribute is not found on the class?

GetCustomAttribute returns null, so attr would be null and accessing attr.Info would cause an error. This is why checking for null is important in real code.

Why do we use [AttributeUsage(AttributeTargets.Class)] on the attribute class?

This limits the attribute to be used only on classes, preventing misuse on other targets like methods or properties.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of attr.Info at step 5?

A null

B "Hello World"

C An error

D "MyClass"

💡 Hint

Check the 'Evaluation' and 'Result' columns at step 5 in the execution_table.

At which step does the program find the attribute instance on MyClass?

A Step 4

B Step 6

C Step 3

D Step 2

💡 Hint

Look for when Attribute.GetCustomAttribute is called in the execution_table.

If we remove [AttributeUsage(AttributeTargets.Class)], what might happen?

A The attribute will not be found at runtime.

B The program will not compile.

C The attribute can be applied to any target, not just classes.

D The Info property will be empty.

💡 Hint

Refer to the key_moments explanation about AttributeUsage.

Concept Snapshot

Custom attribute classes let you add extra info to code elements.
Define a class inheriting Attribute.
Use [AttributeUsage] to limit targets.
Apply with [YourAttribute(...)] syntax.
Read at runtime with reflection (GetCustomAttribute).
Access your data from the attribute instance.

Full Transcript

This lesson shows how to create and use custom attribute classes in C#. First, you define a class that inherits from Attribute and add any properties you want. Then you apply this attribute to a class using square brackets. When the program runs, you use reflection to get the attribute instance from the class and read its data. The example prints the string stored in the attribute. Key points include casting the attribute to your custom type and using AttributeUsage to control where the attribute can be applied.

Practice

1. What is the main purpose of creating a custom attribute class in C#?

easy

A. To create a new data type for variables

B. To replace the main class in a program

C. To add extra information to code elements like classes or methods

D. To handle exceptions automatically

Solution

1. Step 1: Understand what attributes do

   Attributes add metadata, or extra info, to code elements like classes or methods.

2. Step 2: Identify the role of custom attributes

   Custom attributes let you define your own extra info to attach to code elements.

3. Final Answer:

   To add extra information to code elements like classes or methods -> Option C

4. Quick Check:

   Custom attributes = extra info [OK]

Hint: Attributes add info to code elements, not change logic [OK]

Common Mistakes:

• Thinking attributes replace classes
• Confusing attributes with data types
• Assuming attributes handle errors

2. Which of the following is the correct way to declare a custom attribute class named InfoAttribute?

easy

A. public struct InfoAttribute : Attribute {}

B. public attribute InfoAttribute {}

C. public class InfoAttribute extends Attribute {}

D. public class InfoAttribute : System.Attribute {}

Solution

1. Step 1: Recall C# syntax for custom attributes

   Custom attribute classes must inherit from System.Attribute using a class declaration.

2. Step 2: Check each option

   public class InfoAttribute : System.Attribute {} correctly uses 'public class InfoAttribute : System.Attribute {}'. public attribute InfoAttribute {} uses invalid keyword 'attribute'. public class InfoAttribute extends Attribute {} uses 'extends' which is Java syntax. public struct InfoAttribute : Attribute {} uses 'struct' which is not correct for attributes.

3. Final Answer:

   public class InfoAttribute : System.Attribute {} -> Option D

4. Quick Check:

   Custom attribute = class + : System.Attribute [OK]

Hint: Custom attributes are classes inheriting System.Attribute [OK]

Common Mistakes:

• Using 'attribute' keyword instead of 'class'
• Using Java syntax 'extends' instead of ':'
• Declaring attribute as struct

3. What will be the output of the following code?

using System;
[Info("Version 1.0")]
class Program {}

public class InfoAttribute : Attribute
{
    public string Version { get; }
    public InfoAttribute(string version) => Version = version;
}

class Test
{
    static void Main()
    {
        var attrs = typeof(Program).GetCustomAttributes(typeof(InfoAttribute), false);
        if (attrs.Length > 0)
            Console.WriteLine(((InfoAttribute)attrs[0]).Version);
        else
            Console.WriteLine("No attribute");
    }
}

medium

A. Version 1.0

B. No attribute

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Understand attribute application

   The Program class has the Info attribute with version "Version 1.0" applied.

2. Step 2: Check reflection code

   The code uses reflection to get InfoAttribute from Program. Since it exists, it prints the Version property.

3. Final Answer:

   Version 1.0 -> Option A

4. Quick Check:

   Reflection finds attribute version = Version 1.0 [OK]

Hint: Reflection reads attribute properties if applied [OK]

Common Mistakes:

• Assuming attribute is not found
• Confusing attribute class with target class
• Forgetting to cast attribute before accessing property

4. Identify the error in this custom attribute declaration:

public class MyAttribute
{
    public string Name { get; set; }
    public MyAttribute(string name) { Name = name; }
}

medium

A. Missing inheritance from System.Attribute

B. Property Name should be private

C. Constructor should not have parameters

D. Class should be declared as struct

Solution

1. Step 1: Check inheritance requirement

   Custom attribute classes must inherit from System.Attribute to be recognized as attributes.

2. Step 2: Analyze given code

   The class MyAttribute does not inherit from System.Attribute, so it is not a valid attribute class.

3. Final Answer:

   Missing inheritance from System.Attribute -> Option A

4. Quick Check:

   Attributes must inherit System.Attribute [OK]

Hint: Always inherit System.Attribute for custom attributes [OK]

Common Mistakes:

• Forgetting to inherit System.Attribute
• Thinking constructor must be parameterless
• Using struct instead of class

5. You want to create a custom attribute PriorityAttribute that accepts an integer priority level and can be applied only to methods. Which of the following is the correct way to declare it?

hard

A. [AttributeUsage(AttributeTargets.Class)]
public class PriorityAttribute : Attribute
{
public int Level;
public PriorityAttribute(int level) { Level = level; }
}

B. [AttributeUsage(AttributeTargets.Method)]
public class PriorityAttribute : Attribute
{
public int Level { get; }
public PriorityAttribute(int level) => Level = level;
}

C. public class PriorityAttribute : Attribute
{
public int Level { get; set; }
public PriorityAttribute() {}
}

D. [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)]
public struct PriorityAttribute
{
public int Level;
public PriorityAttribute(int level) { Level = level; }
}

Solution

1. Step 1: Check AttributeUsage target

   The attribute should apply only to methods, so AttributeTargets.Method is correct.

2. Step 2: Verify class declaration and constructor

   It must be a class inheriting Attribute, with a constructor accepting an int and a read-only property.

3. Step 3: Review options

   [AttributeUsage(AttributeTargets.Method)] public class PriorityAttribute : Attribute { public int Level { get; } public PriorityAttribute(int level) => Level = level; } matches all requirements. [AttributeUsage(AttributeTargets.Class)] public class PriorityAttribute : Attribute { public int Level; public PriorityAttribute(int level) { Level = level; } } targets classes, not methods. public class PriorityAttribute : Attribute { public int Level { get; set; } public PriorityAttribute() {} } lacks constructor parameter and target restriction. [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)] public struct PriorityAttribute { public int Level; public PriorityAttribute(int level) { Level = level; } } uses struct, which is invalid for attributes.

4. Final Answer:

   [AttributeUsage(AttributeTargets.Method)] public class PriorityAttribute : Attribute { public int Level { get; } public PriorityAttribute(int level) => Level = level; } -> Option B

5. Quick Check:

   AttributeUsage + class + constructor with param = [AttributeUsage(AttributeTargets.Method)] public class PriorityAttribute : Attribute { public int Level { get; } public PriorityAttribute(int level) => Level = level; } [OK]

Hint: Use AttributeUsage to limit targets and inherit Attribute [OK]

Common Mistakes:

• Using struct instead of class
• Wrong AttributeTargets in AttributeUsage
• Missing constructor parameter for priority