2

I'm wondering how one can prove what the .Net framework is doing behind the scenes.

I have a method that accepts a parameter of a List<String> originalParameterList.

In my method I have another List<String> newListObj if I do the following:

List<String> newListObj = originalParameterList
    newListObj.Add(value);
    newListObj.Add(value1);
    newListObj.Add(value2);

The count of the originalParameterList grows (+3).

If I do this:

List<String> newListObj = new List<String>(originalParamterList);

newListObj.Add(value);
newListObj.Add(value1);
newListObj.Add(value2);

The count of the originalParameterList stays the sames (+0).

I also found that this code behaves the same:

List<String> newListObj = new List<String>(originalParamterList.ToArray());

newListObj.Add(value);
newListObj.Add(value1);
newListObj.Add(value2);

The count of the originalParameterList stays the sames (+0).

My question is, is there a way to see what the .Net Framework is doing behind the scenes in a definitive way?

4

7 回答 7

1

您可以将程序集加载到 ILDASM 和（加载时），找到您的方法并双击它，它将显示该方法的 cil 代码。只需在搜索的 Windows 开始菜单中键入“IL”。

或者，您可以使用以下这些方法来创建一个新的独立列表

        private void GetList(List<string> lst)
        {
            List<string> NewList = lst.Cast<string>().ToList();
            NewList.Add("6");
            //not same values.
            //or....
            List<string> NewList = lst.ConvertAll(s => s);
            NewList.Add("6");
            //again different values

        }
于 2013-06-28T17:05:23.000 回答
0

通常，文档应该提供足够的信息来使用 API。

在您的具体示例中，文档public List(IEnumerable<T> collection)说（强调我的）：

初始化 List 类的新实例，该实例包含 从指定集合复制的元素，并且有足够的容量容纳复制的元素数量。

这里的参考是构造函数的源代码：

public List (IEnumerable <T> collection)
{
    if (collection == null)
        throw new ArgumentNullException ("collection");

    // initialize to needed size (if determinable)
    ICollection <T> c = collection as ICollection <T>;
    if (c == null) {
        _items = EmptyArray<T>.Value;;
        AddEnumerable (collection);
    } else {
        _size = c.Count;
        _items = new T [Math.Max (_size, DefaultCapacity)];
        c.CopyTo (_items, 0);
    }
}

void AddEnumerable (IEnumerable <T> enumerable)
{
    foreach (T t in enumerable)
    {
        Add (t);
    }
}
于 2013-06-28T15:47:19.020 回答
0

最简单的方法就是去 MSDN

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

它说

初始化 List 类的新实例，该实例包含从指定集合复制的元素，并且有足够的容量容纳复制的元素数量。

所以在内部它只是将传递的 IEnumerable 的所有元素添加到新列表中。它还说

这是一个 O(n) 操作

这意味着没有假设优化。

于 2013-06-28T15:47:25.737 回答
0

那是因为您引用了原始列表的第一个案例（因为它是一个引用类型），并且您通过 newListObj 修改了它的集合。第二种和第三种情况你通过 List 构造函数List Class复制了原始对象的集合，并且你修改了新的集合，这对原始没有任何影响。

于 2013-06-28T15:47:43.173 回答
0

正如其他人已经说过的，有各种工具可以让您检查 .NET 框架的源代码。我个人更喜欢JetBrains 的 dotPeek，它是免费的。

在您提到的特定情况下，我认为当您将一个列表传递给另一个列表的构造函数时，该列表会被复制。如果您只是将一个变量分配给另一个变量，那么这些变量只是指的是同一个列表。

于 2013-06-28T15:48:38.120 回答
0

你可以

于 2013-06-28T15:49:19.623 回答
0

这是来自 List constrcutor 的代码：

public List(IEnumerable<T> collection)
{
    if (collection == null)
    {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
    }
    ICollection<T> collection2 = collection as ICollection<T>;
    if (collection2 != null)
    {
        int count = collection2.Count;
        this._items = new T[count];
        collection2.CopyTo(this._items, 0);
        this._size = count;
        return;
    }
    this._size = 0;
    this._items = new T[4];
    using (IEnumerator<T> enumerator = collection.GetEnumerator())
    {
        while (enumerator.MoveNext())
        {
            this.Add(enumerator.Current);
        }
    }
}

正如您所看到的，当您调用采用 IEnumerable 的 costructor 时，它将所有数据复制到自身。

于 2013-06-28T15:50:15.260 回答