Question

Consider the following interface

public interface ICustomData
{
    String CustomData { set; get; }
}

According to MSDN documentation, interfaces members are automatically public.

Lets say I now want to implement my interface:

public class CustomDataHandler : ICustomData
{
}

This would break at compile time, telling me that I have not implemented “CustomData”

This on the otherhand would work:

public class CustomDataHandler : ICustomData
{
    public String CustomData { set; get; }
}

My question is: If the member of the interface is automatically public, why MUST I declare the implementation in the class? If the interface declaration is syntactically identical to the class declaration, why can the compiler not infer this automatically from my interface?

EDIT:

My reason for asking. Imagine a scenario where you are building data models, entities etc. I might code some interfaces to these models like so:

public interface IUserAccount
{
    Guid Identity { set; get; }
    String FirstName { set; get; }
    String LastName { set; get; }
    String EmailAddress { set; get; }
    String Password { set; get; }
}

public interface IUserDataEntry
{
    Guid DataIdentity { set; get; }
    String DataName { set; get; }
    String Data { set; get; }
}

It would be far simpler to construct the models like so:

public class UserAccount : IUserAccount
{
}

public class UserDataEntry : IUserDataEntry
{
}

public class Combined : IUserAccount, IUserDataEntry
{
}

Answer 1

They may be syntactically identical, but they mean different things (i.e. they are not semantically identical).

In the interface, the syntax means that an implementing class must expose such a property, with get and set accessors implemented as it sees fit (either explicitly or implicitly). An interface merely defines the outward behaviour that a class must provide; it does not provide any implementation of that behaviour.

In the class, the syntax is an “auto-property”, an implementation of the property defined by the interface, and the get and set accessors are implicitly converted into full implementations with a backing field. It looks something like this when it’s compiled:

public class CustomDataHandler : ICustomData
{
    private string customData;

    public string CustomData
    {
        get
        {
            return customData;
        }
        set
        {
            customData = value;
        }
    }
}