.NET中的结构和类有什么区别？
当前回答
首先，结构是通过值而不是引用传递的。结构适用于相对简单的数据结构，而类通过多态性和继承从体系结构的角度来看具有更大的灵活性。
其他人可能会比我给你更多的细节，但当我所追求的结构很简单时，我会使用结构。
其他回答
除了其他答案之外，还有一个基本的区别值得注意，那就是数据如何存储在数组中，因为这会对性能产生重大影响。
对于结构，数组包含结构的实例对于类，数组包含指向内存中其他位置的类实例的指针
因此，内存中的结构数组如下所示
[结构][结构]〔结构〕〔结构〕
而类数组看起来像这样
指针
对于一个类数组，您感兴趣的值不会存储在数组中，而是存储在内存的其他位置。
对于绝大多数应用程序来说，这种差异并不重要，但是，在高性能代码中，这将影响内存中数据的位置，并对CPU缓存的性能产生很大影响。在可以/应该使用结构的情况下使用类将大大增加CPU上的缓存未命中数。
现代CPU做的最慢的事情不是处理数字，而是从内存中提取数据，一级缓存命中速度比从RAM读取数据快很多倍。
下面是一些可以测试的代码。在我的机器上，遍历类数组所需的时间大约是结构数组的3倍。
private struct PerformanceStruct
{
public int i1;
public int i2;
}
private class PerformanceClass
{
public int i1;
public int i2;
}
private static void DoTest()
{
var structArray = new PerformanceStruct[100000000];
var classArray = new PerformanceClass[structArray.Length];
for (var i = 0; i < structArray.Length; i++)
{
structArray[i] = new PerformanceStruct();
classArray[i] = new PerformanceClass();
}
long total = 0;
var sw = new Stopwatch();
sw.Start();
for (var loops = 0; loops < 100; loops++)
for (var i = 0; i < structArray.Length; i++)
{
total += structArray[i].i1 + structArray[i].i2;
}
sw.Stop();
Console.WriteLine($"Struct Time: {sw.ElapsedMilliseconds}");
sw = new Stopwatch();
sw.Start();
for (var loops = 0; loops < 100; loops++)
for (var i = 0; i < classArray.Length; i++)
{
total += classArray[i].i1 + classArray[i].i2;
}
Console.WriteLine($"Class Time: {sw.ElapsedMilliseconds}");
}
有一个有趣的“类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;
}
}
}
}
基元值类型或结构类型的每个变量或字段都持有该类型的唯一实例，包括其所有字段（公共和私有）。相比之下，引用类型的变量或字段可能为空，或者可能引用存储在其他位置的对象，其他引用也可能存在。结构的字段将存储在与该结构类型的变量或字段相同的位置，该变量或字段可能位于堆栈上，也可能是另一个堆对象的一部分。
创建原始值类型的变量或字段将使用默认值创建它；创建结构类型的变量或字段将创建一个新实例，以默认方式创建其中的所有字段。创建引用类型的新实例将首先以默认方式创建其中的所有字段，然后根据类型运行可选的附加代码。
将一个基本类型的变量或字段复制到另一个将复制值。将结构类型的一个变量或字段复制到另一个变量将前一个实例的所有字段（公共和私有）复制到后一个实例。将一个引用类型的变量或字段复制到另一个将导致后者引用与前者相同的实例（如果有的话）。
需要注意的是，在某些语言（如C++）中，类型的语义行为与它的存储方式无关，但在.NET中则不是这样。如果一个类型实现了可变值语义，则将该类型的一个变量复制到另一个变量会将第一个实例的财产复制到第二个实例所引用的另一个实例，并且使用第二个实例的成员来变异它将导致第二个例子被改变，而不是第一个。如果一个类型实现了可变的引用语义，那么将一个变量复制到另一个变量并使用第二个变量的成员来变异对象将影响第一个变量所引用的对象；具有不可变语义的类型不允许变异，因此复制是创建新实例还是创建对第一个实例的另一个引用在语义上无关紧要。
在.NET中，值类型可以实现上述任何语义，前提是它们的所有字段都可以这样做。然而，引用类型只能实现可变引用语义或不可变语义；具有可变引用类型字段的值类型限于实现可变引用语义或奇怪的混合语义。
如前所述：类是引用类型，而结构是具有所有后果的值类型。
根据经验，框架设计指南建议在以下情况下使用结构而不是类：
它的实例大小小于16字节它逻辑上表示单个值，类似于原始类型（int、double等）它是不可变的它不必经常装箱
| Struct | Class | |
|---|---|---|
| Type | Value-type | Reference-type |
| Where | On stack / Inline in containing type | On Heap |
| Deallocation | Stack unwinds / containing type gets deallocated | Garbage Collected |
| Arrays | Inline, elements are the actual instances of the value type | Out of line, elements are just references to instances of the reference type residing on the heap |
| Al-Del Cost | Cheap allocation-deallocation | Expensive allocation-deallocation |
| Memory usage | Boxed when cast to a reference type or one of the interfaces they implement, Unboxed when cast back to value type (Negative impact because boxes are objects that are allocated on the heap and are garbage-collected) |
No boxing-unboxing |
| Assignments | Copy entire data | Copy the reference |
| Change to an instance | Does not affect any of its copies | Affect all references pointing to the instance |
| Mutability | Should be immutable | Mutable |
| Population | In some situations | Majority of types in a framework should be classes |
| Lifetime | Short-lived | Long-lived |
| Destructor | Cannot have | Can have |
| Inheritance | Only from an interface | Full support |
| Polymorphism | No | Yes |
| Sealed | Yes | When have sealed keyword (C#), or Sealed attribute (F#) |
| Constructor | Can not have explicit parameterless constructors | Any constructor |
| Null-assignments | When marked with nullable question mark | Yes (When marked with nullable question mark in C# 8+ and F# 5+ 1) |
| Abstract | No | When have abstract keyword (C#), or AbstractClass attribute (F#) |
| Member Access Modifiers | public, private, internal |
public, protected, internal, protected internal, private protected |
1不鼓励在F#中使用null，请改用Option类型。
推荐文章
- 流。Seek(0, SeekOrigin.Begin)或Position = 0
- 如果查询为空，则最大返回值
- 如何初始化静态变量
- 传递一个实例化的系统。类型作为泛型类的类型参数
- 在c#中转换字符串为类型
- 替换c#字符串中的多个字符
- 在Java中创建对象数组
- .NET中的闭包是什么?
- 连接网络共享时，如何提供用户名和密码
- 重新定位解决方案从。net 4.0到4.5 -如何重新定位NuGet包?
- CultureInfo。InvariantCulture意味着什么?
- 如何将linq结果转换为哈希集或哈希集
- 'useLegacyV2RuntimeActivationPolicy'在.NET 4配置中做什么?
- HTTP POST返回错误:417“期望失败。”
- 为什么Path。以Path.DirectorySeparatorChar开头的文件名合并不正确?
