CODEWITHSUNDEEP
c#.netinterfacecasting
Rolfant90
Rolfant90

Reputation: 13

Cast object from an interface to its implementation

I have the following code:

public interface BaseInterface
{
    int ID { get; }
}

public interface SpecialInterface1 : BaseInterface
{
    int price { get; }
}

public interface SpecialInterface1 : BaseInterface
{
    int xyz { get; }
}

public class Implementation1 : SpecialInterface
{
    int price { get; }
    int ID { get; internal set; }
}

public class Implementation2 : SpecialInterface
{
    int xyz { get; }
    int ID { get; internal set; }
}

Now in a Management class I want to add the objects that implement BaseInterface into a List.

I know that I can use as or is to cast the interface to an implementation, but in my project, I have about 10 special interfaces with an implementation each so I would have to write a really big if statements.

public void Add(BaseInterface u, int id)
{
    if (u is Implementation1)
    {
        ((Implementation1)u).ID = id;
        Units.Add(u);
    }

    if (u is Implementation2)
    {
        ((Implementation2)u).ID = id;
        Units.Add(u);
    }
}

My goal is that the id is not changeable outside the implementation and I would provide only the interfaces outside my dll so none can change the id.

Upvotes: 0

Views: 3718

Answers (4)

MplsAmigo
MplsAmigo

Reputation: 1025

While I like this answer the best,

I recommend making the ID a required parameter of all the implementation's constructors, and then to use a factory pattern to generate any instance you require. This makes any instance without the ID set throw an exception at compile time rather than runtime reducing the probability of exceptions.

Here is a simple example that gets you what you want without an additional interface. Should you choose you can combine my answer with @Iqon's answer.

public interface IInterface
{
    int ID { get; }
}

internal class InternalImplementation: IInterface {
    public InternalImplementation(int ID) { this.ID = ID; }
    public int ID { get; set; }
}

public class MyImplementationFactoryService {

    public IInterface Create() {
        int id = 1 // Or however you get your ID, possibly from a DB query?
        return new InternalImplementation(id);
    }

    public IInterface Create(type|enum createtype) {
        // return type based on typeof or enum
    }

}

Upvotes: 1

Iqon
Iqon

Reputation: 1992

A solution would be to add an extra interface. This eliminates the internal setter in your implementation.

internal interface IChangeID
{
    void SetID(int id);
}

public interface IBaseInterface
{
    int ID { get; }
}

public class Implementation : IBaseInterface,
                              IChangeID
{        
    public void SetID(int id) { ID = id; }
    public int ID { get; private set; }
}

Only the real implementations should implement IChangeID. Returning IBaseInterface or ISpecialInterface will hide the setter, because those interfaces do not inherit from IChangeID.

This would change your add into:

public void Add(BaseInterface u, int id)
{
     ((IChangeID)u).SetID(id);
     Units.Add(u);
}

If you do want to return the concrete types, not interfaces. You could implement the given interface explicit. This will hide the set method even from the concrete implementation.

public class Implementation : IBaseInterface,
                              IChangeID
{        
    void IChangeID.SetID(int id) { ID = id; }
    public int ID { get; private set; }
}

var obj = new Implementation();
obj.SetID() // This WILL NOT Compile

Upvotes: 4

Kaushal
Kaushal

Reputation: 1349

In case you want to use reflection to set property, code below may help

public interface IBaseInterface
{
   int ID { get; }
}

public class Impl1 : IBaseInterface 
{
    public int ID { get; internal set; }

    public int Price {get; set;}
}

public class Impl2 : IBaseInterface 
{
    public int ID { get { return 0;} }

    public int Subscription {get; set;}
}

public class Program
{
    public static void Main(string[] args)
    {
        IBaseInterface obj1 = new Impl1();

        SetProperty(obj1, "ID", 100);
        Console.WriteLine("Object1 Id is {0}", obj1.ID); 

        IBaseInterface obj2 = new Impl2();

        SetProperty(obj2, "ID", 500);
        Console.WriteLine("Object2 Id is {0}", obj2.ID); 
    }

    private static void SetProperty(IBaseInterface obj, string propertyName, object id){
        if(obj.GetType().GetProperty(propertyName).CanWrite) {
            obj.GetType().GetProperty(propertyName).SetValue(obj, id); 
            Console.WriteLine("CanWrite property '{0}' : {1}" , propertyName, obj.GetType().GetProperty(propertyName).CanWrite); 
        }
    }
}

Output

CanWrite property 'ID' : True

Object1 Id is 100

Object2 Id is 0

Upvotes: 0

Panagiotis Kanavos
Panagiotis Kanavos

Reputation: 131219

If you don't want to modify the interfaces and implementations, you could use C# 7's pattern matching to access the implementation type without casting. It requires 3 lines per implementation type but avoids modifying the classes:

public void Add(BaseInterface u, int id)
{
    switch(u)
    {
        case Implementation1 u1:
            u1.ID = id;
            break;
        case Implementation2 u1:
            u1.ID = id;
            break;    
        default :
            throw new ArgumentException("Unexpected implementation!");
    }
    Units.Add(u);     
}

The obvious disadvantage is that the code will have to be modified if a new implementation is added.

Another option is to use dynamic, losing type safety. This will fail at runtime if some implementation doesn't have a setter (eg because it was replaced by constructor initialization)

public void Add(BaseInterface u, int id)
{
    dynamic x =u;
    x.ID=id;
    Units.Add(x);     
}

Upvotes: 1

Related Questions