Generically typed interface

Question

I came across the following code in our code base:

public interface ICloneable<T>
{
    T Clone();
}

public class MyObject : ICloneable<MyObject>
{
    public Stuff SomeStuff { get; set; }

    T Clone()
    {
        return new MyObject { SomeStuff = this.SomeStuff };
    }
}

The pattern of using a generic interface and then doing class A : Interface<A> looks pretty bizarre to me. I have a feeling it's either useless or that it could be changed into something less intricated. Can someone explain if this is right/wrong, and how it should be changed?

Answer 1

You see this same pattern in the framework for IEquatable<T>. The most frequent use case for this is writing a generic method where you constrain the generic parameter type to implement the interface. This then allows you to write code in terms of a statically typed method Equals<T>. Another example is IComparable<T>, which is very handy for implementing methods relying on sorting without having to use the older style of providing an external Comparator class. For instance, the default comparison mechanism for the LINQ OrderBy method uses IComparable<T>, if it's available. In both of these cases, it's very natural to say that an instance of a type is comparable or equatable to other instances of the same type.

Answer 2

This pattern is called a Prototype object creation pattern. Usually it is used to do a deep cloning of objects (that is if Stuff is a reference type then it should also be cloned).