आइए मान लें कि आपको एक निश्चित मात्रा में डेटा स्टोर करने की आवश्यकता है, जिसे किसी संरचना या वर्ग द्वारा दर्शाया जाता है। आप केवल अधिकतम N तत्वों को संग्रहीत करेंगे, यदि अधिक जोड़ते हैं, तो आपको पहले किसी मौजूदा को हटाना होगा।

आप डेटा को स्टोर करने के लिए किसी भी तरह से उपयोग कर सकते हैं - एक सूची, एक सरणी (या यदि आप चाहें तो कुछ भी)।

कचरा संग्रह के संदर्भ में - क्या इससे कोई फर्क पड़ता है कि आप जानकारी का प्रतिनिधित्व करने के लिए कक्षा या संरचना का उपयोग करते हैं या नहीं? क्या इससे कोई फर्क पड़ता है कि आप इसे किसी सूची या ऐरे में संग्रहीत करते हैं?

मेरा अंतर्ज्ञान सबसे अच्छा तरीका है जो स्ट्रक्चर्स की एक सरणी का उपयोग करेगा, क्योंकि सिद्धांत रूप में एक जीसी को कभी भी यहां कुछ भी इकट्ठा करने की आवश्यकता नहीं होनी चाहिए (जबकि सरणी ढेर पर संग्रहीत होती है, इसका आकार स्थिर रहता है और इसलिए कोई संग्रह कभी नहीं होता है I मानना?)।

मुझे पूरी तरह से यकीन नहीं है कि स्ट्रक्चर्स की एक सूची का प्रतिनिधित्व कैसे किया जाएगा - क्या स्ट्रक्चर तत्वों को जोड़ने/हटाने से जुड़े कचरा संग्रह का कोई रूप है?

स्ट्रक्चर्स के बजाय कक्षाओं का उपयोग करने के लिए, मुझे उम्मीद है कि एक बार सूची से हटा दिया जाएगा, या सरणी में ओवरराइड किया जाएगा, पुराने संदर्भ को एकत्र करने की आवश्यकता होगी, इसलिए या तो जीसी दबाव डाला जाएगा।

अगर मेरा अंतर्ज्ञान यहां सही है या अगर मैं कहीं भी गलत हो रहा हूं तो इनपुट की सराहना करेंगे! धन्यवाद

उदाहरण कोड:

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;
}
c#
3
Bogey 23 अप्रैल 2018, 12:26

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

एक परतदार .नेट डेमो यहाँ

सारांश, यहां कोई रहस्य नहीं है और इसकी काफी सहज ज्ञान युक्त, संरचना की सरणी तेज है और समकक्ष वर्गों की तुलना में कम कचरा पैदा करती है।

जाहिर है कि एक सूची फिर से धीमी हो जाएगी, हालांकि यह मानते हुए कि आप केवल तत्व को ओवरराइट कर रहे हैं और इसे हटा नहीं रहे हैं, शायद इसी तरह का कचरा पैदा करेगा।

वैसे भी यह एक निर्णायक डेमो नहीं है

1
TheGeneral 23 अप्रैल 2018, 14:06