使用反射强制转换泛型

Question

I have 3 classes with the following structure. And I have a generic method that refreshes the collection to check if the collection is updated in any way or not. This method works fine except if it has Observablecollection inside the model you are trying to update.

So in TestClassA , I am calling my generic Collectionrefresh method for TestClassB . But TestClassB have a ObservableCollection which is not updating.

public class TestClassA
{
   public ObservableCollection<TestClassB> CollectionA {get; set;}

   CollectionA.CollectionRefresh(CollectionB)    //Here CollectionB is the updated list
}

public class TestClassB
{
   public ObservableCollection<TestClassC> TestClassB {get; set;}
   public string Name {get; set;}
}

public class TestClassC
{
   public string FirstName {get; set;}
   public string LastName {get; set;}
}

Now to overcome this problem I have modified my method this way.

public static void CollectionRefresh<T>(this ObservableCollection<T> collection, List<T> items)
{
   //Method Content

   PropertyInfo[] properties = typeof(T).GetProperties();


   foreach(PropertyInfo property in properties)
   {
      if (property.PropertyType.IsGenericType && typeof(ObservableCollection<>).IsAssignableFrom(property.PropertyType.GetGenericTypeDefinition()))
      {
         //I am getting the oldCollection and newList from somewherelse in the method.
         var collection1 = (dynamic)property.GetValue(oldCollection);
         var collection2 = (dynamic) property.GetValue(newList);

         collection1.CollectionRefresh(collection2);
      }
   }

   //Method Content
}

This is not working because dynamic will be an object and I want the cast it to be ObservableCollection<TestClassC> . If I cast ObservableCollection<T> it gives me incorrect cast error because T will be TestClassB at that time and I want it to be TestClassC . Upon casting ObservableCollection<TestClassC> to both collection1 and collection2, my problem is solved but since I am doing generics I am trying to find a way to do it generic.

Answer 1

In my understanding, your ultimate goal would be void collection1.CollectionRefresh(collection2)

where collection1.GetType()==collection2.GetType()==typeof(ObservableCollection<TestClassC>)

I suppose you want to call

TestClassA testA = new TestClassA();
List<TestClassB> list = new List<TestClassB>();
testA.CollectionA.CollectionRefresh(list);

Then T is going to be TestClassB and ObservableCollection<TestClassC> CollectionB is your targeted property.

property.GetValue(TestClassB someB) is going to return an object, which is not eligible to call void CollectionRefresh(collection2) so you are now stuck, am I correct?

This is a nested generic problem. If you also given TestClassC as T2 then it would be so easy.

Usually we would have a non-generic base class so that we could explicitly cast to that. Unfortunately, ObservableCollection<T> is not inherited from a functional ObservableCollection class.

Here is my suggestion. You have to use both an expression tree and reflection to get the CollectionRefresh method and then call it, but that might be an overkill.

Anyway, try this.

public static void CollectionRefresh<T>(this ObservableCollection<T> collection, List<T> items)
{
   //Method Content

   PropertyInfo[] properties = typeof(T).GetProperties();


   foreach(PropertyInfo property in properties)
   {
      if (property.PropertyType.IsGenericType && typeof(ObservableCollection<>).IsAssignableFrom(property.PropertyType.GetGenericTypeDefinition()))
      {
        MethodInfo refreshMethod = property.PropertyType.GetMethod("CollectionRefresh");

        var instanceT1 = Expression.Parameter(typeof(T), "otherT1");
        var instanceT2 = Expression.Parameter(typeof(T), "otherT2");
        var prop1 = Expression.Call(instanceT1, property.GetMethod);
        var prop2 = Expression.Call(instanceT2, property.GetMethod);
        var collection1 = Expression.Convert(prop1, property.PropertyType);
        var collection2 = Expression.Convert(prop2, property.PropertyType);
        var refresh = Expression.Call(collection1, refreshMethod, collection2);
        var lambda = Expression.Lambda<Action<T, T>>(refresh, instanceT1, instanceT2);

        Action<T, T> func = lambda.Compile();
        func(oldCollection, newList);
      }
   }

   //Method Content
}