C# 基础（二十八）C#的值类型（int/string/结构体集合为值类型）和引用类型(泛型集合为引用类型)：自定义类泛型集合类型是引用类型。将自定义类改为自定义结构体，从而变成值类型，以便备份数据。

最新推荐文章于 2020-05-06 15:21:05 发布

我爱AI

最新推荐文章于 2020-05-06 15:21:05 发布

阅读量1k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： ---------- 【C#.基础】

本文链接：https://blog.youkuaiyun.com/xpj8888/article/details/88101984

---------- 【C#.基础】专栏收录该内容

48 篇文章

订阅专栏

本文深入探讨了C#中的值类型与引用类型的区别，包括它们的定义、内存分配方式、适用场合及如何正确选择使用。通过代码示例，详细解释了两者在内存中的部署差异，以及它们对程序性能的影响。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、问题

执行PatientInfoList.Clear()后，operateDataSheet.GetPatientInfoFunc()中的patientInfoHistroryModel也跟着清零。

所以，我不得不提出疑问，我那个两个类的类型，到底是值类型，还是应用类型？？？？？？？？？？？？？？

if (operateDataSheet.GetPatientInfoFunc().Count > 0)
{
    int a = operateDataSheet.GetPatientInfoFunc().Count;
    PatientInfoList.Clear();
    int b = operateDataSheet.GetPatientInfoFunc().Count;
    int c = operateDataSheet.GetPatientInfoFunc().Count;
    PatientInfoList = operateDataSheet.GetPatientInfoFunc();
}

patientInfoHistroryModel集合表示如下：

        private List<PatientInfoHistroryModel> patientInfoList = new List<PatientInfoHistroryModel>();

        /// <summary>
        /// 患者信息列表
        /// </summary>
        public List<PatientInfoHistroryModel> PatientInfoList
        {
            get { return patientInfoList; }
            set { SetProperty(ref patientInfoList, value); }
        }

patientInfoHistroryModel集合及其返回值表示如下：

 //病人信息列表
List<PatientInfoHistroryModel> patientInfoHistroryModel = new List<PatientInfoHistroryModel>();

        public List<PatientInfoHistroryModel> GetPatientInfoFunc()
        {  
            return patientInfoHistroryModel;
        }

二、别人也遇到了同样的问题

泛型集合是数据，是存放在对堆当中。

https://blog.youkuaiyun.com/u014761139/article/details/69372342

https://www.cnblogs.com/qixinbo/p/6961125.html

三、解决办法

1、采用结构体，可以备份数据，如下所示：

2、foreach 拷贝

四、举个典型的例子说明引用类型/值类型


#region 值类型和应用类型
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Messaging;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;
namespace test
{

    public class ClassValue
    {
        public int a;
        public int b;
        public string str1;
        public string str2;
    }
    class Program
    {
        static void Main(string[] args)
        {

            #region 一、自定义泛型集合是属于引用类型
            List<ClassValue> List1 = new List<ClassValue>();
            List<ClassValue> List2 = new List<ClassValue>();

            //分别赋值
            List1.Add(new ClassValue { a = 100, b = 200, str1 = "aaaa", str2 = "bbbb" });
            List2 = List1;
            //List2 = new List<ClassValue>();
            //List2.AddRange(List1);
            //Array.Copy(List1.ToArray(), List2.ToArray(), 1);

            //直接输出
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine("-------------------直接输出------------------");
            Console.WriteLine("a = {0}, b = {1}, str1 = {2}, str2 = {3}", List1[0].a, List1[0].b, List1[0].str1, List1[0].str2);
            Console.WriteLine("a = {0}, b = {1}, str1 = {2}, str2 = {3}", List2[0].a, List2[0].b, List2[0].str1, List2[0].str2);

            //我们现在来改变List1，看看List2是否也跟着改变
            List1[0].a = 111;
            List1[0].str1 = "ljflaj";
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine("-------------------改变List1，List2也改变------------------");
            Console.WriteLine("a = {0}, b = {1}, str1 = {2}, str2 = {3}", List1[0].a, List1[0].b, List1[0].str1, List1[0].str2);
            Console.WriteLine("a = {0}, b = {1}, str1 = {2}, str2 = {3}", List2[0].a, List2[0].b, List2[0].str1, List2[0].str2);

            //我们现在来改变List2，看看List1是否也跟着改变
            List2[0].a = 12121212;
            List2[0].str1 = "我我我";
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine("-------------------改变List2，List1也改变------------------");
            Console.WriteLine("a = {0}, b = {1}, str1 = {2}, str2 = {3}", List1[0].a, List1[0].b, List1[0].str1, List1[0].str2);
            Console.WriteLine("a = {0}, b = {1}, str1 = {2}, str2 = {3}", List2[0].a, List2[0].b, List2[0].str1, List2[0].str2);
            #endregion

            #region 二、字符串List集合是属于值类型
            List<string> stringList1 = new List<string>();
            List<string> stringList2 = new List<string>();
            //赋值
            stringList1.Add("AAA");
            stringList1.Add("BBB");

            stringList2.Add("AAA");
            stringList2.Add("BBB");
            //输出
            Console.WriteLine("-------------------直接输出------------------");
            Console.WriteLine("字符串1 = {0}, 字符串2 = {1}", stringList1[0], stringList1[1]);
            Console.WriteLine("字符串1 = {0}, 字符串2 = {1}", stringList2[0], stringList2[1]);

            //我们现在来改变stringList1，看看stringList2是否也跟着改变
            stringList1[0] = "--***111";
            Console.WriteLine("");
            Console.WriteLine("-------------------改变stringList1，stringList2不会改变------------------");
            Console.WriteLine("字符串1 = {0}, 字符串2 = {1}", stringList1[0], stringList1[1]);
            Console.WriteLine("字符串1 = {0}, 字符串2 = {1}", stringList2[0], stringList2[1]);
            #endregion

            #region 三、字符串集合是属于值类型
            string[] str1 = { "111", "222" };
            string[] str2 = { "111", "222" };

            //输出
            Console.WriteLine();
            Console.WriteLine("-------------------直接输出------------------");
            Console.WriteLine("字符串1 = {0}, 字符串2 = {1}", str1[0], str1[1]);
            Console.WriteLine("字符串1 = {0}, 字符串2 = {1}", str2[0], str2[1]);

            //我们现在来改变str1，看看str2是否也跟着改变
            str1[0] = "--***111";
            Console.WriteLine("");
            Console.WriteLine("-------------------改变str1，str2不会改变------------------");
            Console.WriteLine("字符串1 = {0}, 字符串2 = {1}", str1[0], str1[1]);
            Console.WriteLine("字符串1 = {0}, 字符串2 = {1}", str2[0], str2[1]);
            #endregion

            #region 四、int集合是属于值类型
            int[] int1 = { 100, 200 };
            int[] int2 = { 100, 200 };

            //输出
            Console.WriteLine();
            Console.WriteLine("-------------------直接输出------------------");
            Console.WriteLine("整数1 = {0}, 整数2 = {1}", int1[0], int1[1]);
            Console.WriteLine("整数1 = {0}, 整数2 = {1}", int2[0], int2[1]);

            //我们现在来改变int1，看看int2是否也跟着改变
            int1[0] = 111;
            Console.WriteLine("");
            Console.WriteLine("-------------------改变int1，int2不会改变------------------");
            Console.WriteLine("整数1 = {0}, 整数2 = {1}", int1[0], int1[1]);
            Console.WriteLine("整数1 = {0}, 整数2 = {1}", int2[0], int2[1]);
            #endregion

            #region 五、new int[]集合是属于值类型
            int[] int11 = new int[] { 100, 200 };
            int[] int22 = new int[] { 100, 200 };

            //输出
            Console.WriteLine();
            Console.WriteLine("-------------------直接输出------------------");
            Console.WriteLine("整数1 = {0}, 整数2 = {1}", int11[0], int11[1]);
            Console.WriteLine("整数1 = {0}, 整数2 = {1}", int22[0], int22[1]);

            //我们现在来改变int1，看看int2是否也跟着改变
            int11[0] = 111;
            Console.WriteLine("");
            Console.WriteLine("-------------------改变int11，int22不会改变------------------");
            Console.WriteLine("整数1 = {0}, 整数2 = {1}", int11[0], int11[1]);
            Console.WriteLine("整数1 = {0}, 整数2 = {1}", int22[0], int22[1]);
            #endregion
            Console.ReadLine();
        }   
    }
}
#endregion

输出：



-------------------直接输出------------------
a = 100, b = 200, str1 = aaaa, str2 = bbbb
a = 100, b = 200, str1 = aaaa, str2 = bbbb


-------------------改变List1，List2也改变------------------
a = 111, b = 200, str1 = ljflaj, str2 = bbbb
a = 111, b = 200, str1 = ljflaj, str2 = bbbb


-------------------改变List2，List1也改变------------------
a = 12121212, b = 200, str1 = 我我我, str2 = bbbb
a = 12121212, b = 200, str1 = 我我我, str2 = bbbb
-------------------直接输出------------------
字符串1 = AAA, 字符串2 = BBB
字符串1 = AAA, 字符串2 = BBB

-------------------改变stringList1，stringList2不会改变------------------
字符串1 = --***111, 字符串2 = BBB
字符串1 = AAA, 字符串2 = BBB

-------------------直接输出------------------
字符串1 = 111, 字符串2 = 222
字符串1 = 111, 字符串2 = 222

-------------------改变str1，str2不会改变------------------
字符串1 = --***111, 字符串2 = 222
字符串1 = 111, 字符串2 = 222

-------------------直接输出------------------
整数1 = 100, 整数2 = 200
整数1 = 100, 整数2 = 200

-------------------改变int1，int2不会改变------------------
整数1 = 111, 整数2 = 200
整数1 = 100, 整数2 = 200

-------------------直接输出------------------
整数1 = 100, 整数2 = 200
整数1 = 100, 整数2 = 200

-------------------改变int11，int22不会改变------------------
整数1 = 111, 整数2 = 200
整数1 = 100, 整数2 = 200

五、值类型和引用类型的原理

转：https://www.cnblogs.com/bakuhert/articles/5878086.html

什么是值类型，什么是引用类型

概念：值类型直接存储其值，而引用类型存储对其值的引用。部署：托管堆上部署了所有引用类型。

引用类型：基类为Objcet

值类型：均隐式派生自System.ValueType：

值类型：	byte，short，int，long，float，double，decimal，char，bool 和 struct 统称为值类型。
引用类型：	string 和 class统称为引用类型。

值类型变量声明后，不管是否已经赋值，编译器为其分配内存。
引用类型当声明一个类时，只在栈中分配一小片内存用于容纳一个地址，而此时并没有为其分配堆上的内存空间。当使用 new 创建一个类的实例时，分配堆上的空间，并把堆上空间的地址保存到栈上分配的小片空间中。
值类型的实例通常是在线程栈上分配的（静态分配），但是在某些情形下可以存储在堆中。
引用类型的对象总是在进程堆中分配（动态分配）。

我们来看下面一段代码：

输出结果：

值类型在栈内分配空间大小因变量类型而异；

引用类型在栈内的空间大小相同；

1. 通用类型系统

C#中，变量是值还是引用仅取决于其数据类型。

C#的基本数据类型都以平台无关的方式来定义。C#的预定义类型并没有内置于语言中，而是内置于.NET Framework中。.NET使用通用类型系统（CTS）定义了可以在中间语言（IL）中使用的预定义数据类型，所有面向.NET的语言都最终被编译为IL，即编译为基于CTS类型的代码。

例如，在C#中声明一个int变量时，声明的实际上是CTS中System.Int32的一个实例。这具有重要的意义：

确保IL上的强制类型安全；
实现了不同.NET语言的互操作性；
所有的数据类型都是对象。它们可以有方法，属性，等。例如：

int i;

i = 1;

string s;

s = i.ToString();

以下关系图（来自MSDN）说明了这几种类型是如何相关的。注意，类型的实例可以只是值类型或自描述类型，即使这些类型有子类别也是如此。

类型类别：

2.值类型

C#的所有值类型均隐式派生自System.ValueType：

结构体：struct（直接派生于System.ValueType）；

数值类型：

整型：sbyte（System.SByte的别名），short（System.Int16），int（System.Int32），long（System.Int64），byte（System.Byte），ushort（System.UInt16），uint（System.UInt32），ulong（System.UInt64），char（System.Char）；

浮点型：float（System.Single），double（System.Double）；

用于财务计算的高精度decimal型：decimal（System.Decimal）。

bool型：bool（System.Boolean的别名）；

用户定义的结构体（派生于System.ValueType）。

枚举：enum（派生于System.Enum）；

可空类型（派生于System.Nullable<T>泛型结构体，T?实际上是System.Nullable<T>的别名）。

每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值。例如：

int i = new int();

等价于：

Int32 i = new Int32();

等价于：

int i = 0;

等价于：

Int32 i = 0;

引用类型和值类型都继承自System.Object类。不同的是，几乎所有的引用类型都直接从System.Object继承，而值类型则继承其子类，即直接继承System.ValueType。System.ValueType直接派生于System.Object。即System.ValueType本身是一个类类型，而不是值类型。其关键在于ValueType重写了Equals()方法，从而对值类型按照实例的值来比较，而不是引用地址来比较。

可以用Type.IsValueType属性来判断一个类型是否为值类型：

TestType testType = new TestType ();

if (testTypetype.GetType().IsValueType)

{

Console.WriteLine("{0} is value type.", testType.ToString());

}

3.引用类型

C#有以下一些引用类型：

数组（派生于System.Array）

用户用定义的以下类型：

类：class（派生于System.Object）；

接口：interface（接口不是一个“东西”，所以不存在派生于何处的问题。Anders在《C# Programming Language》中说，接口只是表示一种约定[contract]）；

委托：delegate（派生于System.Delegate）。

object（System.Object的别名）；

字符串：string（System.String的别名）。

可以看出：

引用类型与值类型相同的是，结构体也可以实现接口；

引用类型可以派生出新的类型，而值类型不能；

引用类型可以包含null值，值类型不能（可空类型功能允许将 null 赋给值类型）；

引用类型变量的赋值只复制对对象的引用，而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时，将复制包含的值。

对于最后一条，经常混淆的是string。我曾经在一本书的一个早期版本上看到String变量比string变量效率高；我还经常听说String是引用类型，string是值类型，等等。例如：

string s1 = "Hello, ";

string s2 = "world!";

string s3 = s1 + s2;//s3 is "Hello, world!"

这确实看起来像一个值类型的赋值。再如：

string s1 = "a";

string s2 = s1;

s1 = "b";//s2 is still "a"

改变s1的值对s2没有影响。这更使string看起来像值类型。实际上，这是运算符重载的结果，当s1被改变时，.NET在托管堆上为s1重新分配了内存。这样的目的，是为了将做为引用类型的string实现为通常语义下的字符串。

4. 值类型和引用类型在内存中的部署

经常听说，并且经常在书上看到：值类型部署在栈上，引用类型部署在托管堆上。实际上并没有这么简单。

MSDN上说：托管堆上部署了所有引用类型。这很容易理解。当创建一个应用类型变量时：

object reference = new object();

关键字new将在托管堆上分配内存空间，并返回一个该内存空间的地址。左边的reference位于栈上，是一个引用，存储着一个内存地址；而这个地址指向的内存（位于托管堆）里存储着其内容（一个System.Object的实例）。下面为了方便，简称引用类型部署在托管推上。

再来看值类型。《C#语言规范》上的措辞是“结构体不要求在堆上分配内存（However, unlike classes, structs are value types and do not require heap allocation）”而不是“结构体在栈上分配内存”。这不免容易让人感到困惑：值类型究竟部署在什么地方？

4.1数组

考虑数组：

int[] reference = new int[100];

根据定义，数组都是引用类型，所以int数组当然是引用类型（即reference.GetType().IsValueType为false）。

而int数组的元素都是int，根据定义，int是值类型（即reference[i].GetType().IsValueType为true）。那么引用类型数组中的值类型元素究竟位于栈还是堆？

如果用WinDbg去看reference[i]在内存中的具体位置，就会发现它们并不在栈上，而是在托管堆上。

实际上，对于数组：

TestType[] testTypes = new TestType[100];

如果TestType是值类型，则会一次在托管堆上为100个值类型的元素分配存储空间，并自动初始化这100个元素，将这100个元素存储到这块内存里。

如果TestType是引用类型，则会先在托管堆为testTypes分配一次空间，并且这时不会自动初始化任何元素（即testTypes[i]均为null）。等到以后有代码初始化某个元素的时候，这个引用类型元素的存储空间才会被分配在托管堆上。

4.2类型嵌套

引用类型部署在托管堆上；

值类型总是分配在它声明的地方：作为字段时，跟随其所属的变量（实例）存储；作为局部变量时，存储在栈上。

从上下文看，mc是一个局部变量，所以部署在托管堆上，并被栈上的一个引用所持有；

值类型字段_value1属于引用类型实例mc的一部分，所以跟随引用类型实例mc部署在托管堆上（有点类似于数组的情形）；

value2是值类型局部变量，所以部署在栈上。

而对于值类型实例，即MyStruct：

根据上下文，值类型实例ms本身是一个局部变量而不是字段，所以位于栈上；

其引用类型字段_object1不存在跟随的问题，必然部署在托管堆上，并被一个引用所持有（该引用是ms的一部分，位于栈）；

其引用类型局部变量_object2显然部署在托管堆上，并被一个位于栈的引用所持有。

所以，简单地说“值类型存储在栈上，引用类型存储在托管堆上”是不对的。必须具体情况具体分析

在C#中，我们用struct/class来声明一个类型为值类型/引用类型。考虑下面的例子：

SomeType[] oneTypes = new SomeType[100];

如果SomeType是值类型，则只需要一次分配，大小为SomeType的100倍。而如果SomeType是引用类型，刚开始需要100次分配，分配后数组的各元素值为null，然后再初始化100个元素，结果总共需要进行101次分配。这将消耗更多的时间，造成更多的内存碎片。所以，如果类型的职责主要是存储数据，值类型比较合适。

一般来说，值类型（不支持多态）适合存储供 C#应用程序操作的数据，而引用类型（支持多态）应该用于定义应用程序的行为。通常我们创建的引用类型总是多于值类型。如果满足下面情况，那么我们就应该创建为值类型：

该类型的主要职责用于数据存储。

该类型的共有接口完全由一些数据成员存取属性定义。

该类型永远不可能有子类。

该类型不具有多态行为。

5. 辨明值类型和引用类型的使用场合

在C#中，我们用struct/class来声明一个类型为值类型/引用类型。考虑下面的例子：

SomeType[] oneTypes = new SomeType[100];

该类型的主要职责用于数据存储。

该类型的共有接口完全由一些数据成员存取属性定义。

该类型永远不可能有子类。

该类型不具有多态行为。

值类型和引用类型的区别（小结）

相同点：

引用类型可以实现接口，值类型当中的结构体也可以实现接口；

引用类型和值类型都继承自System.Object类。

1）范围方面

C#的值类型包括：结构体（数值类型、bool型、用户定义的结构体），枚举，可空类型。

C#的引用类型包括：数组，用户定义的类、接口、委托，object，字符串。

2）内存分配方面：

数组的元素不管是引用类型还是值类型，都存储在托管堆上。

引用类型在栈中存储一个引用，其实际的存储位置位于托管堆。简称引用类型部署在托管推上。而值类型总是分配在它声明的地方：作为字段时，跟随其所属的变量（实例）存储；作为局部变量时，存储在栈上。（栈的内存是自动释放的，堆内存是.NET中会由GC来自动释放）

3）适用场合

值类型在内存管理方面具有更好的效率，并且不支持多态，适合用做存储数据的载体；引用类型支持多态，适合用于定义应用程序的行为。

引用类型可以派生出新的类型，而值类型不能，因为所有的值类型都是密封（seal）的；

引用类型可以包含null值，值类型不能（可空类型功能允许将 null 赋给值类型，如 int? a = null; ）；

引用类型变量的赋值只复制对对象的引用，而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时，将复制包含的值。

值得注意的是，引用类型和值类型都继承自System.Object类。不同的是，几乎所有的引用类型都直接从System.Object继承，而值类型则继承其子类，即直接继承System.ValueType。即System.ValueType本身是一个类类型，而不是值类型。其关键在于ValueType重写了Equals()方法，从而对值类型按照实例的值来比较，而不是引用地址来比较。

内容参考来自文章：

值类型和引用类型，栈和堆的含义

通用类型系统概述

C#详解值类型和引用类型区别