Question

我们通过Andrew Davey's使用sourceforge BindingListView<T>类将集合绑定到DataGridView并允许排序和过滤。

这适用于普通集合。但是在一种情况下，我们绑定的集合是一个接口类型，如果我们尝试对它进行排序，我们会收到此错误：

Invalid type owner for DynamicMethod

安德鲁戴维斯的代码中存在错误，因此我们很难知道从哪里开始。

        private static Comparison<T> BuildValueTypeComparison(PropertyInfo pi, ListSortDirection direction)
        {
            MethodInfo getMethod = pi.GetGetMethod();
            Debug.Assert(getMethod != null);


            DynamicMethod dm = new DynamicMethod("Get" + pi.Name, typeof(int), new Type[] { typeof(T), typeof(T) }, typeof(T), true);
            //^^^ ======== Here's the line reporting the error=========== ^^^

            ILGenerator il = dm.GetILGenerator();

            // Get the value of the first object's property.
            il.Emit(OpCodes.Ldarg_0);
            il.EmitCall(OpCodes.Call, getMethod, null);
            // Box the value type
            il.Emit(OpCodes.Box, pi.PropertyType);

            // Get the value of the second object's property.
            il.Emit(OpCodes.Ldarg_1);
            il.EmitCall(OpCodes.Call, getMethod, null);
            // Box the value type
            il.Emit(OpCodes.Box, pi.PropertyType);

            // Cast the first value to IComparable and call CompareTo,
            // passing the second value as the argument.
            il.Emit(OpCodes.Castclass, typeof(IComparable));
            il.EmitCall(OpCodes.Call, typeof(IComparable).GetMethod("CompareTo"), null);

            // If descending then multiply comparison result by -1
            // to reverse the ordering.
            if (direction == ListSortDirection.Descending)
            {
                il.Emit(OpCodes.Ldc_I4_M1);
                il.Emit(OpCodes.Mul);
            }

            // Return the result of the comparison.
            il.Emit(OpCodes.Ret);

            // Create the delegate pointing at the dynamic method.
            return (Comparison<T>)dm.CreateDelegate(typeof(Comparison<T>));
        }

Answer 1

更新：我终于以正确的方式工作了，请看下面的内容。

DynamicMethod在运行时动态构建方法;在库中，您正在使用创建的方法添加到对象T;但是，当T是一个接口时，这会失败，因为您无法向接口添加方法。

主要问题在于方法：

private static GetPropertyDelegate BuildGetPropertyMethod(PropertyInfo pi)

作为编写它的方式，只有在集合类型T具体时才会起作用。

如果您将实施更改为：

private static GetPropertyDelegate BuildGetPropertyMethod(PropertyInfo pi)
{
    MethodInfo getMethod = pi.GetGetMethod();
    Debug.Assert(getMethod != null);

    DynamicMethod dm = new DynamicMethod(
        "GetProperty_" + typeof(T).Name + "_" + pi.Name, typeof(object), 
        new Type[] { typeof(T) },
        pi.Module, 
        true);

    ILGenerator il = dm.GetILGenerator();

    il.Emit(OpCodes.Ldarg_0);
    il.EmitCall(OpCodes.Callvirt, getMethod, null);
    if (pi.PropertyType.IsValueType)
    {
        il.Emit(OpCodes.Box, pi.PropertyType);
    }

    // Return the result of the comparison.
    il.Emit(OpCodes.Ret);

    return (GetPropertyDelegate)dm.CreateDelegate(typeof(GetPropertyDelegate));
}

it will work for both concrete types and interfaces

您还需要更新以下两种方法：

private static Comparison<T> BuildValueTypeComparison(PropertyInfo pi, ListSortDirection direction)

private static Comparison<T> BuildNullableComparison(PropertyInfo pi, ListSortDirection direction)

我可能错了，但我认为在这些方法中实现的速度增益来自快速属性读取，因此使用DynamicMethod方法编写整个方法并没有太大的好处;我们可以重复使用上面的BuildGetPropertyMethod。这样做，这些变成了：

private static Comparison<T> BuildValueTypeComparison(
    PropertyInfo pi, 
    ListSortDirection direction)
{
    GetPropertyDelegate m = BuildGetPropertyMethod(pi);
    Comparison<T> d = delegate(T x, T y)
    {
        object mx = m(x);
        object my = m(y);

        IComparable c = (IComparable)mx;

        if (direction == ListSortDirection.Descending)
        {
            return -c.CompareTo(my);
        }

        return c.CompareTo(my);
    };

    return d;
}

private static Comparison<T> BuildNullableComparison(
    PropertyInfo pi, 
    ListSortDirection direction)
{
    GetPropertyDelegate m = BuildGetPropertyMethod(pi);
    Comparison<T> d = delegate(T x, T y)
        {
            object mx = m(x);
            object my = m(y);

            IComparable c = (IComparable)mx;

            if (c == null)
            {
                c = (IComparable)my;

                if (c == null)
                {
                    return 0;
                }

                return direction == ListSortDirection.Descending 
                    ? c.CompareTo(mx) : -c.CompareTo(mx);
            }

            return direction == ListSortDirection.Descending 
                ? -c.CompareTo(my) : c.CompareTo(my);
        };

    return d;
}

显然对它做了一些测试，但我很确定这就是你想要的，它应该与前面的代码一样快。

Answer 2

不要放弃并继续使用DataSet！你正朝着正确的方向前进！现在，我们先来看一下函数签名：

DynamicMethod(string name, 
              Type returnType, 
              Type[] parameterTypes, 
              Type owner, 
              bool skipVisibility)

Error is “Invalid type owner for DynamicMethod"

错误消息试图告诉您，Type owner不是函数所期望的。它想要一个Class类型。您可能正在将接口类型传递到类型所有者。在接口上创建动态方法是不可能的。

1.错误示例

也许您正在使用依赖注入，并且您可能希望使用Interface。

但是，此代码将遇到运行时错误。

var viewModelList = GetViewModels(); //returns an IList<IViewModel> <-- has i !!
var blv = new BindingListView<IViewModel>(viewModelList);

2.工作示例

尝试重新设计代码以使用Concrete Type。

现在，此代码不会遇到运行时错误

var viewModelList = GetViewModels(); //returns an IList<ViewModel> <-- has no i !!
var blv = new BindingListView<ViewModel>(viewModelList);

然后，DataGridView上的排序和过滤将自动运行：）

EDIT --------------------------------------------- < / p>

P.S。关于尝试重新设计代码：

如果您使用的是MVVM / MVP模式，请考虑以下逻辑。 IList<IViewModel>应保留在“VM + P”端。使用IViewModel的目的主要是因为我希望能够用MockingViewModel : IViewModel替换它来对单元测试逻辑的“VM + P”进行单元测试。

现在，BindingListView<ViewModel>应该在“V”方面，即YourView : System.Windows.Form { ... }。它将绑定到绑定源YourBindingSource.DataSource = blv;由于我不会对WinForm进行单元测试，因此我将尝试将它们重构为演示者和视图模型，并尽可能保持View的精简。所以，我只是在BindingListView中使用ViewModel，而不是接口IViewModel。

所以BindingListView<ConcreteViewModel>对我来说自然有意义，它不接受模型界面。

请参阅有关MVVM MVP设计和单元测试WinForm的这个问题： Should I unit-test my view in MVP(or VM) or how to keep the code in the view to a minimum?

Answer 3

为什么他们为属性创建新方法，为什么？他们不能只使用PropertyInfo并获取属性值吗？如果我这样做，我会考虑接口，而不是限制用户使用它们。他们正在创造同样的方法，称为原始＆＃34;得到＆＃34;方法，我不明白这是什么意思。

 private static GetPropertyDelegate BuildGetPropertyMethod(PropertyInfo pi)
        {
            MethodInfo getMethod = pi.GetGetMethod();
            Debug.Assert(getMethod != null);

            DynamicMethod dm = new DynamicMethod("__blw_get_" + pi.Name, typeof(object), new Type[] { typeof(T) }, typeof(T), true);
            ILGenerator il = dm.GetILGenerator();

            il.Emit(OpCodes.Ldarg_0);
            il.EmitCall(OpCodes.Call, getMethod, null);

            // Return the result of the comparison.
            il.Emit(OpCodes.Ret);

            // Create the delegate pointing at the dynamic method.
            return (GetPropertyDelegate)dm.CreateDelegate(typeof(GetPropertyDelegate));
        }

修正了排序：

            private static Comparison<T> BuildComparison(string propertyName, ListSortDirection direction)
        {
            PropertyInfo pi = typeof(T).GetProperty(propertyName);
            Debug.Assert(pi != null, string.Format("Property '{0}' is not a member of type '{1}'", propertyName, typeof(T).FullName));

            if (typeof(IComparable).IsAssignableFrom(pi.PropertyType))
            {
                if (pi.PropertyType.IsValueType)
                {
                    return BuildValueTypeComparison(pi, direction);
                }
                else
                {
                    //CHANGED!!!!!
                    //GetPropertyDelegate getProperty = BuildGetPropertyMethod(pi);
                    return delegate(T x, T y)
                    {
                        int result;
                        //CHANGED!!!!!
                        object value1 = pi.GetValue(x, null);// getProperty(x);
                        //CHANGED!!!!!
                        object value2 = pi.GetValue(y, null); //getProperty(y);
                        if (value1 != null && value2 != null)
                        {
                            result = (value1 as IComparable).CompareTo(value2);
                        }
                        else if (value1 == null && value2 != null)
                        {
                            result = -1;
                        }
                        else if (value1 != null && value2 == null)
                        {
                            result = 1;
                        }
                        else
                        {
                            result = 0;
                        }

                        if (direction == ListSortDirection.Descending)
                        {
                            result *= -1;
                        }
                        return result;
                    };
                }
            }
            else if (pi.PropertyType.IsGenericType && pi.PropertyType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
            {
                var compare = typeof(Nullable).GetMethod("Compare", BindingFlags.Static | BindingFlags.Public).MakeGenericMethod(pi.PropertyType.GetGenericArguments()[0]);
                return delegate (T x, T y)
                {
                    return (int)compare.Invoke(x,new[] { pi.GetValue(x, null), pi.GetValue(y, null) } );
                };
                //return BuildNullableComparison(pi, direction);
            }
            else
            {
                return delegate(T o1, T o2)
                {
                    if (o1.Equals(o2))
                    {
                        return 0;
                    }
                    else
                    {
                        return o1.ToString().CompareTo(o2.ToString());
                    }
                };
            }
        }

排序接口时“DynamicMethod的类型所有者无效”错误

3 个答案: