Question

让我们假设您需要存储一定数量的数据，这些数据由结构或类表示。您只会存储最多N个元素，如果添加更多元素，则必须先删除现有元素。

您可以使用任何您喜欢的方式存储数据 - 列表，数组（或任何其他内容，如果您愿意）。

就垃圾收集而言 - 是否使用类或结构来表示信息会有所不同吗？将它存储在List或Array中会有所不同吗？

我的直觉是使用结构数组的最佳方式，因为原则上GC不应该在这里收集任何东西（当数组存储在堆上时，它的大小保持不变，所以没有任何集合发生了我相信吗？）。

我不完全确定如何表示结构列表 - 是否存在与添加/删除结构元素相关的任何形式的垃圾收集？

至于使用类而不是结构体，我希望一旦从列表中删除，或者在数组中重写，就需要收集旧的引用，这样就会对GC产生压力。

如果我的直觉在这里是正确的，或者我在任何地方都出错了，请欣赏输入！感谢

示例代码：

public struct SStruct
{
   int ABC;
}

public class SClass
{
  int ABC;
}

public class Test
{
   List<SStruct> _data1;
   List<SClass> _data2;
   SStruct[100] _data3;
   SClass[100] _data4;

  public void run()
  {
    var sStruct = new SStruct();
    var sClass = new SClass();

    if(data1.Count > 0)
      _data1.RemoveAt(0);

    if(data2.Count > 0)
      _data2.RemoveAt(0);

    _data1.Add(sStruct);
    _data2.Add(sClass);
    _data3[0] = sStruct;
    _data4[0] = sClass;
}

Answer 1

如果有疑问，请在您的情况下进行一些测试。

这很容易以最基本的形式进行测试，但这实际上取决于你在做什么。但我认为假设你的直觉可能非常准确。

这只是一个基本的测试，随时随地修改它，并按照你喜欢的方式加载结构

鉴于

public struct TestStruct
{
   public int Value;

}
public struct TestStruct2
{
   public int Value;

   public string AString;
}
public class TestClass
{
   public int Value;
}
public class TestClass2
{
   public int Value;
   public string AString;
}
private static TestStruct[] _arrayOfTestStructs = new TestStruct[100];
private static TestStruct2[] _arrayOfTestStruct2 = new TestStruct2[100];
private static TestClass[] _arrayOfTestClass = new TestClass[100];
private static TestClass2[] _arrayOfTestClass2 = new TestClass2[100];

<强>测试

var sw = new Stopwatch();

Random rand = new Random();
GC.Collect();
GC.WaitForPendingFinalizers();
Console.WriteLine("struct1");
Console.WriteLine("Start   : {0:N0}", GC.GetTotalMemory(false));
sw.Start();
for (int i = 0; i < 100000000; i++)
{
   _arrayOfTestStructs[rand.Next(100)] = new TestStruct();
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
sw.Reset();

Console.WriteLine("Working : {0:N0}", GC.GetTotalMemory(false));
GC.Collect();
GC.WaitForPendingFinalizers();
Console.WriteLine("Collect : {0:N0}", GC.GetTotalMemory(false));
Console.WriteLine("Class1");
sw.Start();
for (int i = 0; i < 100000000; i++)
{
   _arrayOfTestClass[rand.Next(100)] = new TestClass();
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
sw.Reset();
Console.WriteLine("Working : {0:N0}", GC.GetTotalMemory(false));
GC.Collect();
GC.WaitForPendingFinalizers();
Console.WriteLine("Collect : {0:N0}", GC.GetTotalMemory(false));
Console.WriteLine("struct2");
sw.Start();
for (int i = 0; i < 100000000; i++)
{
   _arrayOfTestStruct2[rand.Next(100)] = new TestStruct2();
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
sw.Reset();
Console.WriteLine("Working : {0:N0}", GC.GetTotalMemory(false));
GC.Collect();
GC.WaitForPendingFinalizers();
Console.WriteLine("Collect : {0:N0}", GC.GetTotalMemory(false));
Console.WriteLine("Class2");
sw.Start();
for (int i = 0; i < 100000000; i++)
{
   _arrayOfTestClass2[rand.Next(100)] = new TestClass2();
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
sw.Reset();
Console.WriteLine("Working : {0:N0}", GC.GetTotalMemory(false));
GC.Collect();
GC.WaitForPendingFinalizers();
Console.WriteLine("Collect : {0:N0}", GC.GetTotalMemory(false));
Console.ReadKey();

<强>输出继电器

struct1
Start   : 32,460
1647
Working : 40,652
Collect : 40,448
Class1
2203
Working : 716,936
Collect : 41,744
struct2
1537
Working : 41,744
Collect : 41,660
Class2
2244
Working : 2,265,944
Collect : 43,072

A Flakey .Net Demo here

总结，这里没有什么神秘之处，它相当直观，结构数组比同等类更快，创造的垃圾更少。

显然List会再慢一些，但假设你只是覆盖了元素而不是删除它，可能会产生类似的垃圾。

无论如何，这不是一个确凿的演示

GC压力 - List vs Array，class vs struct

1 个答案: