代码之家  ›  专栏  ›  技术社区  ›  blu

C#泛型复制构造函数

  •  5
  • blu  · 技术社区  · 16 年前

    我有一个接口和两个实现该接口的类。类具有泛型类型。我想从一个类的实例克隆到另一个类。

    interface IFoo
    {
        // stuff
    }
    
    class Foo<T> : IFoo
    {
        // foo stuff
        // ifoo implementation
    }
    
    class Bar<T> : IFoo
    {
        // bar stuff
        // ifoo implementation
    }
    

    我创建了一个扩展方法来实现克隆:

    public static Bar<T> Clone<T>(this IFoo foo) 
    {
        return new Bar<T>(foo);
    }
    

    调用该方法需要以下类型:

    someFoo.Clone<T> ...
    

    更新 下面是如何使用它来更好地说明这种情况。

    在方法中,我迭代一个集合并返回IFoo的枚举。在该方法中,我查看源集合的属性并确定Foo的类型。

    IFoo foo = null;
    
    string type = element.Attribute("Type").Value;
    switch (type)
    {
        case "int":
            foo = new Foo<int>();
            break;
    
        case "string":
            foo = new Foo<string>();
            break;
    
        // etc
    }
    // other stuff
    
    yield return foo;
    

    5 回复  |  直到 16 年前
        1
  •  2
  •   Jero    16 年前

    所以你一切正常,但你想能够使用语法

    someFoo.Clone()
    

    而不是

    someFoo.Clone<int>()
    

    你希望int是隐含的而不是显式的?

    在代码示例中不能这样做的原因是IFoo没有引用创建所需的泛型类型t Bar<T> .

    我建议您确实需要另一个接口: IFoo<T>

    public static Bar<T> Clone<T>(this IFoo<T> foo) 
    {
        return new Bar<T>(foo);
    }
    

    那你就不用担心

    IFoo<int> someFoo = new Foo<int>();
    Bar<int> someBar = someFoo.Clone();
    

    希望有帮助

        2
  •  0
  •   Community CDub    8 年前
        3
  •  0
  •   Jozef Izso    16 年前

    当您需要完全控制深度复制克隆时,这种模式非常好:

    public class FooBase
    {
        private int x;
    
        public FooBase() { /* standard contructor */ }
    
        protected FooBase(FooBase clone)
        {
            this.x = clone.x;
        }
    
        public FooBase Clone() { return new FooBase(this); }
    }
    
    public class Foo : FooBase
    {
        private int y;
    
        public Foo() { /* standard contructor */ }
    
        protected Foo(Foo clone) : base(clone)
        {
            this.y = clone.y;
        }
    
        public Foo Clone() { return new Foo(this); }
    }
    

    定义用于克隆的受保护构造函数-以便派生类可以克隆基类中的值。

    更新 :我想我误解了这个问题,已经实施了克隆。Freddy是对的-编译器必须知道它应该为哪个类型推断,而不能从IFoo类型推断。它可以在室内完成 (此Foo<T>Foo) 不过。

        4
  •  0
  •   configurator    16 年前

    尝试这样定义方法

    public static Bar<T> Clone<T>(this Foo<T> foo)
    {
        return new Bar<T>(foo);
    }
    

    这样,参数将具有泛型类型,编译器将具有从中推断类型的源。

        5
  •  0
  •   eglasius    16 年前

    如果它适用于你的场景,你可以有一个 IFoo<T> Foo<T> . 您确实需要传递引用T的东西,以便编译器可以推断出适当的类型。