关于c#:linq-查询的结果会开辟新的内存吗

昨天群里有位敌人问：linq 查问的后果会开拓新的内存吗？如果开了，那是对原序列集外面元素的深拷贝还是仅仅拷贝其援用？

其实这个问题我感觉问的挺好，很多初学 C# 的敌人或多或少都有这样的疑难，甚至有 3，4 年工作教训的敌人可能都不是很分明，这就导致在写代码的时候总是会畏手畏脚，还会莫名的揪心这样玩的话内存会不会暴涨暴跌，这一篇我就用 windbg 来帮忙敌人彻底剖析一下。

这位老弟提到了是深拷贝还是浅拷贝，本意就是想问：linq 一个援用类型汇合到底会怎么？ 这里我先模仿一个汇合，代码如下：


    class Program
    {static void Main(string[] args)
        {var personList = new List<Person>() {new Person() {Name="jack", Age=20},
                                              new Person() { Name="elen",Age=25,},
                                              new Person() {  Name="john", Age=22}
                                            };

            var query = personList.Where(m => m.Age > 20).ToList();

            Console.WriteLine($"query.count={query.Count}");

            Console.ReadLine();}
    }

    class Person
    {public string Name { get; set;}

        public int Age {get; set;}
    }

如果用 windbg 的话，就非常简单了，假如是深 copy 的话，那么 query 之后，托管堆上就会有 5 个 Person，那是不是这样呢？用 !dumpheap -stat -type Person 到托管堆验证一下即可。


0:000> !dumpheap -stat -type Person
Statistics:
              MT    Count    TotalSize Class Name
00007ff7f27c3528        1           64 System.Func`2[[ConsoleApp5.Person, ConsoleApp5],[System.Boolean, System.Private.CoreLib]]
00007ff7f27c2b60        2           64 System.Collections.Generic.List`1[[ConsoleApp5.Person, ConsoleApp5]]
00007ff7f27c9878        1           72 System.Linq.Enumerable+WhereListIterator`1[[ConsoleApp5.Person, ConsoleApp5]]
00007ff7f27c7a10        3          136 ConsoleApp5.Person[]
00007ff7f27c2ad0        3           96 ConsoleApp5.Person

从最初一行输入能够看到: ConsoleApp5.Person 的 Count=3，也就表明没有所谓的深 copy，如果你还不信的话，能够在 query 中批改某一个 Person 的 Age，看看原始的 personList 汇合是不是同步更新, 批改代码如下：


        static void Main(string[] args)
        {var personList = new List<Person>() {new Person() {Name="jack", Age=20},
                                              new Person() { Name="elen",Age=25,},
                                              new Person() {  Name="john", Age=22}
                                            };

            var query = personList.Where(m => m.Age > 20).ToList();

            // 成心批改 Age=25 为  Age=100；query[0].Age = 100;

            Console.WriteLine($"query[0].Age={query[0].Age}, personList[2].Age={personList[1].Age}");

            Console.ReadLine();}

从截图来看更加验证了并没有所谓的深 copy 一说。

要验证是不是 copy 援用，最粗犷的办法就是看看 query 这个数组在托管堆上的存储行态就明确了，同样你也能够借助 windbg 去验证一下，先到线程栈去找 query 变量，而后用 da 命令对 query 进行打印。


0:000> !clrstack -l
OS Thread Id: 0x809c (0)
        Child SP               IP Call Site
000000E143D7E9B0 00007ff7f26f18be ConsoleApp5.Program.Main(System.String[]) [E:\net5\ConsoleApp5\ConsoleApp5\Program.cs @ 20]
    LOCALS:
        0x000000E143D7EA38 = 0x00000218266aab70
        0x000000E143D7EA30 = 0x00000218266aad98

0:000> !do 0x00000218266aad98
Name:        System.Collections.Generic.List`1[[ConsoleApp5.Person, ConsoleApp5]]
MethodTable: 00007ff7f27b2b60
EEClass:     00007ff7f27abad0
Size:        32(0x20) bytes
File:        C:\Program Files\dotnet\shared\Microsoft.NETCore.App\3.1.9\System.Private.CoreLib.dll
Fields:
              MT    Field   Offset                 Type VT     Attr            Value Name
0000000000000000  4001c35        8              SZARRAY  0 instance 00000218266aadb8 _items
00007ff7f26bb1f0  4001c36       10         System.Int32  1 instance                2 _size
00007ff7f26bb1f0  4001c37       14         System.Int32  1 instance                2 _version
0000000000000000  4001c38        8              SZARRAY  0   static dynamic statics NYI                 s_emptyArray

0:000> !da 00000218266aadb8
Name:        ConsoleApp5.Person[]
MethodTable: 00007ff7f27b7a10
EEClass:     00007ff7f26b6580
Size:        56(0x38) bytes
Array:       Rank 1, Number of elements 4, Type CLASS
Element Methodtable: 00007ff7f27b2ad0
[0] 00000218266aac00
[1] 00000218266aac20
[2] null
[3] null

从最初四行代码能够看出数组有 4 个格子，前 2 个格子放的是内存地址，后两个都是 null，可能有些敌人会问，query 不是 2 条记录吗？怎么会有 4 个格子呢？这是因为 query 是 List 构造，而 List 底层用的是数组，默认以 4 个格子起步，不信的话翻一下 List 原代码即可。


    public class List<T>
    {private void EnsureCapacity(int min)
        {if (_items.Length < min)
            {int num = (_items.Length == 0) ? 4 : (_items.Length * 2);   // 默认 4 个大小
                if ((uint)num > 2146435071u)
                {num = 2146435071;}
                if (num < min)
                {num = min;}
                Capacity = num;
            }
        }
    }

如果你想进一步查看数组中前两个元素 00000218266aac00, 00000218266aac20 指向的是什么，能够用 !do 打印一下即可。


0:000> !do 00000218266aac00
Name:        ConsoleApp5.Person
MethodTable: 00007ff7f27b2ad0
EEClass:     00007ff7f27c2a00
Size:        32(0x20) bytes
File:        E:\net5\ConsoleApp5\ConsoleApp5\bin\Debug\netcoreapp3.1\ConsoleApp5.dll
Fields:
              MT    Field   Offset                 Type VT     Attr            Value Name
00007ff7f2771e18  4000001        8        System.String  0 instance 00000218266aab30 <Name>k__BackingField
00007ff7f26bb1f0  4000002       10         System.Int32  1 instance               25 <Age>k__BackingField
0:000> !do 00000218266aac20
Name:        ConsoleApp5.Person
MethodTable: 00007ff7f27b2ad0
EEClass:     00007ff7f27c2a00
Size:        32(0x20) bytes
File:        E:\net5\ConsoleApp5\ConsoleApp5\bin\Debug\netcoreapp3.1\ConsoleApp5.dll
Fields:
              MT    Field   Offset                 Type VT     Attr            Value Name
00007ff7f2771e18  4000001        8        System.String  0 instance 00000218266aab50 <Name>k__BackingField
00007ff7f26bb1f0  4000002       10         System.Int32  1 instance               22 <Age>k__BackingField

到这里为止，我感觉答复这位敌人的疑难应该是没有问题了，不过这里既然说到了汇合中的援用类型，不得不说一下汇合中的值类型又会是怎么样的？

有了下面的根底，验证这个问题的答案就简略了，先上测试代码


        static void Main(string[] args)
        {var list = new List<int>() {1, 2, 3, 4, 5, 6, 7,8,9,10};

            var query = list.Where(m => m > 5).ToList();

            Console.ReadLine();}

而后间接把整个数组内容打印进去


// list
0:000> !DumpArray /d 0000019687c8aba8
Name:        System.Int32[]
MethodTable: 00007ff7f279f090
EEClass:     00007ff7f279f010
Size:        88(0x58) bytes
Array:       Rank 1, Number of elements 16, Type Int32
Element Methodtable: 00007ff7f26cb1f0
[0] 0000019687c8abb8
[1] 0000019687c8abbc
[2] 0000019687c8abc0
[3] 0000019687c8abc4
[4] 0000019687c8abc8
[5] 0000019687c8abcc
[6] 0000019687c8abd0
[7] 0000019687c8abd4
[8] 0000019687c8abd8
[9] 0000019687c8abdc
[10] 0000019687c8abe0
[11] 0000019687c8abe4
[12] 0000019687c8abe8
[13] 0000019687c8abec
[14] 0000019687c8abf0
[15] 0000019687c8abf4

// query
0:000> !DumpArray /d 0000019687c8ae68
Name:        System.Int32[]
MethodTable: 00007ff7f279f090
EEClass:     00007ff7f279f010
Size:        56(0x38) bytes
Array:       Rank 1, Number of elements 8, Type Int32
Element Methodtable: 00007ff7f26cb1f0
[0] 0000019687c8ae78
[1] 0000019687c8ae7c
[2] 0000019687c8ae80
[3] 0000019687c8ae84
[4] 0000019687c8ae88
[5] 0000019687c8ae8c
[6] 0000019687c8ae90
[7] 0000019687c8ae94

认真比照 list 和 query 的数组出现，发现有两点好玩的信息：

值类型和援用类型一样，数组中都是寄存地址的。
值类型数组中的所有格子都被填满，不像援用类型数组中还有 null 的状况。

接下来的问题是，数组中每个元素的地址到底指向了谁，能够挑出每个数组的 0 号元素地址，用 dp 命令看一看：


//list
0:000> dp 0000019687c8abb8
00000196`87c8abb8  00000002`00000001 00000004`00000003
00000196`87c8abc8  00000006`00000005 00000008`00000007
00000196`87c8abd8  0000000a`00000009 00000000`00000000

//query
0:000> dp 0000019687c8ae78
00000196`87c8ae78  00000007`00000006 00000009`00000008
00000196`87c8ae88  00000000`0000000a 00000000`00000000

看到没有，原来地址下面寄存的都是数字值，深 copy 无疑哈。

以上所有的剖析能够得出：援用类型数组是援用 copy，值类型数组是深 copy，有时候背诵得来的货色总是容易遗记，只有实操验证能力真正的刻骨铭心！????????????

更多高质量干货：参见我的 GitHub: dotnetfly

关于c#:linq-查询的结果会开辟新的内存吗

一：背景

1. 讲故事

二：寻找答案

1. 一个小案例

2. 真的是深 copy 吗？

3. 真的是 copy 援用吗？

三：汇合中的值类型是什么样的 copy 形式

1. 应用 windbg 验证

四：总结