什么时候应该在C#中使用struct而不是class？我的概念模型是当项只是值类型的集合时使用结构.一种逻辑上将它们组合在一起形成一个有凝聚力的整体的方法.
我在这里遇到了这些规则:
这些规则有效吗？结构在语义上意味着什么？
IAb*_*act 590
OP引用的来源具有一定的可信度......但是微软怎么样 - 结构使用的立场是什么？我从微软那里寻求了一些额外的学习,这就是我发现的:
如果类型的实例很小并且通常是短暂的或者通常嵌入在其他对象中,则考虑定义结构而不是类.
除非类型具有以下所有特征,否则不要定义结构:
- 它逻辑上表示单个值,类似于基本类型(整数,双精度等).
- 它的实例大小小于16个字节.
- 这是不可改变的.
- 它不必经常装箱.
好的,无论如何,#2和#3.我们心爱的字典有2个内部结构:
[StructLayout(LayoutKind.Sequential)] // default for structs
private struct Entry //<Tkey, TValue>
{
// View code at *Reference Source
}
[Serializable, StructLayout(LayoutKind.Sequential)]
public struct Enumerator :
IEnumerator<KeyValuePair<TKey, TValue>>, IDisposable,
IDictionaryEnumerator, IEnumerator
{
// View code at *Reference Source
}
'JonnyCantCode.com'来源获得了4分中的3分 - 相当可原谅,因为#4可能不会成为问题.如果你发现自己装了一个结构,重新考虑你的架构.
让我们看看为什么微软会使用这些结构:
Entry和Enumerator,代表单个值.Entry永远不会作为Dictionary类之外的参数传递.进一步的研究表明,为了满足IEnumerable的实现,Dictionary Enumerator每次使用枚举器时都使用它复制的结构......这是有意义的.Enumerator是公共的,因为Dictionary是可枚举的,并且必须具有与IEnumerator接口实现相同的可访问性 - 例如IEnumerator getter. 更新 - 此外,要意识到当一个struct实现一个接口 - 就像Enumerator那样 - 并且被强制转换为该实现的类型时,该struct将成为一个引用类型并被移动到堆中.内部的Dictionary类,枚举是仍然值类型.但是,只要方法调用GetEnumerator(),IEnumerator就会返回引用类型.
我们在这里看不到的任何尝试或证明要求保持结构不可变或维持实例大小只有16个字节或更少:
readonly- 不是一成不变的Entry具有不确定的寿命(从Add(),到Remove(),Clear()或垃圾收集);并且... 4.两个结构存储TKey和TValue,我们都知道它们很有能力作为参考类型(添加奖励信息)
尽管有散列键,但字典很快部分是因为实例化结构比引用类型更快.在这里,我有一个Dictionary<int, int>存储300,000个随机整数和顺序递增的键.
容量:312874
MemSize:2660827字节
已完成大小调整:5ms
总填充时间:889ms
容量:必须调整内部数组大小之前可用元素的数量.
MemSize:通过将字典序列化为MemoryStream并获得字节长度(对于我们的目的来说足够准确)来确定.
已完成调整大小:将内部数组从150862元素调整为312874元素所需的时间.当你想通过顺序复制每个元素时Array.CopyTo(),这不是太破旧.
填充的总时间:由于记录和OnResize我添加到源中的事件而导致的倾斜; 然而,在操作期间调整15次时,仍然令人印象深刻地填充300k整数.出于好奇,如果我已经知道容量,那么总的时间是多少？13毫秒
那么,现在,如果Entry是一个班级呢？这些时间或指标真的会有那么大差异吗？
容量:312874
MemSize:2660827字节
已完成大小调整:26ms
总填充时间:964ms
显然,最大的区别在于调整大小.如果使用容量初始化Dictionary,会有什么不同吗？不足以关注... 12ms.
会发生什么,因为它Entry是一个结构,它不需要像引用类型那样初始化.这既是价值类型的美丽又是祸根.为了Entry用作引用类型,我必须插入以下代码:
/*
* Added to satisfy initialization of entry elements --
* this is where the extra time is spent resizing the Entry array
* **/
for (int i = 0 ; i < prime ; i++)
{
destinationArray[i] = new Entry( );
}
/* *********************************************** */
我必须将每个数组元素初始化Entry为引用类型的原因可以在MSDN:Structure Design中找到.简而言之:
不要为结构提供默认构造函数.
如果结构定义了默认构造函数,则在创建结构的数组时,公共语言运行库会自动在每个数组元素上执行默认构造函数.
某些编译器(如C#编译器)不允许结构具有默认构造函数.
它实际上非常简单,我们将借用阿西莫夫的三机器人法则:
... 我们从中得到什么:简而言之,对价值类型的使用负责.它们快速有效,但如果维护不当(即无意复制),则有能力引发许多意外行为.
ILo*_*ran 144
我不同意原帖中给出的规则.这是我的规则:
1)存储在数组中时使用结构体来提高性能.(另见结构何时？)
2)您需要将代码传递给C/C++的结构化数据
3)除非您需要,否则不要使用结构:
Jos*_*rke 84
当您需要值语义而不是引用语义时,请使用结构.
不确定为什么大家都在贬低这一点,但这是一个有效的观点,并且在操作澄清他的问题之前做出,这是结构的最根本的基本原因.
如果需要引用语义,则需要一个类而不是结构.
Mar*_*ell 58
除了"它是一个值"的答案之外,使用结构的一个特定方案是,当您知道有一组导致垃圾收集问题的数据时,您有很多对象.例如,Person实例的大型列表/数组.这里的自然隐喻是一个类,但是如果你有大量长寿的Person实例,它们最终会堵塞GEN-2并导致GC停顿.如果场景保证,这里的一种可能的方法是使用Person 结构的数组(不是列表),即Person[].现在,不是在GEN-2中拥有数百万个对象,而是在LOH上有一个块(我假设这里没有字符串等 - 即没有任何引用的纯值).这对GC影响很小.
使用这些数据很尴尬,因为数据可能超出了结构的大小,并且您不希望一直复制胖值.但是,直接在数组中访问它不会复制结构 - 它就位(与列表索引器相比,它会复制).这意味着很多工作与索引:
int index = ...
int id = peopleArray[index].Id;
请注意,保持值本身不可变将有助于此处.对于更复杂的逻辑,请使用带有by-ref参数的方法:
void Foo(ref Person person) {...}
...
Foo(ref peopleArray[index]);
同样,这是就地 - 我们没有复制价值.
在非常具体的情况下,这种策略可以非常成功; 但是,只有当你知道自己在做什么以及为什么这样做时,它才是一个相当先进的scernario.这里的默认值是一个类.
bUK*_*eer 40
从C#语言规范:
1.7结构
与类一样,结构体是可以包含数据成员和函数成员的数据结构,但与类不同,结构体是值类型,不需要堆分配.结构类型的变量直接存储结构的数据,而类类型的变量存储对动态分配的对象的引用.结构类型不支持用户指定的继承,并且所有结构类型都隐式继承自类型对象.
结构对于具有值语义的小型数据结构特别有用.复数,坐标系中的点或字典中的键值对都是结构的好例子.对小型数据结构使用结构而不是类可以使应用程序执行的内存分配数量产生很大差异.例如,以下程序创建并初始化100个点的数组.将Point实现为类,实例化101个单独的对象 - 一个用于数组,一个用于100个元素.
class Point
{
public int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
class Test
{
static void Main() {
Point[] points = new Point[100];
for (int i = 0; i < 100; i++) points[i] = new Point(i, i);
}
}
另一种方法是使Point成为一个结构.
struct Point
{
public int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
现在,只实例化一个对象 - 数组的对象 - 并且Point实例以串联方式存储在数组中.
使用new运算符调用Struct构造函数,但这并不意味着正在分配内存.结构构造函数只是返回结构值本身(通常在堆栈的临时位置),而不是动态分配对象并返回对它的引用,然后根据需要复制该值.
对于类,两个变量可以引用同一个对象,因此对一个变量的操作可能会影响另一个变量引用的对象.对于结构体,每个变量都有自己的数据副本,并且一个变量不可能影响另一个变量.例如,由以下代码片段生成的输出取决于Point是类还是结构.
Point a = new Point(10, 10);
Point b = a;
a.x = 20;
Console.WriteLine(b.x);
如果Point是一个类,则输出为20,因为a和b引用同一个对象.如果Point是结构,则输出为10,因为a到b的赋值会创建值的副本,并且此副本不受后续分配到ax的影响
前面的例子强调了结构的两个局限性.首先,复制整个结构通常比复制对象引用效率低,因此对于结构而言,赋值和值参数传递可能比使用引用类型更昂贵.其次,除了ref和out参数之外,不可能创建对结构的引用,结构排除了它们在许多情况下的使用.
Fra*_*nov 34
结构适用于数据的原子表示,其中所述数据可以由代码多次复制.克隆一个对象通常比复制一个结构更昂贵,因为它涉及分配内存,运行构造函数和完成它时解除分配/垃圾回收.
Usm*_*far 26
这是一个基本规则.
如果所有成员字段都是值类型,则创建结构.
如果任何一个成员字段是引用类型,请创建一个类.这是因为引用类型字段无论如何都需要堆分配.
Exmaples
public struct MyPoint
{
public int X; // Value Type
public int Y; // Value Type
}
public class MyPointWithName
{
public int X; // Value Type
public int Y; // Value Type
public string Name; // Reference Type
}
Mau*_*gan 17
在需要使用StructLayoutAttribute显式指定内存布局的情况下,您需要使用"struct" - 通常用于PInvoke.
编辑:注释指出您可以使用StructLayoutAttribute的类或结构,这当然是正确的.在实践中,您通常会使用一个结构 - 它在堆栈和堆上分配,如果您只是将参数传递给非托管方法调用,这是有意义的.
mjf*_*tes 16
我使用结构包装或解压缩任何种类的二进制通信格式.这包括读取或写入磁盘,DirectX顶点列表,网络协议或处理加密/压缩数据.
在此上下文中,您列出的三条准则对我没用.当我需要在特定顺序中写出四百个字节的东西时,我将定义一个四百字节的结构,并且我将填充它应该具有的任何不相关的值,并且我将要去以任何最有意义的方式设置它.(好吧,四百个字节会很奇怪 - 但是当我以Excel文件为生,我正在处理全部最多大约四十个字节的结构,因为那是BIFF记录的大小.)
Suj*_*jit 13
.NET支持value types和reference types(在Java中,您只能定义引用类型).reference types在托管堆中分配get的实例,并且在没有对它们的未完成引用时进行垃圾回收.value types另一方面,实例在其中分配stack,因此一旦其范围结束,就分配内存.当然,value types通过价值和reference types参考传递.除System.String外,所有C#原始数据类型都是值类型.
何时使用struct over class,
在C#中,structs是value types,类是reference types.您可以使用enum关键字和struct关键字在C#中创建值类型.使用a value type而不是a reference type将导致托管堆上的对象更少,从而导致垃圾收集器(GC)上的负载更少,GC周期更少,从而提高性能.但是,value types也有它们的缺点.绕过一个大struct的肯定比通过引用更昂贵,这是一个明显的问题.另一个问题是与之相关的开销boxing/unboxing.如果您想知道什么boxing/unboxing意思,请按照这些链接获取有关boxing和的详细说明unboxing.除了性能之外,有时候你只需要类型来拥有值语义,如果reference types你拥有它们,这将是非常困难(或丑陋)的实现.您应该value types只使用,当您需要复制语义或需要自动初始化时,通常在arrays这些类型中.
Jas*_*ams 11
甲结构是一个值类型.如果将结构分配给新变量,则新变量将包含原始副本.
public struct IntStruct {
public int Value {get; set;}
}
以下结果导致存储在内存中的结构的5个实例:
var struct1 = new IntStruct() { Value = 0 }; // original
var struct2 = struct1; // A copy is made
var struct3 = struct2; // A copy is made
var struct4 = struct3; // A copy is made
var struct5 = struct4; // A copy is made
// NOTE: A "copy" will occur when you pass a struct into a method parameter.
// To avoid the "copy", use the ref keyword.
// Although structs are designed to use less system resources
// than classes. If used incorrectly, they could use significantly more.
甲类是引用类型.将类分配给新变量时,该变量包含对原始类对象的引用.
public class IntClass {
public int Value {get; set;}
}
超出以下内容只会导致内存中类对象的一个实例.
var class1 = new IntClass() { Value = 0 };
var class2 = class1; // A reference is made to class1
var class3 = class2; // A reference is made to class1
var class4 = class3; // A reference is made to class1
var class5 = class4; // A reference is made to class1
结构可能会增加代码错误的可能性.如果将值对象视为可变引用对象,则当所做的更改意外丢失时,开发人员可能会感到惊讶.
var struct1 = new IntStruct() { Value = 0 };
var struct2 = struct1;
struct2.Value = 1;
// At this point, a developer may be surprised when
// struct1.Value is 0 and not 1
hab*_*bib 11
误区一：结构是轻量级的类
这个神话有多种形式。有些人认为值类型不能或不应该有方法或其他重要的行为——它们应该被用作简单的数据传输类型，只有公共字段或简单的属性。DateTime 类型是一个很好的反例：它是一个值类型是有意义的，因为它是一个像数字或字符这样的基本单位，并且它能够基于它的价值。从另一个方向看，数据传输类型通常应该是引用类型——决定应该基于所需的值或引用类型语义，而不是类型的简单性。其他人认为值类型在性能方面比引用类型“更轻”。事实是，在某些情况下，值类型的性能更高——例如，除非它们被装箱，否则它们不需要垃圾收集，没有类型识别开销，并且不需要取消引用。但在其他方面，引用类型的性能更高——参数传递、给变量赋值、返回值和类似的操作只需要复制 4 或 8 个字节（取决于你运行的是 32 位还是 64 位 CLR ) 而不是复制所有数据。想象一下，如果 ArrayList 是一种“纯”值类型，并且将 ArrayList 表达式传递给涉及复制其所有数据的方法！在几乎所有情况下，性能并不是由这种决定真正决定的。瓶颈几乎永远不会出现在您认为会出现的地方，在您根据性能做出设计决定之前，你应该衡量不同的选择。值得注意的是，这两种信念的结合也不起作用。一个类型有多少方法（无论是类还是结构）并不重要——每个实例占用的内存不受影响。（就代码本身占用的内存而言，这是有成本的，但这是一次而不是每个实例。）
误解 2：引用类型存在于堆中；值类型存在于堆栈中
这通常是由于重复它的人的懒惰造成的。第一部分是正确的——引用类型的实例总是在堆上创建。这是导致问题的第二部分。正如我已经注意到的，变量的值存在于它声明的任何地方，因此如果您有一个具有 int 类型实例变量的类，则任何给定对象的该变量的值将始终是该对象的其余数据所在的位置——在堆上。只有局部变量（在方法中声明的变量）和方法参数存在于堆栈中。在 C# 2 和更高版本中，甚至一些局部变量也并不真正存在于堆栈中，正如我们在第 5 章中查看匿名方法时所看到的那样。这些概念现在是否相关？有争议的是，如果您正在编写托管代码，您应该让运行时担心如何最好地使用内存。的确，语言规范不保证什么存在于何处；未来的运行时可能能够在堆栈上创建一些对象，如果它知道它可以逃脱它，或者 C# 编译器可以生成几乎不使用堆栈的代码。下一个神话通常只是一个术语问题。
误区 #3：对象在 C# 中默认通过引用传递
这可能是传播最广的神话。同样，经常（尽管并非总是）做出这种声明的人知道 C# 的实际行为，但他们不知道“通过引用传递”的真正含义。不幸的是，对于知道这意味着什么的人来说，这令人困惑。引用传递的正式定义比较复杂，涉及到左值和类似的计算机科学术语，但重要的是如果你通过引用传递一个变量，你调用的方法可以改变调用者变量的值通过改变其参数值。现在，请记住引用类型变量的值是引用，而不是对象本身。您可以更改参数引用的对象的内容，而无需通过引用传递参数本身。例如，
void AppendHello(StringBuilder builder)
{
builder.Append("hello");
}
调用此方法时，参数值（对 StringBuilder 的引用）按值传递。如果您要在方法中更改 builder 变量的值（例如，使用语句 builder = null;），则调用者不会看到该更改，这与神话相反。有趣的是，不仅神话中的“按引用”位不准确，“对象被传递”位也不准确。对象本身永远不会通过引用或值传递。当涉及到引用类型时，要么是通过引用传递变量，要么是通过值传递参数（引用）的值。除此之外，这回答了当 null 用作按值参数时会发生什么的问题——如果对象被传递，那会导致问题，因为不会有对象传递！反而，空引用以与任何其他引用相同的方式按值传递。如果这个简短的解释让您感到困惑，您可能需要查看我的文章“C# 中的参数传递”，（http://mng.bz/otVt），其中更详细。这些神话并不是周围唯一的神话。装箱和拆箱是因为他们存在相当多的误解，接下来我将努力澄清。
参考： C# in Depth 3rd Edition by Jon Skeet
Sna*_*Jag 10
不 - 我不完全同意这些规则.它们是考虑性能和标准化的良好指导方针,但不是考虑到可能性.
正如您在回复中所看到的,有很多创造性的方法可以使用它们.因此,这些指南只需要这样,总是为了性能和效率.
在这种情况下,我使用类来表示更大形式的真实世界对象,我使用结构来表示具有更精确用途的较小对象.你说的方式,"一个更有凝聚力的整体." 关键词具有凝聚力.这些类将是更多面向对象的元素,而结构体可以具有一些这些特征,尽管规模较小.IMO.
我在Treeview和Listview标签中经常使用它们,可以非常快速地访问常见的静态属性.我一直在努力以另一种方式获取此信息.例如,在我的数据库应用程序中,我使用Treeview,其中包含表,SP,函数或任何其他对象.我创建并填充我的结构,将其放在标签中,将其拉出,获取选择的数据等等.我不会在上课时这样做!
我确实尝试将它们保持在小的状态,在单实例情况下使用它们,并防止它们发生变化.注意记忆,分配和性能是明智的.测试是必要的.
sup*_*cat 10
C#或其他.net语言中的结构类型通常用于保存应该像固定大小的值组一样的事物.结构类型的一个有用方面是结构类型实例的字段可以通过修改其所在的存储位置来修改,而不是以其他方式.可以以这样的方式对结构进行编码:改变任何字段的唯一方法是构造一个全新的实例,然后使用结构赋值通过用新实例中的值覆盖它们来改变目标的所有字段,但是除非struct没有提供创建其字段具有非默认值的实例的方法,否则如果struct本身存储在可变位置,则其所有字段都是可变的.
请注意,如果结构包含私有类类型字段,并且将其自己的成员重定向到包装类对象的成员,则可以设计结构类型,使其基本上表现得像类类型.例如,PersonCollection可能会提供性能SortedByName和SortedById,两者都持有"不可改变的"参考了PersonCollection(在其构造集),并实现GetEnumerator通过调用creator.GetNameSortedEnumerator或creator.GetIdSortedEnumerator.这样的结构表现得很像a的引用PersonCollection,除了它们的GetEnumerator方法将被绑定到不同的方法PersonCollection.也可以有一个结构包装数组的一部分(例如,可以定义一个ArrayRange<T>结构,该结构将保存一个T[]被调用的Arr,一个int Offset和一个intLength,索引属性,对于idx范围为0到的索引Length-1,将访问Arr[idx+Offset]).不幸的是,如果foo是这种结构的只读实例,当前的编译器版本将不允许这样的操作,foo[3]+=4;因为它们无法确定此类操作是否会尝试写入字段foo.
也可以设计一个结构,使其表现得像一个值类型,它保存一个可变大小的集合(每当结构都会被复制时),但唯一的方法就是确保没有对象. struct持有一个引用将暴露于任何可能会改变它的东西.例如,可以有一个类似于数组的结构,它包含一个私有数组,其索引的"put"方法创建一个新数组,其内容与原始数组的内容类似,除了一个更改的元素.不幸的是,使这种结构有效地执行可能有些困难.虽然有时结构语义可以很方便(例如,能够将类似数组的集合传递给例程,调用者和被调用者都知道外部代码不会修改集合,
Rom*_*kij 10
我用BenchmarkDotNet做了一个小基准,以便更好地理解数字中的"结构"效益.我正在测试循环遍历结构(或类)的数组(或列表).创建这些数组或列表超出了基准测试的范围 - 很明显,"类"更重将使用更多内存,并且将涉及GC.
所以结论是:小心LINQ和隐藏的结构装箱/拆箱,并使用结构进行微优化,严格保留数组.
PS关于通过调用堆栈传递struct/class的另一个基准是/sf/answers/3350511601/
BenchmarkDotNet=v0.10.8, OS=Windows 10 Redstone 2 (10.0.15063)
Processor=Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount=4
Frequency=3233542 Hz, Resolution=309.2584 ns, Timer=TSC
[Host] : Clr 4.0.30319.42000, 64bit RyuJIT-v4.7.2101.1
Clr : Clr 4.0.30319.42000, 64bit RyuJIT-v4.7.2101.1
Core : .NET Core 4.6.25211.01, 64bit RyuJIT
Method | Job | Runtime | Mean | Error | StdDev | Min | Max | Median | Rank | Gen 0 | Allocated |
---------------- |----- |-------- |----------:|----------:|----------:|----------:|----------:|----------:|-----:|-------:|----------:|
TestListClass | Clr | Clr | 5.599 us | 0.0408 us | 0.0382 us | 5.561 us | 5.689 us | 5.583 us | 3 | - | 0 B |
TestArrayClass | Clr | Clr | 2.024 us | 0.0102 us | 0.0096 us | 2.011 us | 2.043 us | 2.022 us | 2 | - | 0 B |
TestListStruct | Clr | Clr | 8.427 us | 0.1983 us | 0.2204 us | 8.101 us | 9.007 us | 8.374 us | 5 | - | 0 B |
TestArrayStruct | Clr | Clr | 1.539 us | 0.0295 us | 0.0276 us | 1.502 us | 1.577 us | 1.537 us | 1 | - | 0 B |
TestLinqClass | Clr | Clr | 13.117 us | 0.1007 us | 0.0892 us | 13.007 us | 13.301 us | 13.089 us | 7 | 0.0153 | 80 B |
TestLinqStruct | Clr | Clr | 28.676 us | 0.1837 us | 0.1534 us | 28.441 us | 28.957 us | 28.660 us | 9 | - | 96 B |
TestListClass | Core | Core | 5.747 us | 0.1147 us | 0.1275 us | 5.567 us | 5.945 us | 5.756 us | 4 | - | 0 B |
TestArrayClass | Core | Core | 2.023 us | 0.0299 us | 0.0279 us | 1.990 us | 2.069 us | 2.013 us | 2 | - | 0 B |
TestListStruct | Core | Core | 8.753 us | 0.1659 us | 0.1910 us | 8.498 us | 9.110 us | 8.670 us | 6 | - | 0 B |
TestArrayStruct | Core | Core | 1.552 us | 0.0307 us | 0.0377 us | 1.496 us | 1.618 us | 1.552 us | 1 | - | 0 B |
TestLinqClass | Core | Core | 14.286 us | 0.2430 us | 0.2273 us | 13.956 us | 14.678 us | 14.313 us | 8 | 0.0153 | 72 B |
TestLinqStruct | Core | Core | 30.121 us | 0.5941 us | 0.5835 us | 28.928 us | 30.909 us | 30.153 us | 10 | - | 88 B |
码:
[RankColumn, MinColumn, MaxColumn, StdDevColumn, MedianColumn]
[ClrJob, CoreJob]
[HtmlExporter, MarkdownExporter]
[MemoryDiagnoser]
public class BenchmarkRef
{
public class C1
{
public string Text1;
public string Text2;
public string Text3;
}
public struct S1
{
public string Text1;
public string Text2;
public string Text3;
}
List<C1> testListClass = new List<C1>();
List<S1> testListStruct = new List<S1>();
C1[] testArrayClass;
S1[] testArrayStruct;
public BenchmarkRef()
{
for(int i=0;i<1000;i++)
{
testListClass.Add(new C1 { Text1= i.ToString(), Text2=null, Text3= i.ToString() });
testListStruct.Add(new S1 { Text1 = i.ToString(), Text2 = null, Text3 = i.ToString() });
}
testArrayClass = testListClass.ToArray();
testArrayStruct = testListStruct.ToArray();
}
[Benchmark]
public int TestListClass()
{
var x = 0;
foreach(var i in testListClass)
{
x += i.Text1.Length + i.Text3.Length;
}
return x;
}
[Benchmark]
public int TestArrayClass()
{
var x = 0;
foreach (var i in testArrayClass)
{
x += i.Text1.Length + i.Text3.Length;
}
return x;
}
[Benchmark]
public int TestListStruct()
{
var x = 0;
foreach (var i in testListStruct)
{
x += i.Text1.Length + i.Text3.Length;
}
return x;
}
[Benchmark]
public int TestArrayStruct()
{
var x = 0;
foreach (var i in testArrayStruct)
{
x += i.Text1.Length + i.Text3.Length;
}
return x;
}
[Benchmark]
public int TestLinqClass()
{
var x = testListClass.Select(i=> i.Text1.Length + i.Text3.Length).Sum();
return x;
}
[Benchmark]
public int TestLinqStruct()
{
var x = testListStruct.Select(i => i.Text1.Length + i.Text3.Length).Sum();
return x;
}
}
类是引用类型.创建类的对象时,为其分配对象的变量仅保留对该内存的引用.将对象引用分配给新变量时,新变量引用原始对象.通过一个变量进行的更改会反映在另一个变量中,因为它们都引用相同的数据.结构是一种值类型.创建结构时,为其分配结构的变量保存结构的实际数据.将结构分配给新变量时,会复制该变量.因此,新变量和原始变量包含相同数据的两个单独副本.对一个副本所做的更改不会影响另一个副本.通常,类用于建模更复杂的行为,或者在创建类对象后要修改的数据.结构最适合于主要包含在创建结构后不打算修改的数据的小型数据结构.
我认为一个很好的第一近似是“从不”。
我认为一个好的第二近似值是“从不”。
如果您迫切希望获得性能，请考虑使用它们，但是请务必进行测量。
简而言之，使用 struct 如果：
您的对象属性/字段不需要更改。我的意思是你只想给它们一个初始值，然后读取它们。
对象中的属性和字段是值类型，并且它们不是很大。
如果是这种情况，您可以利用结构来获得更好的性能和优化的内存分配，因为它们仅使用堆栈而不是同时使用堆栈和堆（在类中）
| 归档时间： |
|
| 查看次数： |
259046 次 |
| 最近记录： |