Overload Resolution Priority Attribute in C#

Back to: C# New Features Tutorials

Overload Resolution Priority Attribute in C#

In this article, I will discuss the Overload Resolution Priority Attribute in C# with Examples. Please read our previous article discussing Extension Properties and Indexers in C# with Examples. In C# 13, a new feature called the Overload Resolution Priority Attribute has been introduced. This feature allows developers to control the order in which method overloads are selected during overload resolution. Specifically, it helps in scenarios where multiple overloaded methods can be matched for a given call, allowing you to prioritize one method over others.

The Overload Resolution Priority Attribute provides better control over which method is selected when multiple overloads are available. It reduces ambiguity in method selection and ensures the most appropriate method is chosen for the task.

What is Overload Resolution in C#?

Overload resolution occurs when a method or operator is called and there are multiple possible candidate methods (overloads) that could match the parameters of the call. The compiler must decide which method to invoke based on the types and number of arguments passed to the method.

In C#, when there are multiple overloaded methods, the compiler uses a set of rules to determine which overload to call. These rules include factors like:

• The number of arguments.
• The types of arguments.
• The conversions needed (if any).
• Optional parameters and default values.

However, in cases where overloads are equally applicable, C# may choose an overload based on its internal rules, which might not always be what the developer intends.

What Does the Overload Resolution Priority Attribute Do?

The Overload Resolution Priority Attribute allows you to explicitly specify the priority of overloads in scenarios where there is ambiguity. By applying this attribute, you can indicate which method should be given higher priority in the overload resolution process.

This attribute is particularly useful when you have several overloaded methods that are nearly identical but have subtle differences in their signatures.

Syntax of the Overload Resolution Priority Attribute

To use the Overload Resolution Priority Attribute, apply it to an overload of a method and specify its priority. The overload with the higher priority will be preferred over the others during overload resolution. The attribute takes an integer value to represent the priority. Higher values indicate higher priority.

[OverloadResolutionPriority(priority: int)]
public void SomeMethod(...);

Where:

• priority is an integer that defines the priority of the method.
• The method with the highest priority will be chosen in case of ambiguity.

Example: Using Overload Resolution Priority Attribute in C#

Let’s take an example where we have two overloaded methods for performing string concatenation, and we want to prioritize one method over another using the OverloadResolutionPriority attribute.

namespace CSharp13NewFeatures
{
    // Define a custom attribute for overload resolution priority
    [AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
    public sealed class OverloadResolutionPriorityAttribute : Attribute
    {
        public int Priority { get; }

        public OverloadResolutionPriorityAttribute(int priority)
        {
            Priority = priority;
        }
    }

    public class StringOperations
    {
        // Method 1: Concatenates two strings
        [OverloadResolutionPriority(1)]  // Higher priority for this method
        public void Concatenate(string a, string b)
        {
            Console.WriteLine($"Concatenating two strings: {a + b}");
        }

        // Method 2: Concatenates a string and an integer (overload)
        [OverloadResolutionPriority(0)]  // Lower priority for this method
        public void Concatenate(string a, int b)
        {
            Console.WriteLine($"Concatenating string and integer: {a + b}");
        }
    }

    public class Program
    {
        static void Main()
        {
            StringOperations operations = new StringOperations();

            // Ambiguous call, but Concatenate(string, string) has higher priority
            operations.Concatenate("Hello", "World");  // This should call the method with higher priority

            // This will call the Concatenate(string, int) method
            operations.Concatenate("Age: ", 30);  // Concatenates string and integer
        }
    }
}

Code Explanation:

• OverloadResolutionPriorityAttribute: A custom attribute that takes an integer priority as a parameter. Methods with higher priority values are selected during overload resolution.
• Concatenate(string, string): The first method that concatenates two strings has a higher priority (priority = 1).
• Concatenate(string, int): The second method that concatenates a string with an integer has a lower priority (priority = 0).
• When both methods could be a valid match (e.g., when calling operations.Concatenate(“Hello”, “World”)), the method with the higher priority (Concatenate(string, string)) is chosen.

Output:

Key Takeaways:

• Priority: The method with higher priority (priority = 1) is selected when multiple overloads match.
• Resolution: Even when multiple overloads are available, the priority attribute dictates which overload the compiler chooses.

Example: Overload Resolution in Logging System

Let’s consider an example in a logging system where we have several overloaded methods for logging messages. We use OverloadResolutionPriorityAttribute to ensure that the correct method is chosen when both string and object arguments are provided.

namespace CSharp13NewFeatures
{
    // Define the OverloadResolutionPriorityAttribute
    [AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
    public sealed class OverloadResolutionPriorityAttribute : Attribute
    {
        public int Priority { get; }

        public OverloadResolutionPriorityAttribute(int priority)
        {
            Priority = priority;
        }
    }

    public class Logger
    {
        // Logging method 1: Log a message as a string
        [OverloadResolutionPriority(1)]
        public void LogMessage(string message)
        {
            Console.WriteLine($"Log (string): {message}");
        }

        // Logging method 2: Log a message as an object (includes type information)
        [OverloadResolutionPriority(0)]
        public void LogMessage(object message)
        {
            Console.WriteLine($"Log (object): {message} ({message.GetType().Name})");
        }
    }

    public class Program
    {
        static void Main()
        {
            Logger logger = new Logger();

            // Calls the method with the highest priority: LogMessage(string)
            logger.LogMessage("This is a string log message");

            // Calls the method with object parameter (lower priority)
            logger.LogMessage(12345);  // This will invoke LogMessage(object)
        }
    }
}

Code Explanation:

• LogMessage(string): This method logs a message as a string and is given higher priority (priority = 1).
• LogMessage(object): This method logs a message as an object and is given lower priority (priority = 0).
• The LogMessage(“This is a string log message”) call resolves to the method with the higher priority, i.e., the string version of LogMessage.

Output:

Real-Time Use Cases for the Overload Resolution Priority Attribute

• Logging Systems: In logging frameworks, you may have multiple overloads for logging messages as strings, objects, or structured data. The OverloadResolutionPriority attribute allows you to ensure that string-based logs take precedence over generic object logs when the arguments are ambiguous.
• Serialization Systems: In a serialization library, you might want to prioritize the serialization method for specific types (e.g., prioritizing the SerializeToJson(string) method over SerializeToJson(object) for better efficiency or performance).
• UI Frameworks: In a UI framework, multiple button-click handler overloads could be defined for different types of event data. The priority attribute allows you to prioritize one handler method over others when event arguments are ambiguous.
• Database Access: In database access systems, you may have multiple overloads for fetching records using string-based IDs or numeric IDs. The priority attribute allows prioritizing one overload to ensure it’s used when both types of arguments are present.

The Overload Resolution Priority attribute in C# 13 introduces a new level of control over method overload resolution. It allows you to explicitly specify which method to prioritize when multiple overloads could match a given call. This feature is especially useful in scenarios where overloads are similar, but you want to enforce a particular resolution order.

By using the OverloadResolutionPriority attribute, you can improve the predictability and clarity of your code, ensure the right method is selected, and avoid potential bugs in method resolution.

In the next article, I will discuss Primary Constructors for Records in C# with Examples. In this article, I explain the Overload Resolution Priority Attribute in C# with Examples. I would like your feedback. Please post your feedback, questions, or comments about this article.