Default Interface Methods in C#
Interfaces were limited to declaring their members (methods, properties, events, and indexers) before C# 8.0, but as of that version, interfaces can include both members and their implementation. Default interface methods, also referred to as virtual extension methods, are the types of methods that can be added to an interface without negatively impacting its current implementation. The traits programming technique is made possible for programmers by this feature, which is an object-oriented programming technique that permits the reuse of methods across unrelated classes.
Important features:
There are several important features of the Default Interface Methods in C#. Some of them are as follows:
- Implementing an indexer, property, or event accessor in the interface is permitted.
- Access modifiers such as override, sealed, external, virtual, abstract, protected, private, and static are permitted to be used in the interface along with default methods and properties. Exercise caution when utilizing modifier keywords.
- In the interface, we can create static fields, methods, properties, indexers, and events.
- Modifiers are overridable.
- The public has default access to the explicit access modifiers.
- If the interface has default methods and is inherited by a designated class, the class in question is unaware of their existence and lacks the implementation of said methods.
- Parameters are permitted when using the default method. There is no need to use a modifier if we override the default procedure.
- Although they must have distinct parameter lists, methods with the same names can be used in the interface.
- We can expand the standard method.
Example:
Let us take an example to illustrate the Default Interface Methods in C#.
using System;
// Define an interface with a default method
public interface IMyInterface
{
// Regular method signature
void RegularMethod();
// Default method with an implementation
// This method can be overridden by implementing classes
// or inherited as-is
public void DefaultMethod()
{
Console.WriteLine("Default implementation of DefaultMethod in IMyInterface");
}
}
// A class implementing the interface
public class MyClass : IMyInterface
{
public void RegularMethod()
{
Console.WriteLine("Regular method implementation in MyClass");
}
// Overriding the default method if needed
public void DefaultMethod()
{
Console.WriteLine("Custom implementation of DefaultMethod in MyClass");
}
}
class Program
{
static void Main(string[] args)
{
// Create an instance of MyClass
MyClass myObj = new MyClass();
// Call methods
myObj.RegularMethod(); // Output: Regular method implementation in MyClass
myObj.DefaultMethod(); // Output: Custom implementation of DefaultMethod in MyClass
// Interface reference
IMyInterface myInterfaceObj = myObj;
// Call default method through interface reference
myInterfaceObj.DefaultMethod(); // Output: Custom implementation of DefaultMethod in MyClass
}
}
Output:
Regular method implementation in MyClass
Custom implementation of DefaultMethod in MyClass
Custom implementation of DefaultMethod in MyClass
Explanation:
In this example, a regular method called RegularMethod() and a default method called DefaultMethod() are both declared by IMyInterface. Implementing IMyInterface, the MyClass class overrides DefaultMethod() with its own implementation and offers its own implementation for RegularMethod(). The flexibility of default interface methods is finally demonstrated in the Main method, where we call both regular and default methods using an instance of MyClass and an interface reference.
Example 2:
Let us take another example to illustrate the Default Interface Methods in C#.
using System;
// A simple interface
interface ICustomInterface {
void Show();
// Default method with both
// declaration and definition
// Here, the name of both methods are same
// but the parameter list is different
public void Show(int x, int y)
{
int product;
product = x * y;
Console.WriteLine("Product: " + product);
}
}
// A class which
// implements ICustomInterface interface
class ExampleClass : ICustomInterface {
// Providing the body
// part of the method
public void Show()
{
Console.WriteLine("Greetings! Method of ICustomInterface");
}
// Main Method
public static void Main(String[] args)
{
// Creating an object
ExampleClass example = new ExampleClass();
// Calling method
example.Show();
// Creating an object
ICustomInterface obj = example;
// Calling and passing parameters in the default method
obj.Show(3, 5);
}
}
Output:
Greetings! Method of ICustomInterface
Product: 15
Conclusion:
In conclusion, the default interface methods added to C# in version 8.0 constitute a major improvement over the language's interface capabilities. This feature enables the provision of default behaviour for methods within interfaces by allowing method implementations to be included alongside method declarations. Default interface methods encourage code reuse and maintainability by providing a mechanism to change interfaces over time without interfering with already implemented implementations. In order to maintain backward compatibility and provide flexibility, implementing classes can choose to override default method implementations with custom behavior or inherit them. C# facilitates the design of more expressive and cohesive APIs by allowing interfaces to contain both abstract and default methods. This feature helps developers create software systems that are both reliable and scalable.