C# How to avoid duplicate code with interfaces where objects have the same behaviour

Question

So a simple example i have:

public interface IFollow{
    Transform Target {get;}
    void LateUpdate();
}

public A : Monobehaviour , IFollow {

   public Transform Target {get; set;}
   public void LateUpdate(){
      //follow the target
   }
}

public B : Monobehaviour , IFollow {

   public Transform Target {get; set;}
   public void LateUpdate(){
      //follow the target [duplicate code as seen in A]
}

When you have lots of different objects that follow a target with the same logic the implemented interface forces you to write a lot of duplicate code.

It also doesn't make much sense to do it via a base class since not all objects will follow.

What's a cleaner way to do this without so much duplication ?

Encase any one wondered, Monobehaviour is a Unity3D thing, though not overly relevant to the question but thought i'd mention it.

Answer 1

You have two options:

• Implement in a(n) (abstract) base class
• Implement in a helper adapter

Make a base class, or an abstract base class that implements the common behavior, and inherit from that. This way your code lives in one place and isn't duplicated.

If a base class doesn't work for some reason, you could put the code into a adapter (or strategy) object that each class uses to implement the behavior, again moving the duplicated code to one place.

Answer 2

You can first extract the common behavior(s) into simple classes which only implement IFollow:

public sealed class FollowTarget : IFollow
{
    public Transform Target {get; set;}
    public void LateUpdate() { //follow the target }
}

public sealed class FollowSomethingElse : IFollow
{
    public Transform Target {get; set;}
    public void LateUpdate() { //follow something else }
}

Then use the required implementation in A, B, C:

public sealed A : Monobehaviour , IFollow {
    private readonly IFollow _follow;
    public A() => _follow = new FollowTarget();
    public Transform Target {get => _follow.Target; set => _follow.Target = value; }
    public void LateUpdate() => _follow.LateUpdate();
}

public sealed B : Monobehaviour , IFollow {
    private readonly IFollow _follow;
    public B() => _follow = new FollowTarget();
    public Transform Target {get => _follow.Target; set => _follow.Target = value; }
    public void LateUpdate() => _follow.LateUpdate();
}

public sealed C : Monobehaviour , IFollow {
    private readonly IFollow _follow;
    public C() => _follow = new FollowSomethingElse();
    public Transform Target {get => _follow.Target; set => _follow.Target = value; }
    public void LateUpdate() => _follow.LateUpdate();
}

Then at this point you may see that A/C or B/C share the same implementation except that you don't instanciate the same _follow. In this case you can require an IFollow in the constructor and refactor (simplify) your code like this:

public sealed AorC : Monobehaviour , IFollow {
    private readonly IFollow _follow;
    public AorC(IFollow follow) => _follow = follow;
    public Transform Target {get => _follow.Target; set => _follow.Target = value; }
    public void LateUpdate() => _follow.LateUpdate();
}

public sealed B : Monobehaviour , IFollow {
    private readonly IFollow _follow;
    public B() => _follow = new FollowTarget();
    public Transform Target {get => _follow.Target; set => _follow.Target = value; }
    public void LateUpdate() => _follow.LateUpdate();
}

Usage beeing

var a = new AorC(new FollowTarget()); 
var c = new AorC(new FollowSomethingElse());

This approach is usually named Decorator and is a specialized form of composition which fosters a more composable code.

Answer 3

You could remove the method (but not the interface) from the class, and move the logic to an extension method:

public interface IFollow
{
    Transform Target {get;}
}

static public class ExtensionMethods
{
     static public void LateUpdate<T>(this T source) where T : IFollow
     {
         var target = source.Target; //Works, due to the type constraint
         //Add code to follow the target here
     }
}

public A : Monobehaviour , IFollow
{
    public Transform Target {get; set;}
}

public B : Monobehaviour , IFollow
{
    public Transform Target {get; set;}
}

You'd still call it exactly the same way as before, only you need to remember to include the namespace of your extension method (if it is different):

A a = new A();
a.LateUpdate();

You could also combine these methods; for example, you could leave LateUpdate() in the interface, but write the implementation as a pass-through that only calls the extension method behind the scenes. This would be valuable if you need the method in the interface for some reason.

Answer 4

C# 8 now supports default interfaces. So you could write it like this:

public interface IFollow
{
    Transform Target { get; }
    public void LateUpdate() {
        Console.WriteLine("Follow the target");
    }
}

public class A : Monobehaviour, IFollow
{
    public Transform Target { get; set; }       
}

public class B : Monobehaviour, IFollow
{

    public Transform Target { get; set; }   
}

Answer 5

You would move the code to another component that you call.

public class RepeatingCode : MonoBehaviour
{
    void RepeatThis() { }
}

public A : Monobehaviour, IFollow {

   public Transform Target {get; set;}
   private RepeatingCode Repeating;

   void Awake() => Repeating = GetComponent<RepeatingCode>();

   public void LateUpdate()
   {
      Repeating.RepeatThis();
   }
}

public B : Monobehaviour, IFollow {

   public Transform Target {get; set;}
   public RepeatingCode Repeating; // Assigned using Inspector

   public void LateUpdate()
   {
      Repeating.RepeatThis();
   }
}