Implementing interfaces in C# .NET

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
{
}

It probably could, but that would allow you to write poorly readable code. — Bgi
– Bgi, Commented Nov 6, 2012 at 9:05
@Bgi, can you explain how it would lead to poorly readable code? Personally I think the code would be neater because you could just look at the interfaces that the class implements rather than at the class itself. Also the implementation and contract are syntactically identical so you would only need to maintain properties in the interface rather than in the class as well. — Matthew Layton
– Matthew Layton, Commented Nov 6, 2012 at 9:25
@trampi, no, C# only allows single inheritance, so abstract classes do not work either! — Matthew Layton
– Matthew Layton, Commented Nov 6, 2012 at 9:26

Justin Harvey · Accepted Answer · 2012-11-06 09:07:50Z

3

An interface is not there to provide an implementation, it is there to define a contract. This then allows for different implementations to be built which implement it.

answered Nov 6, 2012 at 9:07

Justin Harvey

14.7k2 gold badges30 silver badges30 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Will Vousden · Accepted Answer · 2012-11-06 09:08:04Z

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;
        }
    }
}

Rich O'Kelly · Accepted Answer · 2012-11-06 09:06:40Z

You are implicitly implementing the interface. In this instance the method signatures of the class must match those of the interface (including accessibility). Ensuring that the methods are marked as public ensures that there are no surprises when looking at the class, for instance:

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

Even though both properties are declared the same, the CustomData property would be public by virtue of it being declared on the interface even though the declaration looks identical to that of PrivateCustomData. This would be inconsistent and lead to harder to maintain code.

If you do not wish to set the access modifier, you could explicitly implement the interface:

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

Trevor Pilley · Accepted Answer · 2012-11-06 09:08:06Z

0

The interface declaration is only specifying the behaviour which the interface defines. In your case, this is a property called CustomData which has a get and set (it is a read/write property) which is of type string.

The class which implements the interface needs to do exactly that - to specify the implementation.

Now in your case, you are using auto implemented properties { get; set; } which looks the same as the interface declaration, however you could also have a backing field and behaviour in your get or set methods.

answered Nov 6, 2012 at 9:08

Trevor Pilley

16.5k6 gold badges47 silver badges61 bronze badges

Comments

Cristian Lupascu · Accepted Answer · 2012-11-06 09:10:47Z

0

Here's an example where the CustomData property is private in a derived class:

public class CustomDataHandler : ICustomData
{
    private string CustomData { set; get; }

    string ICustomData.CustomData { get; set; }
}

But this code compiles, because there is also an explicit implementation of the property.

So, the public modifier is not redundant in this case.

answered Nov 6, 2012 at 9:10

Cristian Lupascu

40.8k18 gold badges107 silver badges139 bronze badges

Comments

LightStriker · Accepted Answer · 2012-11-06 09:14:15Z

You must explicitly implement it because... You are not limited to implementing it that way. You could use a field, or do something else in your method. An interface is only a method contract that guaranty that this method exist.

public class CustomDataHandler : ICustomData
{
    public String CustomData
    {
        get { return "None of your business!"; }
        set { } // Decide to do nothing
    }
}

The interface only guaranty this method will exist. Not what you're gonna do with it.

EDIT: As for your edit of your question, you probably seek to have a parent class instead of an interface if you want to implement the method only once for a collection of classes. However, while you can combine interface, you cannot combine parent classes. But, you can add interface at different point of a classes hierarchy.

Collectives™ on Stack Overflow

Implementing interfaces in C# .NET

6 Answers 6

Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related