Why use Clone()?

The idea is that using Clone you can create a new object of the same type as the one you invoke it on, without knowing the exact type of the object you are invoking it on.

For example:

void Test(ICloneable original)
{
    var cloned = original.Clone();
}

Here cloned is of the same runtime type as original, and you did not need to know what that type was to perform the cloning.

However the usefulness of ICloneable is pretty much none, because it does not define the semantics of the clone operation: is it a shallow copy or a deep copy? Since the interface does not mandate one or the other, you can't really know what you are getting back. And since knowing that is essential because you need to handle the clone accordingly, ICloneable itself is pretty much a burned card.

Defining your own interface with a Clone method (with well-defined semantics) makes much sense though.

Update: See also: Why should I implement ICloneable in c#?

Clone() usually provides a shallow copy of an object (e.g., see Array.Clone() ), it copies the references but not the referenced objects.

It's handy if you understand its limitations, mainly that the semantics of what actually gets copied over into the new object are mostly left to the implementer of the Clone() method, because the interface ICloneable that defines the Clone() method is under-specified (so it could be a shallow copy or a deep copy, but you can't rely on either).