为什么动态类型在强制转换不起作用的情况下起作用？

Question

到目前为止，我的猜测是动态类型只是在编译期间“关闭”类型检查，并且在动态实例上调用消息时执行类似于类型转换的操作。显然还有其他事情发生。

附加的 NUnit 测试用例显示了我的问题：使用动态类型我可以使用仅在具体子类中可用的方法，但我不能使用强制转换来做同样的事情（导致 InvalidCastException）。我宁愿进行强制转换，因为这可以让我在 VS 中完成完整的代码。

谁能解释正在发生的事情和/或提示我如何在我的案例中完成代码，而不必在每个具体子类中重新实现 WorkWithAndCreate 方法？

干杯，约翰内斯

using System;
using NUnit.Framework;

namespace SlidesCode.TestDataBuilder
{
    [TestFixture]
    public class MyTest
    {
        [Test]
        public void DynamicWorks()
        {
            string aString = CreateDynamic(obj => obj.OnlyInConcreteClass());
            Assert.AreEqual("a string", aString);
        }

        private static string CreateDynamic(Action<dynamic> action)
        {
            return new MyConcreteClass().WorkWithAndCreate(action);
        }

        [Test]
        public void CastingDoesNotWorkButThrowsInvalidCastException()
        {
            string aString = CreateWithCast(obj => obj.OnlyInConcreteClass());
            Assert.AreEqual("a string", aString);
        }

        private static string CreateWithCast(Action<MyConcreteClass> action)
        {
            return new MyConcreteClass().WorkWithAndCreate((Action<MyGenericClass<string>>) action);
        }
    }

    internal abstract class MyGenericClass<T>
    {
        public abstract T Create();
        public T WorkWithAndCreate(Action<MyGenericClass<T>> action)
        {
            action(this);
            return this.Create();
        }
    }

    internal class MyConcreteClass : MyGenericClass<string>
    {
        public override string Create()
        {
            return "a string";
        }

        public void OnlyInConcreteClass()
        {
        }
    }
}

这是我评论中格式化的真实世界示例：

Customer customer = ACustomer(cust =>
        {
            cust.With(new Id(54321));
            cust.With(AnAddress(addr => addr.WithZipCode(22222)));
        });

private static Address AnAddress(Action<AddressBuilder> buildingAction)
{
    return new AddressBuilder().BuildFrom(buildingAction);
}

private static Customer ACustomer(Action<CustomerBuilder> buildingAction)
{
    return new CustomerBuilder().BuildFrom(buildingAction);
}

其中缺少一些细节，但我希望它能说明目的。

Answer 1

dynamic 起作用的原因是dynamic 不依赖于对象类型的编译时知识。 MyGenericClass<string> 没有方法OnlyInConcreteClass()，但是你传递的实例当然有方法，dynamic 找到了这个。

顺便说一句，你可以让WorkWithAndCreate 像这样工作：

public T WorkWithAndCreate<T1>(Action<T1> action)
    where T1 : MyGenericClass<T>
{
    action((T1)this);
    return this.Create();
}

然后，调用也将起作用：

private static string CreateWithCast(Action<MyConcreteClass> action)
{
    return new MyConcreteClass().WorkWithAndCreate(action);
}

您现在不必再投射了。

关于您的构建器，以下操作是否可行？

private static TResult AnInstance<TBuilder, TResult>(Action<TBuilder> buildingAction)
    where TBuilder : Builder<TResult>, new()
{
    return new TBuilder().BuildFrom(buildingAction);
}

Answer 2

这是一个如何使用动态的例子：

http://msdn.microsoft.com/en-us/library/dd264736.aspx

你说：

到目前为止，我的猜测是动态类型只是在编译期间“关闭”类型检查，并且在动态实例上调用消息时执行类似于类型转换的操作

实际上，它使用反射在运行时查找您按名称调用的方法、属性和字段。除非您将对象实际转换回其基础类型，否则不会进行转换。

至于你的实际问题，你能举一个更具体的例子吗？可能有更好的设计，但您没有告诉我们您想要做什么 - 只是您目前正在做什么。

冒昧地猜测一下，您可能想要使用基础interface，并让您的所有函数都接受该基础接口。然后将您要调用的方法放在该接口上，并在您的具体类型中实现它们。通常dynamic 在您没有基类型或无法修改基类型以添加​​虚拟或抽象方法时用作解决方法。

如果你真的想让它按原样工作，你必须用泛型类型参数而不是动态类型参数来编写它。请参阅 Pieter 的解决方案，了解如何正确执行此操作。