在非泛型接口中使用泛型集合

Question

I've spent quite a while today looking for a way to solve this but with no luck. I have a generic class as follows:

public class StagedEntity<T>: IStagedEntity where T : IStagedItem {

  public Type EntityType {
    get { return typeof( T ); }
  }

  public IList<T> StagedItems { get; set; }
}

in order that I can create a collection of StagedEntities of various arbitrary types, ie:

var stagedEntities = new List<IStagedEntity> {
  new StagedEntity<StagedBrand> {
    StagedItems = new List<StagedBrand> {
      new StagedBrand {
        Code = "Brand1"
      },
      new StagedBrand {
        Code = "Brand2"
      }
    }
  },
  new StagedEntity<StagedModel> {
    StagedItems = new List<StagedModel> {
      new StagedModel {
        Name = "Model1"
      },
      new StagedBrand {
        Name = "Model2"
      }
    }
  }
}

I then wish to iterate over each entity in stagedEntities , and with each one I need to be able to access all of the property values of each item in its StagedItems collection, something like:

private void DoStuff( IStagedEntity stagedEntity ) {

  var properties = stagedEntity.EntityType.GetProperties().ToList();

  foreach ( var item in stagedEntity.StagedItems ) {   <=== This line doesn't compile

    foreach ( var property in properties ) {
      // Do something with
      // property.GetValue( item, null );
    }
  }
}

However the above code doesn't compile because the interface definition IStagedEntity doesn't have IList<T> StagedItems defined, I can't put this in the interface definition because the interface is non-generic and so doesn't know what T is.

I've tried various things such as making the interface generic ( IStagedEntity<T> ) and defining StagedEntities as new List<IStagedEntity<IStagedItem>> , and I can get this to compile by casting each instance of StagedEntity<T> to IStagedEntity<IStagedItem> , however this fails at runtime with:

Unable to cast object of type
'DataExport.StagedEntity`1[DataExport.StagedBrand]' to type
'DataExport.IStagedEntity`1[DataExport.IStagedItem]'.

Is there an obvious way around this that I'm missing? Any help would be much appreciated.

---

EDIT: For completeness, the IStagedEntity interface at present looks like this:

public interface IStagedEntity {
  Type EntityType { get; }
}

Answer 1

If you can change the method signature of DoStuff() , I'd suggest to keep your interfaces and classes as they are and just change the argument like this:

private void DoStuff<T>(StagedEntity<T> stagedEntity) // note the arg type
{

  var properties = stagedEntity.EntityType.GetProperties().ToList();

  foreach ( var item in stagedEntity.StagedItems ) {
    foreach ( var property in properties ) {
      // Do something with
      // property.GetValue( item, null );
    }
  }
}

So you can call that method like:

private void foo()
{
    StagedEntity<MyGenericType> entities = null; // ...
    DoStuff(entities);
}

Answer 2

Using dynamic will get you the result that you are asking for. I would on the other side consider the other suggested approaches since you do not know if all IStagedEntity will meet the StagedItems property

private static void DoStuff(IStagedEntity stagedEntity)
{
        dynamic se = stagedEntity;
        var properties = stagedEntity.EntityType.GetProperties().ToList();

        foreach (var item in se.StagedItems)
        {   
            foreach (var property in properties)
            {
             // Do something with
             // property.GetValue( item, null );
            }
        }
}

Answer 3

I've managed to get this to work by making the IStagedEntity interface generic so I can include IList<T> StagedItems in it - which I tried previously, but crucially I've now also made the interface type parameter covariant ( <out T> ) which has solved the conversion issue I was getting before:

public interface IStagedEntity<out T> where T : IStagedItem {
  Type EntityType { get; }

  IList<T> StagedItems { get; }
}

Obviously I've also had to amend all references to IStagedEntity to IStagedEntity<IStagedItem> , and having done so the assignment (simplified below) now works without issue:

var stagedEntities = new List<IStagedEntity<IStagedItem>> {
  new StagedEntity<StagedBrand>(),
  new StagedEntity<StagedModel>()
}

And with IList<T> StagedItems now in the interface I can happily access this property in my consuming method.

Thanks for your help everyone :o)

---

EDIT: It's possibly worth pointing out that adding the covariant out as described above will cause the compiler to complain of 'invalid variance' if there is a generic property with a setter on the interface. Simply removing the setter will fix this (and of course you can still have setters on the concrete implementation).