Answer.

Background

In the .NET platform, and therefore in Visual Basic, attributes were introduced as a powerful tool for annotating various code elements with metadata. This allows programs and tools to gain additional information at runtime and compile time, configuring the behavior of methods, classes, and properties through reflection, serialization, automated testing, and so on.

Problem

Without attributes, one has to hard-code additional logic for configuring methods or classes, and generic libraries cannot be extensible and flexible without external information about the class or method. There's also the issue of passing settings without changing the actual code.

Solution

Attributes are special classes that inherit from Attribute. They can be created and applied to methods, classes, properties, parameters, or return values. At runtime, these attributes can be discovered through reflection and modify the behavior of the corresponding logic.

Example code for creating and using a custom attribute:

Imports System

<AttributeUsage(AttributeTargets.Class Or AttributeTargets.Method, AllowMultiple:=False)>
Public Class InfoAttribute
    Inherits Attribute
    Public Property Description As String
    Public Sub New(desc As String)
        Description = desc
    End Sub
End Class

<Info("Special business logic method.")>
Public Sub Calculate()
    Console.WriteLine("Calculation performed.")
End Sub

' Reading the attribute via reflection
Dim method = GetType(Module1).GetMethod("Calculate")
Dim attr = CType(Attribute.GetCustomAttribute(method, GetType(InfoAttribute)), InfoAttribute)
If attr IsNot Nothing Then Console.WriteLine(attr.Description)

Key features:

Custom attributes are created from classes that inherit from Attribute
Attributes can be applied to various elements ( AttributeTargets.Class, Method, Property, etc.)
Used for serialization, validation, DI frameworks, configuring behavior at runtime and during code generation

Trick questions.

Can attributes directly change the behavior of a method or class without using reflection?

No, attributes themselves contain only metadata. The behavior of an object can only be changed if the calling code or runtime checks for the presence of the attribute via reflection and takes additional actions.

Can the same attribute be applied multiple times to the same element, and what is required for this?

By default — no. To allow this upon declaration of the attribute, AllowMultiple:=True must be specified in AttributeUsage. Then one attribute can be applied multiple times to one element.

Are attributes inherited from base class to derived class?

No, by default — they are not inherited. If inheritance is required, the AttributeUsage specifies the parameter Inherited:=True.

Common mistakes and anti-patterns

Using attributes without subsequent analysis or processing through reflection
Attempting to store complex objects in the attribute instead of simple ones (only serializable values are allowed)
Not specifying AttributeTargets, which leads to application errors

Real-life example

Negative case

In a project, custom attributes are mass-applied to methods, but no one implements processing of these attributes through reflection — such code becomes a useless burden, complicating maintenance and readability of the source code.

Pros:

Easy to add the necessary tag to the necessary code element
Documentation is simplified

Cons:

No effect on application behavior
Useless complexity

Positive case

An attribute is used for annotating logging methods, and a separate subsystem automatically determines, through reflection, which methods are subject to auditing, inserts analytics, and adds tracing. The behavior is transparent to the user.