Default Interface Implementations for Static Members in C#

Back to: C# New Features Tutorials

Default Interface Implementations for Static Members in C#

In this article, I will discuss Default Interface Implementations for Static Members in C# with Examples. Please read our previous article discussing Primary Constructors for Records in C# with Examples. In C# 13, the language introduced a powerful new feature allowing static members (such as static methods and static properties) to have default implementations inside interfaces. Before this, interfaces could only declare instance methods, and static methods or properties had to be defined in separate static helper classes or inside the implementing classes.

With default static implementations for interfaces, you can now define static methods and static properties directly inside an interface. This allows them to have default behavior that can be shared across all implementing types, providing more flexibility when designing interface-based architectures.

What Are Interfaces in C#?

An interface in C# is a contract that defines a set of methods or properties that must be implemented by any class or struct that inherits from the interface. However, interfaces cannot provide implementations for their members. They are only used to define the signature of methods or properties. Before C# 13, interfaces could only declare instance methods and instance properties, with no ability to specify static members.

What Changed in C# 13?

Before C# 13, interfaces could only contain instance methods and properties. Static members had to be placed in classes or static helper classes. With the introduction of default static implementations in C# 13, interfaces can now declare and provide default behaviors for static methods and properties. This allows the implementation of shared functionality directly in the interface, improving code reusability and modularity.

Key Features of Default Interface Implementations for Static Members

• Static Methods with Default Implementation: Interfaces can now define static methods with default implementations. Implementing classes can use these methods without needing to specify them explicitly.
• Static Properties with Default Implementation: Static properties with default values can now be defined in interfaces, eliminating the need for every class to re-implement them.
• Direct Access via Interface: Static methods and properties defined in an interface are accessed through the interface type, not through instances or implementing classes.
• No Inheritance of Static Members: Static members in interfaces do not participate in inheritance. They must be accessed using the interface type.
• Default Implementations for Static Members: You can define default behavior for static methods and properties, ensuring that implementing classes can use or override the default behavior.

What is the Default Static Method in an Interface?

A default static method in an interface allows you to define a static method inside an interface with a default implementation. Implementing classes can either use this default implementation or override it with their custom behavior.

public interface IExample
{
    // Static method with a default implementation
    public static void DoSomething()
    {
        Console.WriteLine("Default behavior from IExample interface.");
    }
}

Real-Time Scenario Using Default Static Method in Interface

Consider an email sending application where you define an interface IEmailService with a default static method for sending a basic email. This static method could be overridden by a class that uses different email services (like SMTP, Gmail API, etc.).

namespace CSharp13NewFeatures
{
    // Define the IEmailService interface
    public interface IEmailService
    {
        // Static method with default implementation
        public static void SendBasicEmail(string to, string subject, string body)
        {
            Console.WriteLine($"Sending email to {to} with subject '{subject}' and body: {body}");
        }
    }

    // Class that uses the default method in IEmailService
    public class DefaultEmailService : IEmailService
    {
        // The class doesn't need to implement the static method, it can use the default from IEmailService
    }

    public class Program
    {
        static void Main()
        {
            // Access static method from the interface directly
            IEmailService.SendBasicEmail("example@example.com", "Hello", "This is a test email.");
        }
    }
}

Code Explanation:

• The IEmailService interface defines a static method SendBasicEmail with a default implementation that outputs a basic email message.
• The DefaultEmailService class implements IEmailService but doesn’t need to redefine SendBasicEmail; it can use the default implementation from the interface.
• The static method is called via the interface (IEmailService.SendBasicEmail), not through the implementing class.

What is the Default Static Property in an Interface?

A default static property in an interface allows you to define static properties with default values that can be accessed directly through the interface. Implementing classes can use these properties directly without needing to override them.

public interface IExample
{
    // Static property with a default value
    public static string ExampleProperty { get; } = "Default Value";
}

Real-Time Scenario Using Default Static Property in Interface

Consider a configuration management system where you define default configuration settings in an interface, such as a default API endpoint. The interface can define a static property with a default value, and implementing classes can access this property without redefining it.

namespace CSharp13NewFeatures
{
    // Define an interface for configuration
    public interface IConfiguration
    {
        // Static property with a default value
        public static string ApiEndpoint { get; } = "https://api.default.com";
    }

    // Class implementing IConfiguration
    public class AppConfig : IConfiguration
    {
        // The class doesn't need to implement the static property; it's inherited from the interface
    }

    public class Program
    {
        static void Main()
        {
            // Access static property directly from the interface
            Console.WriteLine($"Default API Endpoint: {IConfiguration.ApiEndpoint}");
        }
    }
}

Code Explanation:

• The IConfiguration interface defines a static property ApiEndpoint with a default value of “https://api.default.com”.
• The AppConfig class implements IConfiguration but does not need to define the static property since it is inherited from the interface.
• The static property is accessed directly via the interface (IConfiguration.ApiEndpoint).

Restrictions and Limitations of Default Static Implementations in Interfaces in C#

• Cannot be Accessed Through the Implementing Class: Static members in interfaces must be accessed directly via the interface type (e.g., IExample.StaticMethod()), and cannot be accessed through the implementing class (e.g., ExampleClass.StaticMethod()).
• No Inheritance: Static members in interfaces do not participate in inheritance. They cannot be inherited or accessed through the implementing class. They must be explicitly accessed through the interface type.
• Versioning Issues: If an interface defines default static members and a new version of the interface adds new default members, your code may need to be recompiled to accommodate these changes. Otherwise, it might cause source-breaking or binary-breaking issues.
• Cannot Be Used in Non-Interface Contexts: Static methods in interfaces can’t be used in contexts where non-interface types are expected (e.g., in classes or structs without the interface).

Real-Time Use Cases for Default Static Implementations in Interfaces

• Logging Frameworks: In a logging framework, an interface might define default static methods to log messages in a general format, allowing different classes (e.g., FileLogger, DatabaseLogger) to override the methods if necessary, while still having a shared default implementation.
• Configuration Management: In an application where configuration values such as DefaultAPIUrl, DefaultLanguage, and MaxRetries are required across multiple classes, default static properties in an interface allow all implementing classes to use the same default values.
• Utility Methods: Utility libraries (such as for date formatting or number parsing) can use static methods with default implementations in interfaces. This eliminates the need for additional helper classes or static utility classes.

Real-Time Scenario: Utility Methods for Data Validation

Imagine a scenario where we need to validate data inputs like email addresses, phone numbers, or credit card numbers in various parts of an application. Instead of implementing these validation methods in every class, we can define static utility methods in an interface, providing default implementations for common validation logic.

The interface will provide default static utility methods for validating email format and phone number format. Implementing classes will be able to use these default implementations directly, ensuring consistency across the application.

using System.Text.RegularExpressions;

namespace CSharp13NewFeatures
{
    // Define the IValidation interface with static utility methods
    public interface IValidation
    {
        // Static method to validate email format with default implementation
        public static bool IsValidEmail(string email)
        {
            var emailPattern = @"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$";
            return Regex.IsMatch(email, emailPattern);
        }

        // Static method to validate phone number format with default implementation
        public static bool IsValidPhoneNumber(string phoneNumber)
        {
            var phonePattern = @"^\+?[1-9]\d{1,14}$"; // E.164 phone number format
            return Regex.IsMatch(phoneNumber, phonePattern);
        }
    }

    // A class using the IValidation interface
    public class UserService : IValidation
    {
        // This class doesn't need to implement static methods, they can be used directly from the interface
    }

    public class Program
    {
        static void Main()
        {
            // Test email validation
            string email = "user@example.com";
            bool isEmailValid = IValidation.IsValidEmail(email);
            Console.WriteLine($"Is '{email}' a valid email? {isEmailValid}");

            email = "user@example";
            isEmailValid = IValidation.IsValidEmail(email);
            Console.WriteLine($"Is '{email}' a valid email? {isEmailValid}");

            // Test phone number validation
            string phoneNumber = "+1234567890";
            bool isPhoneValid = IValidation.IsValidPhoneNumber(phoneNumber);
            Console.WriteLine($"Is '{phoneNumber}' a valid phone number? {isPhoneValid}");

            phoneNumber = "+12345zbcd";
            isPhoneValid = IValidation.IsValidPhoneNumber(phoneNumber);
            Console.WriteLine($"Is '{phoneNumber}' a valid phone number? {isPhoneValid}");
        }
    }
}

Code Explanation:

IValidation Interface:

The IValidation interface defines two static methods:

• IsValidEmail: Checks if the provided email address matches a basic regular expression for email format.
• IsValidPhoneNumber: Checks if the provided phone number matches a common phone number format (E.164).

UserService Class: The UserService class implements the IValidation interface. It doesn’t need to implement the static methods, as these default implementations are already provided in the interface. The static methods are used directly via the interface.

Accessing Static Methods: The static methods are called via the interface type (IValidation.IsValidEmail and IValidation.IsValidPhoneNumber), not through instances of the implementing class.

Validation: We validate an email and a phone number by calling the static methods from the interface. The results are displayed on the console.

Output:

Why This is Useful:

• Centralized Validation Logic: By defining common validation logic like email and phone number format validation in the interface, you ensure that the logic is consistent across different classes. Any class implementing the IValidation interface can easily access these utility methods without re-implementing them.
• Avoiding Code Duplication: Instead of having to write and maintain separate methods for validating email or phone numbers in multiple classes, you define them once in the interface. This reduces code duplication and the chance of errors
• Shared Functionality: The static methods are shared across all implementing classes, which is ideal when you need to apply common rules (like validation) consistently across your application.
• Flexible and Extendable: You can add new utility methods for other validation rules (e.g., validating credit card numbers, ZIP codes) in the IValidation interface, and these methods will automatically be available to all implementing classes.

Conclusion:

The default static implementation feature in C# 13 empowers developers to define static methods and static properties directly in interfaces, eliminating the need for redundant code in every implementing class. This feature significantly improves code maintainability, reuse, and flexibility, especially in scenarios that require shared utility functions, configuration settings, or logging behavior.

Key benefits of default static members in interfaces:

• Shared behavior across all implementing types.
• Default implementations reduce boilerplate code.
• Easier version management for shared utility functions.

This feature opens up new possibilities for designing cleaner and more modular architectures in C#, especially in large-scale applications where default behaviors need to be shared across multiple classes.

In this article, I explain Default Interface Implementations for Static Members in C# with Examples. I would like your feedback. Please post your feedback, questions, or comments about this article.