.NET 4.0 中的动态：我做得对吗？

Question

昨天，我使用 .NET 4.0 中新的 dynamic 类型编写了第一行代码。我发现这很有用的场景如下：

我有一个包含多个值列表的类。这可以是 List、List、List 或任何类型的列表。使用它们的方式是，我向其中一个或多个列表添加一个值。然后我“同步”它们，以便它们最终都具有相同的长度（那些太短的用默认值填充）。然后我继续添加更多值，再次同步等。目标是一个列表中任何索引处的项目与另一个列表中相同索引处的项目相关。 （是的，通过将所有这些包装在另一个类中可能可以更好地解决这个问题，但这不是本例的重点。）

我在几个类中都有这个构造，所以我想让列表的同步像通用的那样可能的。但由于列表的内部类型可能会有所不同，因此这并不像我最初想象的那么简单。但是，输入今天的英雄：动力学:)

我编写了以下帮助程序类，它可以获取列表（任何类型）的集合以及每个列表的默认值：

using System;
using System.Collections.Generic;
using System.Linq;

namespace Foo.utils
{
    public class ListCollectionHelper
    {
        /// <summary>
        /// Takes a collection of lists and synchronizes them so that all of the lists are the same length (matching
        /// the length of the longest list present in the parameter).
        /// 
        /// It is assumed that the dynamic type in the enumerable is of the type Tuple&lt;ICollection&lt;T>, T>, i.e. a
        /// list of tuples where Item1 is the list itself, and Item2 is the default value (to fill the list with). In
        /// each tuple, the type T must be the same for the list and the default value, but between the tuples the type
        /// might vary.
        /// </summary>
        /// <param name="listCollection">A collection of tuples with a List&lt;T> and a default value T</param>
        /// <returns>The length of the lists after the sync (length of the longest list before the sync)</returns>
        public static int SyncListLength(IEnumerable<dynamic> listCollection)
        {
            int maxNumberOfItems = LengthOfLongestList(listCollection);
            PadListsWithDefaultValue(listCollection, maxNumberOfItems);
            return maxNumberOfItems;
        }

        private static int LengthOfLongestList(IEnumerable<dynamic> listCollection)
        {
            return listCollection.Aggregate(0, (current, tuple) => Math.Max(current, tuple.Item1.Count));
        }

        private static void PadListsWithDefaultValue(IEnumerable<dynamic> listCollection, int maxNumberOfItems)
        {
            foreach (dynamic tuple in listCollection)
            {
                FillList(tuple.Item1, tuple.Item2, maxNumberOfItems);
            }
        }

        private static void FillList<T>(ICollection<T> list, T fillValue, int maxNumberOfItems)
        {
            int itemsToAdd = maxNumberOfItems - list.Count;

            for (int i = 0; i < itemsToAdd; i++)
            {
                list.Add(fillValue);
            }
        }
    }
}

下面是我使用的一组简短的单元测试验证我最终得到了所需的行为：

using System;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Foo.utils;

namespace Foo.UnitTests
{
    [TestClass]
    public class DynamicListSync
    {
        private readonly List<string> stringList = new List<string>();
        private readonly List<bool> boolList = new List<bool>();
        private readonly List<string> stringListWithCustomDefault = new List<string>();
        private readonly List<int> intList = new List<int>();

        private readonly List<dynamic> listCollection = new List<dynamic>();

        private const string FOO = "bar";

        [TestInitialize]
        public void InitTest()
        {
            listCollection.Add(Tuple.Create(stringList, default(String)));
            listCollection.Add(Tuple.Create(boolList, default(Boolean)));
            listCollection.Add(Tuple.Create(stringListWithCustomDefault, FOO));
            listCollection.Add(Tuple.Create(intList, default(int)));
        }

        [TestMethod]
        public void SyncEmptyLists()
        {
            Assert.AreEqual(0, ListCollectionHelper.SyncListLength(listCollection));
        }

        [TestMethod]
        public void SyncWithOneListHavingOneItem()
        {
            stringList.Add("one");
            Assert.AreEqual(1, ListCollectionHelper.SyncListLength(listCollection));

            Assert.AreEqual("one", stringList[0]);
            Assert.AreEqual(default(Boolean), boolList[0]);
            Assert.AreEqual(FOO, stringListWithCustomDefault[0]);
            Assert.AreEqual(default(int), intList[0]);
        }

        [TestMethod]
        public void SyncWithAllListsHavingSomeItems()
        {
            stringList.Add("one");
            stringList.Add("two");
            stringList.Add("three");
            boolList.Add(false);
            boolList.Add(true);
            stringListWithCustomDefault.Add("one");

            Assert.AreEqual(3, ListCollectionHelper.SyncListLength(listCollection));

            Assert.AreEqual("one", stringList[0]);
            Assert.AreEqual("two", stringList[1]);
            Assert.AreEqual("three", stringList[2]);

            Assert.AreEqual(false, boolList[0]);
            Assert.AreEqual(true, boolList[1]);
            Assert.AreEqual(default(Boolean), boolList[2]);

            Assert.AreEqual("one", stringListWithCustomDefault[0]);
            Assert.AreEqual(FOO, stringListWithCustomDefault[1]);
            Assert.AreEqual(FOO, stringListWithCustomDefault[2]);

            Assert.AreEqual(default(int), intList[0]);
            Assert.AreEqual(default(int), intList[1]);
            Assert.AreEqual(default(int), intList[2]);
        }
    }
}

因此，由于这是我第一次尝试动态（无论是在 C# 中还是在其他任何地方......），我只是想问我是否做得正确。显然，代码按预期工作，但是这是正确的方法吗？是否有任何明显的优化或我遗漏的陷阱等？

Answer 1

我还没有仔细研究它，但是在声明集合时使用动态关键字真的有必要吗？在 .NET 4.0 中，还有新机制来支持协变和逆变，意味着您还应该能够使用下面的代码。

    var listCollection = new List<IEnumerable<object>>();

    listCollection.Add(new List<int>());

这里的缺点是你的列表只保存只读的 IEnumerable 实例，而不是可以直接修改的东西（如果你的实现中需要的话）。

除此之外，我认为使用动态效果很好，因为您正在使用它们，但您确实牺牲了 C# 通常提供的很多安全机制。因此，我建议的是，如果您使用此技术，我建议将其编写在一个包含良好且经过测试的类中，该类不会将动态类型暴露给任何更大的客户端代码体。

Answer 2

我在 C# 中对动态进行了相当多的修改，我最初认为它们会非常简洁，因为我是 Ruby/Javascript 动态类型的忠实粉丝，但遗憾的是对实现感到失望。因此，我对“我做得对吗”的看法归结为“这个问题是否适合动力学”——这是我对此的想法。

• 对加载和 JIT 所有动态相关程序集的性能影响可能非常严重。
• 第一次动态解析方法时，C-Sharp 运行时绑定器会在内部抛出并捕获异常。每个调用站点都会发生这种情况（即，如果您有 10 行代码调用动态对象上的方法，则会出现 10 个异常）。如果您将调试器设置为“在第一次机会异常时中断”，这真的很烦人，并且它还会用第一次机会异常消息填充调试输出窗口。您可以抑制这些，但 Visual Studio 使这样做变得很烦人。
• 这两件事加起来 - 在冷启动时，您的应用程序可能需要明显更长的时间来加载。在带有 SSD 的 core i7 上，我发现当我的 WPF 应用程序首次加载所有动态内容时，它会在加载程序集、JITing 和抛出捕获异常时停滞大约 1-2 秒。 （有趣的是，IronRuby 没有这些问题，它的 DLR 实现比 C# 的好得多）
• 一旦加载，性能就非常好。
• 动力学杀死了视觉工作室的智能感知和其他优秀功能。虽然我个人并不介意这一点，因为我有编写大量 ruby​​ 代码的背景，但我组织中的其他几位开发人员对此感到恼火。
• 动态会使调试变得更加困难。 ruby/javascript 等语言提供了 REPL（交互式提示）来帮助它们，但 C# 还没有。如果您只是使用动态来解析方法，它不会那么糟糕，但如果您尝试使用它来动态实现数据结构（ExpandoObject 等），那么调试在 C# 中就变得非常痛苦。当我的同事不得不使用 ExpandoObject 调试一些代码时，他们对我更加恼火。

总的来说：

• 如果你可以做一些不需要动态的事情，就不要使用它们。 C# 实现它们的方式太尴尬了，你的同事会生你的气。
• 如果您只需要非常小的动态功能，请使用反射。经常被引用的使用反射的“性能问题”通常不是什么大问题。
• 尤其要尝试避免由于加载/启动性能损失而导致客户端应用程序出现动态变化。

我对这种特定情况的建议：

• 看起来您可以通过将事物作为 Object 传递来避免动态。我建议你这样做。
• 您将不得不放弃使用 Tuple 来传递数据对，并创建一些自定义类，但这也可能会改进您的代码，因为您可以将有意义的名称附加到数据而不仅仅是 Item1 和 Item2

Answer 3

我相信添加dynamic关键字主要是为了使Microsoft Office互操作更容易，以前您必须编写相当复杂的代码（用C#）才能使用Microsoft Office API，现在Office界面代码可以更加简洁。

其原因在于 Office API 最初是为 Visual Basic 6（或 VB 脚本）使用而编写的； .NET 4.0 添加了多种语言功能，使之变得更容易（以及动态功能，您还可以获得命名参数和可选参数）。

当您使用dynamic关键字时，它会失去编译时检查，因为使用dynamic关键字的对象是在运行时解析的。由于必须加载提供动态支持的程序集，因此会产生一些内存开销。此外，还会产生一些性能开销，类似于使用反射。

Answer 4

我认为这不是动态的解决方案。当您需要有条件地使用一堆不同类型时，动态非常有用。如果这是一个字符串，则执行某些操作；如果是一个 int，则执行其他操作；如果是一个 Puppy 类实例，则调用 bark()。动态使您不必使用大量类型转换或丑陋的泛型来乱扔这样的代码。动态和其他高级语言功能的用途是用于代码生成器、解释器等...

这是一个很酷的功能，但除非您与动态语言或 COM 互操作性交谈，否则它仅适用于遇到棘手的高级问题时。

Answer 5

我认为您可以通过使用 IList 来完成同样的事情，而不是在这里使用动态。 （非泛型）两者都消除了编译时类型检查，但由于泛型列表也实现了 IList，因此您仍然可以使用 IList 进行运行时类型检查。

另外，附带问题，为什么使用 .Aggregate() 而不是 .Max() 来查找最大长度？