Cast concrete to Interface

Question

I am getting an object of type Company<IDesignation>. Now I want to cast it to ICompany<Manager>. Run time I know that IDesignation is nothing but "Manager" type.

Answer 1

Is this what you are looking for?

Company comp = new Company();
Manager mgner = new Manager(comp.getManager());
IDesignation manager = mgner; 
ICompany company = (ICompany)manager;

Assuming Company is:

public class Company: ICompany, IDesignation //or something?

Using either Generic Type Casting (what u are trying to do) or simply Casting an Interface or object depends on whether you will perform this task explicitly or implicitly (maybe class has pre-defined function to cast it) and as your comment has pointed out... maybe by user or runtime matters or whether or not and/or how you need to instantiate your object so I would really need to see the class implementation in order to be able to provide something that uses type casting in the way you want to perform it.

Answer 2

What you need is Contravariance, i.e. your IEntityDelta generic type parameter needs to be made contravariant. The only way to do that and for this to work is to have:

public interface IEntityDelta<in T> : IEntityDelta where T : IEntity

Note the in T in the definition. Check out the in (Generic Modifier) (C# Reference)
Or this Understanding Covariant and Contravariant interfaces in C#

If you're not the creator of that interface and if the IEntityDelta<> is defined w/o the in modifier you're out of luck.

And just to mention that adding in/out modifiers is easier said than done. For that to compile your methods, properties etc. need to satisfy the conditions of contravariance (or covariance in case of 'out') on that generic type (T) parameter.

And this what your classes, interfaces look like based on your info (which was terrible btw. next time you need to dedicate a bit more time in providing minimal but complete code that makes sense):

public interface IEntityDelta<in T> : IEntityDelta 
    where T : IEntity
{
    void MakeDelta(T entity); // this is allowed
    //T Entity { get; set; } // this won't work
}
public class EntityDelta<T> : IEntityDelta<T> 
    where T : class, IEntity
{
    public T Entity { get; set; }
    public EntityDelta(T entity) => Entity = entity;
    public void MakeDelta(T entity) { }
}
public interface IEntityDelta { }
public abstract class Entity : IEntity { }
public class Order : Entity { }
public interface IEntity { }

...and usage:

var order = new Order();
EntityDelta<IEntity> orderDelta = new EntityDelta<IEntity>(order);
IEntityDelta<IEntity> idelta = orderDelta;
IEntityDelta<Order> iOrderDelta = orderDelta;