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

简单类+工厂的通用解决方案

  •  3
  • Marc  · 技术社区  · 15 年前

        public class Foo<T>
        {
            public RecordType Type { get; set; }
            public T Value { get; set; }
        }
    

    RecordType 可能看起来像这样:

     public enum RecordType
        {
            EmptyRecord,
            BooleanRecord,
            IntegerRecord,
            StringRecord,
            ByteRecord
        }
    

    IEnumerable<Foo<T>> 为迭代和/或打开 记录类型 Foo 这是一种工厂方法。

    小编辑: 我应该提到的是,我的主要目标是在不强制调用方强制转换的情况下使用.Value。

    1 回复  |  直到 15 年前
        1
  •  2
  •   dtb    15 年前

    您可以引入非通用接口IFoo:

    public interface IFoo
    {
        RecordType Type { get; set; }
    }
    

    它由泛型Foo类实现:

    public class Foo<T> : IFoo
    {
        public T Value { get; set; }
    }
    

    并创建一个工厂方法,该方法根据记录类型创建一个Foo实例:

    public static IFoo CreateFoo(RecordType type)
    {
        switch (type)
        {
            case RecordType.Bool: return new Foo<bool>();
            // ...
        }
    }
    

    IFoo foo = CreateFoo(RecordType.Bool);
    
    if (foo.Type == RecordType.Bool)
    {
        Foo<bool> boolFoo = (Foo<bool>)foo;
        bool value = boolFoo.Value;
    }
    

    如果有一个方法可以处理Foo对象,例如:

    void DoIt<T>(IEnumerable<Foo<T>> foos)
    {
        foreach (Foo<T> foo in foos)
        {
            Qux(foo.Value);
        }
    }
    

    IEnumerable<IFoo> foos = // ...
    DoIt<bool>(foos.OfType<Foo<bool>>());
    

    因此,基本上,您使用Foo<T>当您在编译时知道T,而IFoo如果您只在运行时知道T。IFoo需要检查才能将其转换为Foo<T>对于运行时的一些T。