c# - 使用动态设置不受控制的(第三方)密封类型的不同属性

Question

给定以下程序:

using System;
using System.Collections.Generic;

namespace ConsoleApplication49
{
    using FooSpace;

    class Program
    {
        static void Main(string[] args)
        {
            IEnumerable<FooBase> foos = FooFactory.CreateFoos();

            foreach (var foo in foos)
            {             
                HandleFoo(foo);
            }
        }

        private static void HandleFoo(FooBase foo)
        {
            dynamic fooObject = foo;
            ApplyFooDefaults(fooObject);
        }

        private static void ApplyFooDefaults(Foo1 foo1)
        {
            foo1.Name = "Foo 1";

            Console.WriteLine(foo1);
        }

        private static void ApplyFooDefaults(Foo2 foo2)
        {
            foo2.Name        = "Foo 2";
            foo2.Description = "SomeDefaultDescription";

            Console.WriteLine(foo2);
        }

        private static void ApplyFooDefaults(Foo3 foo3)
        {
            foo3.Name    = "Foo 3";
            foo3.MaxSize = Int32.MaxValue;

            Console.WriteLine(foo3);
        }

        private static void ApplyFooDefaults(Foo4 foo4)
        {
            foo4.Name        = "Foo 4";
            foo4.MaxSize     = 99999999;
            foo4.EnableCache = true;

            Console.WriteLine(foo4);
        }

        private static void ApplyFooDefaults(FooBase unhandledFoo)
        {
            unhandledFoo.Name = "Unhandled Foo";
            Console.WriteLine(unhandledFoo);
        }
    }    
}

/////////////////////////////////////////////////////////
// Assume this namespace comes from a different assembly
namespace FooSpace
{
    ////////////////////////////////////////////////
    // these cannot be changed, assume these are 
    // from the .Net framework or some 3rd party
    // vendor outside of your ability to alter, in
    // another assembly with the only way to create
    // the objects is via the FooFactory and you
    // don't know which foos are going to be created
    // due to configuration.

    public static class FooFactory
    {
        public static IEnumerable<FooBase> CreateFoos()
        {
            List<FooBase> foos = new List<FooBase>();
            foos.Add(new Foo1());
            foos.Add(new Foo2());
            foos.Add(new Foo3());
            foos.Add(new Foo4());
            foos.Add(new Foo5());

            return foos;
        }
    }

    public class FooBase
    {
        protected FooBase() { }

        public string Name { get; set; }

        public override string ToString()
        {
            return String.Format("Type = {0}, Name=\"{1}\"", this.GetType().FullName, this.Name);
        }
    }

    public sealed class Foo1 : FooBase
    {
        internal Foo1() { }
    }

    public sealed class Foo2 : FooBase
    {
        internal Foo2() { }

        public string Description { get; set; }

        public override string ToString()
        {
            string baseString =  base.ToString();
            return String.Format("{0}, Description=\"{1}\"", baseString, this.Description);
        }
    }

    public sealed class Foo3 : FooBase
    {
        internal Foo3() { }

        public int MaxSize { get; set; }

        public override string ToString()
        {
            string baseString =  base.ToString();
            return String.Format("{0}, MaxSize={1}", baseString, this.MaxSize);
        }
    }

    public sealed class Foo4 : FooBase
    {
        internal Foo4() { }

        public int MaxSize { get; set; }
        public bool EnableCache { get; set; }

        public override string ToString()
        {
            string baseString =  base.ToString();
            return String.Format("{0}, MaxSize={1}, EnableCache={2}", baseString,
                                                                      this.MaxSize,
                                                                      this.EnableCache);
        }
    }

    public sealed class Foo5 : FooBase
    {
        internal Foo5() { }
    }
    ////////////////////////////////////////////////
}

产生以下输出:

Type = ConsoleApplication49.Foo1, Name="Foo 1"
Type = ConsoleApplication49.Foo2, Name="Foo 2", Description="SomeDefaultDescription"
Type = ConsoleApplication49.Foo3, Name="Foo 3", MaxSize=2147483647
Type = ConsoleApplication49.Foo4, Name="Foo 4", MaxSize=99999999, EnableCache=True
Type = ConsoleApplication49.Foo5, Name="Unhandled Foo"
Press any key to continue . . .

我在这里选择使用动态来避免以下情况:

1. 使用 switch/if/else 语句，例如开关(foo.GetType().Name)
2. 显式类型检查语句，例如foo 是 Foo1
3. 显式转换语句，例如(Foo1)foo

由于 dynamic 转换，正确的 ApplyFooDefaults 方法根据传入 HandleFoo(FooBase foo) 的对象类型被调用.任何没有适当的 ApplyFooDefaults 处理程序方法的对象，都会落入“捕获所有”方法，ApplyFooDefaults(FooBase unhandledFoo)。

这里的一个关键部分是 FooBase 和派生类代表了我们无法控制的类型，无法从中派生以添加额外的接口(interface)。

这是对动态的“良好”使用吗？这个问题是否可以在不增加额外复杂性的情况下以 OOP 方式解决，考虑到约束以及这只是为这些对象设置默认属性值这一事实？

*已更新*

在 Bob Horn 的回答之后，我意识到我的场景并不完整。附加限制:

1. 您不能直接创建 Foos，您必须使用 FooFactory。
2. 你不能假定 Foo 类型，因为 Foo 类型在配置和反射创建。

.

Answer 1

好吧，单个对象的初始化应该发生在类型的构造函数中。如果工厂未能做到这一点，并且仅输出具有基本类型的对象，那么显然它超出了 OOP 模式，无法根据类型初始化对象。

唉，运行时类型检测是可行的方法，而 dynamic 正是这样做的，所以是的，您的解决方案非常漂亮。 (但第三方库不是，因为它强制你使用动态类型)