System.Array is effectively derived from System.Object. You don’t see it here, because everything in .NET Framework derives by default from System.Object, including types like int (System.Int32).

In other words:

• class MyClass : MyOtherClass { } indicates that MyClass is derived from MyOtherClass.

• class MyClass { } indicates that MyClass is derived from System.Object.

The advantage of using an interface is that methods (or classes with generics) may rely on interfaces when they need a specific method or property. Imagine the following source code:

public interface INamed
{
    string Name { get; }
}

public void SayHello(INamed namedEntity)
{
    Console.WriteLine("Hello, " + namedEntity.Name + "!");
}

By using an interface, the method shows that it doesn’t care about the exact type of namedEntity. All what it cares about is that the object should contain a property of type string called Name which has a getter.

The actual type may be a Person. Or a Cat : Animal. Or an AircraftModel. SayHello accepts them all, at the condition for them to implement INamed.

Why would Person implement an interface, instead of simply containing the Name property?

Because, aside using Reflection or dynamic programming, the caller doesn’t have a clue that Person effectively implements Name property. For example this code will not compile:

public class Person
{
    public string Name { get; set; }
}

public void SayHello(object namedEntity)
{
    Console.WriteLine("Hello, " + namedEntity.Name + "!"); // Compile-time error here
}

public void Main()
{
    this.SayHello(new Person { Name = "Robert" });
}