使包装类的扩展方法/构造函数通用

【问题标题】：Making Extension Methods/Constructors of a wrapper class Generic使包装类的扩展方法/构造函数通用
【发布时间】：2015-09-24 18:11:39
【问题描述】：

在一项服务（我无法更改）中，我有两个对象类 Bar 和 Baz，它们的属性大多相似（但遗憾的是，不，它们不是从相同的基类或从相同的接口继承...是的——愚蠢），以及与它们的相对BarQux 和BazQux 属性相关的依赖类：

public class Bar                          public class Baz
{                                         {
    public int ID { get; set; }               public int ID { get; set; }
    public bool Active { get; set; }          public bool Active { get; set; }
    public int BarQux { get; set; }           public int BazQux { get; set; }
    ...                                       ...
}                                         }

public class Qux
{
    public int ID { get; set; } // Corresponds to BarQux and BazQux
    public string Name { get; set; }
}

在 WPF 屏幕中，我将每种类型的列表（Baz 和 Bar）绑定到两个单独的 ListView。我需要每个人都有一个额外的Selected CheckBox 列。为此，我创建了一个包含公共属性的包装类、附加的Selected 属性以及每个属性的构造函数：

public class Foo
{
    public Foo(Bar bar, Qux qux)
    {
        this.Active = bar.Active;
        this.FooQux = string.Format("{0} - {1}", qux.ID, qux.Name);
        ...
    }

    public Foo(Baz baz, Qux qux)
    {
        this.Active = baz.Active;
        this.FooQux = string.Format("{0} - {1}", qux.ID, qux.Name);
        ...
    }

    public bool Selected { get; set; }
    public int ID { get; set; }
    public bool Active { get; set; }
    public string FooQux { get; set; }
    ...
}

为了将 Baz 和 Bar 类的每个集合转换为 Foo 的集合，我创建了以下扩展方法：

public static List<Foo> ToFoo(this IEnumerable<Bar> bars, IEnumerable<Qux> quxs)
{
    List<Foo> foos = new List<Foo>();

    foreach (Bar bar in bars)
    {
        Foo foo = new Foo(bar, quxs.Single(qux => qux.ID == bar.BarQux));
        foos.Add(foo);
    }

    return foos;
}

public static List<Foo> ToFoo(this IEnumerable<Baz> bazs, IEnumerable<Qux> quxs)
{
    List<Foo> foos = new List<Foo>();

    foreach (Baz baz in bazs)
    {
        Foo foo = new Foo(baz, quxs.Single(qux => qux.ID == baz.BazQux));
        foos.Add(foo);
    }

    return foos;
}

问题：

如何使这个通用化？

理论、实施和错误：

  1. 由于除了Bar 和Baz 参数之外，构造函数几乎相同，我可以以某种方式使用泛型类型T 创建一个构造函数并仍然获取属性吗？

    public class Foo<T>
{
    public Foo(T obj, Qux qux)
    {
        this.Active = obj.Active; // 'T' does not contain a definition for 'Active'...
        this.Qux = string.Format("{0} - {1}", qux.ID, qux.Name);
        ...
    }
    ...
}

  2. 更改构造函数以接收Qux 对象的整个集合并在那里执行quxs.Single(qux =&gt; qux.ID == object.ObjectQux) 逻辑。然后将扩展方法变成一个泛型方法，如下所示。

    public static List<Foo> ToFoo<T>(this IEnumerable<T> objCollection, IEnumerable<Qux> quxs)
{
    List<Foo> foos = new List<Foo>();

    foreach (T obj in objCollection)
    {
        Foo foo = new Foo(obj, quxs); // The best overloaded method... has some invalid arguments.
        foos.Add(foo);
    }

    return foos;
}

  3. 1 和 2 合并？有什么我没有想到的吗？

【问题讨论】：

  • 你可能想看看这个en.wikipedia.org/wiki/Adapter_pattern
  • 不能修改文件还是不能修改类？例如，您可以实现部分类。但是，您必须将原始类更改为部分类。
  • @ScottNimrod 我无法修改服务中的任何类或文件，例如 Bar、Baz 和 Type 类。如果可以的话，我想让前两个继承自基类或接口 - 这将使我在概括事物方面的有限经验更容易。
  • 这看起来像是一个 DTO 对象到/从 BusinessObject 的案例。您可以完全控制 businessObject 实现，但 DTO 对象实际上来自“难以”更改的外部服务。

标签： c# wpf generics wrapper


【解决方案1】：

如果您的属性有限并且列表中的项目数量也很少，那么您可以使用Reflection。由于您将在 WPF 中使用它，因此我还建议将该进程移至单独的后台线程。

通用 Foo

public class Foo<T>
{
    public Foo(T obj, Qux qux)
    {
        //this.Active = obj.Active;

        var fooProps = GetType().GetProperties().ToList();
        var tProps = typeof(T).GetProperties()
            .Where(p =>
            {
                var w = fooProps.FirstOrDefault(f => f.Name == p.Name);
                return w != null;
            }).ToList();

        foreach (var propertyInfo in tProps)
        {
            var val = propertyInfo.GetValue(obj);
            fooProps.First(e => e.Name == propertyInfo.Name).SetValue(this, val);
        }
        this.FooQux = string.Format("{0} - {1}", qux.ID, qux.Name);
    }
    public bool Selected { get; set; }
    public int ID { get; set; }
    public bool Active { get; set; }
    public string FooQux { get; set; }
}

你的扩展方法

    public static IEnumerable<Foo<Bar>> ToFoo(this IEnumerable<Bar> bars, IEnumerable<Qux> quxs)
    {
        return bars.
            Select(bar => new Foo<Bar>(bar, quxs.Single(qux => qux.ID == bar.BarQux))).ToList();
    }

    public static IEnumerable<Foo<Baz>> ToFoo(this IEnumerable<Baz> bazs, IEnumerable<Qux> quxs)
    {
        return bazs.
            Select(baz => new Foo<Baz>(baz, quxs.Single(qux => qux.ID == baz.BazQux))).ToList();
    }
    public static IEnumerable<Qux> ToQuxes(this IEnumerable<BazQux> bazQuxs)
    {
        return bazQuxs.Select(b => new Qux(typeof(BazQux), b)).ToList();
    }

    public static IEnumerable<Qux> ToQuxes(this IEnumerable<BarQux> barQuxes )
    {
        return barQuxes.Select(b => new Qux(typeof(BarQux), b)).ToList();
    }

同样，您也可以将您的 BarQux 或 BazQux 转换为非通用的 Qux 类。

public class Qux
{
    public int ID { get; set; } // Corresponds to BarQux and BazQux
    public string Name { get; set; }

    public Qux(Type type, object obj)
    {
        var ob = Convert.ChangeType(obj, type);

        var quxProps = GetType().GetProperties();
        var obProps = ob.GetType().GetProperties()
            .Where(p =>
            {
                var w = quxProps.FirstOrDefault(f => f.Name == p.Name);
                return w != null;
            }).ToList();
        foreach (var propertyInfo in obProps)
        {
            var val = propertyInfo.GetValue(obj);
            quxProps.First(e => e.Name == propertyInfo.Name).SetValue(this, val);
        }

    }
}

然后你可以调用 ToFoo 扩展方法，瞧你有一个 Foo 列表。

您也可以使用Qux类的逻辑将Foo转换为非泛型

【讨论】：

  • 写得很好的建议。我目前正在按照这些思路测试一个想法，尽管我更喜欢你在属性中循环的方法。对反射不太了解，我很好奇这是否会太贵，因此不值得花时间——这些类有 6 个共同的属性加上Qux 属性，通常对于任何给定的对象的数量都转换为Foo客户的范围从少数到可能几百。想法？我需要一些时间来测试您的建议，之后我会回复您。
  • 查看 6 个属性的数量和数百条记录，上述解决方案是可行的。您拥有的另一个好处是客户端机器将使用反射进行处理。如果它在服务端，您可能会遇到问题，因为托管服务的机器会受到打击
  • 感谢您的意见！我无法对Qux 类应用任何更改，因为这也是服务的一部分——但无论如何我都不需要它们。通用类Foo 效果很好。我发布了一个答案，显示了我的确切用法，以使扩展方法也通用。
【解决方案2】：

我真的看不出这样做有什么好处。

如果您坚持使用泛型，您可以像这样对 T 进行一些类型检查：

public class Foo<T>
{
    public Foo(T obj, Qux qux)
    {
        var baz = obj as Baz;
        var bar = obj as Bar;

        Active = baz != null && baz.Active || bar != null && bar.Active;

        this.FooQux = string.Format("{0} - {1}", qux.ID, qux.Name);
    }

    public bool Selected { get; set; }
    public int ID { get; set; }
    public bool Active { get; set; }
    public string FooQux { get; set; }
}

或者：

public static List<Foo> ToFoo<T>(this IEnumerable<T> objCollection, IEnumerable<Qux> quxs)
{
    List<Foo> foos = new List<Foo>();

    foreach (T obj in objCollection)
    {
        var baz = obj as Baz;
        var bar = obj as Bar;

        Foo foo = null;

        if(baz != null)
            foo = new Foo(baz, quxs.Single(qux => qux.ID == baz.BazQux));

        if(bar != null)
            foo = new Foo(bar, quxs.Single(qux => qux.ID == bar.BarQux));

        if(foo != null)
            foos.Add(foo);
    }

    return foos;
}

但这显然并不比您已有的好多少，如果 T 不是 Bar 或 Baz（未显示），您将不得不进行一些异常处理，这会使您面临潜在的运行时故障。您也可以使用反射，但效果相同。

不幸的是，您正在寻找的东西在 C# 中是不可能的。唯一可以摆脱这种情况的方法是，如果接口是鸭子类型的 a-la Golang，但事实并非如此。

【讨论】：

  • 实现包装器是有道理的。当我被告知可能还有一些具有相同属性名称和类型的类也需要注意时，我有一个应用程序开发进行到一半的场景。不可能编写更多的构造函数。所以我通过反思去照顾其他课程以节省开发时间
  • 我对通用实现的兴趣在于减少重复的代码，并在服务类发生变化时减少未来的工作。很有可能我所拥有的就足够了，而泛型就更少了——我愿意接受——这是一种学习体验。
【解决方案3】：

根据Sandesh的建议，最终结果：

public class Foo<T>
{
    public Foo() {}

    public Foo(T obj, IEnumerable<Qux> quxs, string quxPropName)
    {
        var fooProps = GetType().GetProperties().ToList();
        var tProps = typeof(T).GetProperties()
            .Where(p =>
            {
                var w = fooProps.FirstOrDefault(f => f.Name == p.Name);
                return w != null;
            }).ToList();

        foreach (var propertyInfo in tProps)
        {
            var val = propertyInfo.GetValue(obj, null);
            fooProps.First(e => e.Name == propertyInfo.Name).SetValue(this, val, null);
        }

        int id = (int)typeof(T).GetProperty(quxPropName).GetValue(obj, null);
        Qux qux = quxs.Single(q => q.ID == id);
        this.FooQux = string.Format("{0} - {1}", qux.ID, qux.Name);
    }

    public bool Selected { get; set; }
    public int ID { get; set; }
    public bool Active { get; set; }
    public string FooQux { get; set; }
}

以及通用的扩展方法：

public static List<Foo<T>> ToFoo<T>(this IEnumerable<T> list, IEnumerable<Qux> quxs, string quxPropName)
{
    List<Foo<T>> foos = null;

    try
    {
        foos = list.Select(obj => new Foo<T>(obj, quxs, quxPropName)).ToList();
    }
    catch
    {
        foos = new List<Foo<T>>();
    }

    return foos;
}

及用法：

List<Foo<Bar>> bars = barCollection.ToFoo(quxCollection, "BarQux");
List<Foo<Baz>> bazs = bazCollection.ToFoo(quxCollection, "BazQux");

【讨论】：

  • 添加一些异常处理，因为这种方法也提供了误用的范围，因为 ToFoo 扩展方法可以用于实现 IEnumerable&lt;T&gt; 的其他类，您可能希望防止这种方法
猜你喜欢
  • 2013-11-15
  • 2013-04-15
  • 2021-02-13
  • 2016-08-26
  • 2014-05-29
  • 1970-01-01
  • 1970-01-01
  • 2023-03-10
  • 2011-03-11
相关资源
最近更新 更多
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode