How to make a class and a record share the same method in C#?

Question

I have a legacy class ExampleClass and its successor, a record ExampleRecord. Both implement the interface IExample that requires a method ExampleMethod.

Is it possible to have both the class and the record use the same method codevise? If yes, how?

Answer 1

Option #1: Extension methods: Add the common method as an extension method to the interface. This way, it belongs neither to the class, nor to record, and instead it is free-floating; any code that has access to the interface should also be given access to the extension method.

Option #2: Default interface methods: Upgrade to C# language version 8.0 or above and then make the common method a Default Interface Method. (See https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-8.0/default-interface-methods) This makes things even simpler: any code that has access to either the class or the record automatically has access to the default interface method.

Of course these approaches will only work if the method relies exclusively on functionality offered by that interface and nothing else.

Answer 2

Depends on what this method is doing. Why you don't use a third class which has this method? Then you can have an instance of it in the class and the record and call it.

public interface IExample
{
    void Foo();
}

public class ExampleClass: IExample
{
    private ExampleService service;
    public void Foo() => service.Foo();
}

public record ExampleRecord : IExample
{
    private ExampleService service;
    public void Foo() => service.Foo();
}

public class ExampleService
{
    public void Foo()
    {
       // ...
    }
}

Another way is a default interface implementation which is available since C#8:

public interface IExample
{
    void Foo()
    {
        // ...
    }
}

public class ExampleClass: IExample
{
}

public record ExampleRecord : IExample
{
}

---

ExampleClass ec = new();
ExampleRecord er = new();
((IExample)ec).Foo();
((IExample)er).Foo();

As you can see you need an explicit cast to the interface, otherwise it will not compile. Why