.NET中的结构和类有什么区别？
当前回答
类的实例存储在托管堆上。“包含”实例的所有变量都只是对堆上实例的引用。将对象传递给方法会导致传递引用的副本，而不是对象本身。
结构（从技术上讲，值类型）存储在使用它们的任何地方，很像原始类型。运行时可以随时复制内容，而无需调用自定义的复制构造函数。将值类型传递给方法涉及复制整个值，同样无需调用任何自定义代码。
C++/CLI名称使这种区别更加明显：“ref class”是第一个类，“value class”是第二个类。C#使用的关键字“class”和“struct”只是必须学习的东西。
其他回答
结构是实际值-它们可以为空，但不能为空
这是正确的，但是也要注意，从.NET2开始，结构支持Nullable版本，C#提供了一些语法糖，使其更易于使用。
int? value = null;
value = 1;
有一个有趣的“类vs结构”难题案例——当您需要从方法返回几个结果时：选择要使用的结果。如果你知道ValueTuple的故事，你就知道添加ValueTuple（结构）是因为它应该比Tuple（类）更有效。但这在数字上意味着什么？两个测试：一个是具有2个字段的结构/类，另一个是有8个字段的类型/类（维度大于4-从处理器节拍的角度来看，类应该比结构更有效，但当然也应该考虑GC负载）。
P.S.另一个特定案例“stuct or class with collections”的基准是：https://stackoverflow.com/a/45276657/506147
BenchmarkDotNet=v0.10.10, OS=Windows 10 Redstone 2 [1703, Creators Update] (10.0.15063.726)
Processor=Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount=4
Frequency=3233540 Hz, Resolution=309.2586 ns, Timer=TSC
.NET Core SDK=2.0.3
[Host] : .NET Core 2.0.3 (Framework 4.6.25815.02), 64bit RyuJIT
Clr : .NET Framework 4.7 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.2115.0
Core : .NET Core 2.0.3 (Framework 4.6.25815.02), 64bit RyuJIT
Method | Job | Runtime | Mean | Error | StdDev | Min | Max | Median | Rank | Gen 0 | Allocated |
------------------ |----- |-------- |---------:|----------:|----------:|---------:|---------:|---------:|-----:|-------:|----------:|
TestStructReturn | Clr | Clr | 17.57 ns | 0.1960 ns | 0.1834 ns | 17.25 ns | 17.89 ns | 17.55 ns | 4 | 0.0127 | 40 B |
TestClassReturn | Clr | Clr | 21.93 ns | 0.4554 ns | 0.5244 ns | 21.17 ns | 23.26 ns | 21.86 ns | 5 | 0.0229 | 72 B |
TestStructReturn8 | Clr | Clr | 38.99 ns | 0.8302 ns | 1.4097 ns | 37.36 ns | 42.35 ns | 38.50 ns | 8 | 0.0127 | 40 B |
TestClassReturn8 | Clr | Clr | 23.69 ns | 0.5373 ns | 0.6987 ns | 22.70 ns | 25.24 ns | 23.37 ns | 6 | 0.0305 | 96 B |
TestStructReturn | Core | Core | 12.28 ns | 0.1882 ns | 0.1760 ns | 11.92 ns | 12.57 ns | 12.30 ns | 1 | 0.0127 | 40 B |
TestClassReturn | Core | Core | 15.33 ns | 0.4343 ns | 0.4063 ns | 14.83 ns | 16.44 ns | 15.31 ns | 2 | 0.0229 | 72 B |
TestStructReturn8 | Core | Core | 34.11 ns | 0.7089 ns | 1.4954 ns | 31.52 ns | 36.81 ns | 34.03 ns | 7 | 0.0127 | 40 B |
TestClassReturn8 | Core | Core | 17.04 ns | 0.2299 ns | 0.2150 ns | 16.68 ns | 17.41 ns | 16.98 ns | 3 | 0.0305 | 96 B |
代码测试：
using System;
using System.Text;
using System.Collections.Generic;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Attributes.Columns;
using BenchmarkDotNet.Attributes.Exporters;
using BenchmarkDotNet.Attributes.Jobs;
using DashboardCode.Routines.Json;
namespace Benchmark
{
//[Config(typeof(MyManualConfig))]
[RankColumn, MinColumn, MaxColumn, StdDevColumn, MedianColumn]
[ClrJob, CoreJob]
[HtmlExporter, MarkdownExporter]
[MemoryDiagnoser]
public class BenchmarkStructOrClass
{
static TestStruct testStruct = new TestStruct();
static TestClass testClass = new TestClass();
static TestStruct8 testStruct8 = new TestStruct8();
static TestClass8 testClass8 = new TestClass8();
[Benchmark]
public void TestStructReturn()
{
testStruct.TestMethod();
}
[Benchmark]
public void TestClassReturn()
{
testClass.TestMethod();
}
[Benchmark]
public void TestStructReturn8()
{
testStruct8.TestMethod();
}
[Benchmark]
public void TestClassReturn8()
{
testClass8.TestMethod();
}
public class TestStruct
{
public int Number = 5;
public struct StructType<T>
{
public T Instance;
public List<string> List;
}
public int TestMethod()
{
var s = Method1(1);
return s.Instance;
}
private StructType<int> Method1(int i)
{
return Method2(++i);
}
private StructType<int> Method2(int i)
{
return Method3(++i);
}
private StructType<int> Method3(int i)
{
return Method4(++i);
}
private StructType<int> Method4(int i)
{
var x = new StructType<int>();
x.List = new List<string>();
x.Instance = ++i;
return x;
}
}
public class TestClass
{
public int Number = 5;
public class ClassType<T>
{
public T Instance;
public List<string> List;
}
public int TestMethod()
{
var s = Method1(1);
return s.Instance;
}
private ClassType<int> Method1(int i)
{
return Method2(++i);
}
private ClassType<int> Method2(int i)
{
return Method3(++i);
}
private ClassType<int> Method3(int i)
{
return Method4(++i);
}
private ClassType<int> Method4(int i)
{
var x = new ClassType<int>();
x.List = new List<string>();
x.Instance = ++i;
return x;
}
}
public class TestStruct8
{
public int Number = 5;
public struct StructType<T>
{
public T Instance1;
public T Instance2;
public T Instance3;
public T Instance4;
public T Instance5;
public T Instance6;
public T Instance7;
public List<string> List;
}
public int TestMethod()
{
var s = Method1(1);
return s.Instance1;
}
private StructType<int> Method1(int i)
{
return Method2(++i);
}
private StructType<int> Method2(int i)
{
return Method3(++i);
}
private StructType<int> Method3(int i)
{
return Method4(++i);
}
private StructType<int> Method4(int i)
{
var x = new StructType<int>();
x.List = new List<string>();
x.Instance1 = ++i;
return x;
}
}
public class TestClass8
{
public int Number = 5;
public class ClassType<T>
{
public T Instance1;
public T Instance2;
public T Instance3;
public T Instance4;
public T Instance5;
public T Instance6;
public T Instance7;
public List<string> List;
}
public int TestMethod()
{
var s = Method1(1);
return s.Instance1;
}
private ClassType<int> Method1(int i)
{
return Method2(++i);
}
private ClassType<int> Method2(int i)
{
return Method3(++i);
}
private ClassType<int> Method3(int i)
{
return Method4(++i);
}
private ClassType<int> Method4(int i)
{
var x = new ClassType<int>();
x.List = new List<string>();
x.Instance1 = ++i;
return x;
}
}
}
}
除了其他答案中描述的所有差异外：
结构不能具有显式无参数构造函数，而类可以结构不能有析构函数，而类可以结构不能从其他结构或类继承，而类可以从其他类继承。（结构和类都可以从接口实现。）
如果您正在观看一段视频，解释所有的差异，您可以查看第29部分-C#教程-C#中类和结构之间的差异。
类的实例存储在托管堆上。“包含”实例的所有变量都只是对堆上实例的引用。将对象传递给方法会导致传递引用的副本，而不是对象本身。
结构（从技术上讲，值类型）存储在使用它们的任何地方，很像原始类型。运行时可以随时复制内容，而无需调用自定义的复制构造函数。将值类型传递给方法涉及复制整个值，同样无需调用任何自定义代码。
C++/CLI名称使这种区别更加明显：“ref class”是第一个类，“value class”是第二个类。C#使用的关键字“class”和“struct”只是必须学习的东西。
基元值类型或结构类型的每个变量或字段都持有该类型的唯一实例，包括其所有字段（公共和私有）。相比之下，引用类型的变量或字段可能为空，或者可能引用存储在其他位置的对象，其他引用也可能存在。结构的字段将存储在与该结构类型的变量或字段相同的位置，该变量或字段可能位于堆栈上，也可能是另一个堆对象的一部分。
创建原始值类型的变量或字段将使用默认值创建它；创建结构类型的变量或字段将创建一个新实例，以默认方式创建其中的所有字段。创建引用类型的新实例将首先以默认方式创建其中的所有字段，然后根据类型运行可选的附加代码。
将一个基本类型的变量或字段复制到另一个将复制值。将结构类型的一个变量或字段复制到另一个变量将前一个实例的所有字段（公共和私有）复制到后一个实例。将一个引用类型的变量或字段复制到另一个将导致后者引用与前者相同的实例（如果有的话）。
需要注意的是，在某些语言（如C++）中，类型的语义行为与它的存储方式无关，但在.NET中则不是这样。如果一个类型实现了可变值语义，则将该类型的一个变量复制到另一个变量会将第一个实例的财产复制到第二个实例所引用的另一个实例，并且使用第二个实例的成员来变异它将导致第二个例子被改变，而不是第一个。如果一个类型实现了可变的引用语义，那么将一个变量复制到另一个变量并使用第二个变量的成员来变异对象将影响第一个变量所引用的对象；具有不可变语义的类型不允许变异，因此复制是创建新实例还是创建对第一个实例的另一个引用在语义上无关紧要。
在.NET中，值类型可以实现上述任何语义，前提是它们的所有字段都可以这样做。然而，引用类型只能实现可变引用语义或不可变语义；具有可变引用类型字段的值类型限于实现可变引用语义或奇怪的混合语义。
推荐文章
- AutoMapper:“忽略剩下的?”
- 如何找出一个文件存在于c# / .NET?
- string. isnullorempty (string) vs. string. isnullowhitespace (string)
- 完全外部连接
- 如何使用。net 4运行时运行PowerShell ?
- 在foreach循环中编辑字典值
- 使用System.IO.Compression在内存中创建ZIP存档
- 在WPF中引入一个窗口到前面
- .NET用固定的空格格式化字符串
- 我如何获得和设置环境变量在c# ?
- Linq风格的“For Each”
- 我如何得到一个动画gif在WPF工作?
- 什么时候使用记录、类和结构
- 获取程序集名称
- “\n”与“Environment”的区别。换行符
