The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Attributes

Next ►
►

Attributes in C# provide a powerful way to add metadata to your code. This metadata can be used to control the behavior of your program at runtime, provide information to tools, or influence the way your code is compiled. In this section, we will explore what attributes are, how to use them, and how to create custom attributes.

What are Attributes?

Attributes are a form of metadata that you can add to your code elements such as classes, methods, properties, and more. They provide additional information that can be used by the runtime or other tools.

Key Concepts:

  • Metadata: Data that provides information about other data.
  • Attribute Class: A class that derives from System.Attribute.
  • Attribute Usage: Specifies the types of items an attribute can be applied to.

Using Attributes

Attributes are applied to code elements by placing them in square brackets above the element. Here are some common built-in attributes:

Example: Applying Attributes

using System;

[Obsolete("This class is obsolete. Use NewClass instead.")]
public class OldClass
{
    [Obsolete("This method is obsolete. Use NewMethod instead.")]
    public void OldMethod()
    {
        Console.WriteLine("Old method");
    }
}

public class NewClass
{
    public void NewMethod()
    {
        Console.WriteLine("New method");
    }
}

Explanation:

  • [Obsolete]: Marks the class or method as obsolete, generating a warning if it is used.
  • The string parameter provides a message that will be displayed in the warning.

Common Built-in Attributes

Attribute Description
[Obsolete] Marks a program element as obsolete.
[Serializable] Indicates that a class can be serialized.
[DllImport] Indicates that a method is implemented in an unmanaged DLL.
[Conditional] Specifies that a method call is conditional on a compilation symbol.
[AttributeUsage] Specifies the types of items an attribute can be applied to.

Creating Custom Attributes

You can create your own attributes by deriving from the System.Attribute class.

Example: Custom Attribute

using System;

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class AuthorAttribute : Attribute
{
    public string Name { get; }
    public string Version { get; }

    public AuthorAttribute(string name, string version)
    {
        Name = name;
        Version = version;
    }
}

[Author("John Doe", "1.0")]
public class SampleClass
{
    [Author("Jane Doe", "1.1")]
    public void SampleMethod()
    {
        Console.WriteLine("Sample method");
    }
}

Explanation:

  • AttributeUsage: Specifies that the AuthorAttribute can be applied to classes and methods.
  • AuthorAttribute: A custom attribute with Name and Version properties.

Accessing Attributes at Runtime

You can use reflection to access attribute information at runtime.

Example: Accessing Custom Attributes

using System;
using System.Reflection;

public class Program
{
    public static void Main()
    {
        Type type = typeof(SampleClass);
        object[] classAttributes = type.GetCustomAttributes(typeof(AuthorAttribute), false);

        foreach (AuthorAttribute attr in classAttributes)
        {
            Console.WriteLine($"Class {type.Name} authored by {attr.Name}, version {attr.Version}");
        }

        MethodInfo method = type.GetMethod("SampleMethod");
        object[] methodAttributes = method.GetCustomAttributes(typeof(AuthorAttribute), false);

        foreach (AuthorAttribute attr in methodAttributes)
        {
            Console.WriteLine($"Method {method.Name} authored by {attr.Name}, version {attr.Version}");
        }
    }
}

Explanation:

  • GetCustomAttributes: Retrieves the custom attributes applied to a class or method.
  • The example prints the author and version information for the SampleClass and its SampleMethod.

Practical Exercise

Exercise: Create and Use a Custom Attribute

  1. Create a custom attribute named DocumentationAttribute with properties Description and Version.
  2. Apply this attribute to a class and a method.
  3. Write a program to retrieve and display the attribute information at runtime.

Solution:

using System;
using System.Reflection;

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class DocumentationAttribute : Attribute
{
    public string Description { get; }
    public string Version { get; }

    public DocumentationAttribute(string description, string version)
    {
        Description = description;
        Version = version;
    }
}

[Documentation("This is a sample class", "1.0")]
public class SampleClass
{
    [Documentation("This is a sample method", "1.1")]
    public void SampleMethod()
    {
        Console.WriteLine("Sample method");
    }
}

public class Program
{
    public static void Main()
    {
        Type type = typeof(SampleClass);
        object[] classAttributes = type.GetCustomAttributes(typeof(DocumentationAttribute), false);

        foreach (DocumentationAttribute attr in classAttributes)
        {
            Console.WriteLine($"Class {type.Name}: {attr.Description}, version {attr.Version}");
        }

        MethodInfo method = type.GetMethod("SampleMethod");
        object[] methodAttributes = method.GetCustomAttributes(typeof(DocumentationAttribute), false);

        foreach (DocumentationAttribute attr in methodAttributes)
        {
            Console.WriteLine($"Method {method.Name}: {attr.Description}, version {attr.Version}");
        }
    }
}

Explanation:

  • DocumentationAttribute: Custom attribute with Description and Version properties.
  • The program retrieves and displays the attribute information for the SampleClass and its SampleMethod.

Summary

In this section, we covered:

  • What attributes are and how they provide metadata.
  • How to use built-in attributes.
  • How to create and apply custom attributes.
  • How to access attribute information at runtime using reflection.

Understanding attributes is crucial for writing more expressive and maintainable C# code. In the next section, we will delve into dynamic programming in C#.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved