जवाबों:
.NET में, दो प्रकार के प्रकार, संदर्भ प्रकार और मूल्य प्रकार हैं ।
संरचना मूल्य प्रकार हैं और कक्षाएं संदर्भ प्रकार हैं ।
सामान्य अंतर यह है कि एक संदर्भ प्रकार ढेर पर रहता है, और एक मूल्य प्रकार इनलाइन रहता है, अर्थात, जहां भी यह आपका चर या क्षेत्र परिभाषित होता है।
एक मान प्रकार वाले चर में संपूर्ण मान प्रकार होता है । एक संरचना के लिए, इसका मतलब है कि चर में संपूर्ण संरचना शामिल है, जिसके सभी क्षेत्र हैं।
एक संदर्भ प्रकार वाले चर में एक पॉइंटर, या स्मृति में कहीं और संदर्भ होता है जहां वास्तविक मूल्य रहता है।
यह एक लाभ है, के साथ शुरू करने के लिए:
आंतरिक रूप से, संदर्भ प्रकार को बिंदु के रूप में लागू किया जाता है, और यह जानते हुए भी कि, और यह जानना कि चर असाइनमेंट कैसे काम करता है, अन्य व्यवहार पैटर्न हैं:
जब आप चर या क्षेत्र घोषित करते हैं, तो यहां बताया गया है कि दो प्रकार कैसे भिन्न होते हैं:
प्रत्येक का एक संक्षिप्त सारांश:
केवल कक्षाएं:
केवल संरचनाएं:
दोनों वर्ग और संरचनाएं:
c# struct memory overheadऔर हंस पसंत के इस जवाब को पाया जो कहता है कि नहीं, यह मामला नहीं है। तो क्या करते हैं आप क्या मतलब है?
classको प्रबंधित मेमोरी (कचरा कलेक्टर द्वारा नियंत्रित) किया जाता है, जबकि उदाहरण structनहीं हैं ।
.NET में, संदर्भ प्रकारों और मूल्य प्रकारों के बीच संरचना और वर्ग की घोषणाएं भिन्न होती हैं।
जब आप किसी संदर्भ प्रकार को पास करते हैं तो वास्तव में केवल एक संग्रहीत होता है। सभी कोड जो एक्सेस को एक्सेस करते हैं, वही एक्सेस कर रहा है।
जब आप राउंड पास एक वैल्यू टाइप करते हैं तो हर एक कॉपी है। सभी कोड अपनी कॉपी पर काम कर रहे हैं।
इसे एक उदाहरण के साथ दिखाया जा सकता है:
struct MyStruct
{
string MyProperty { get; set; }
}
void ChangeMyStruct(MyStruct input)
{
input.MyProperty = "new value";
}
...
// Create value type
MyStruct testStruct = new MyStruct { MyProperty = "initial value" };
ChangeMyStruct(testStruct);
// Value of testStruct.MyProperty is still "initial value"
// - the method changed a new copy of the structure.एक वर्ग के लिए यह अलग होगा
class MyClass
{
string MyProperty { get; set; }
}
void ChangeMyClass(MyClass input)
{
input.MyProperty = "new value";
}
...
// Create reference type
MyClass testClass = new MyClass { MyProperty = "initial value" };
ChangeMyClass(testClass);
// Value of testClass.MyProperty is now "new value"
// - the method changed the instance passed.कक्षाएं कुछ भी नहीं हो सकती हैं - संदर्भ एक अशक्त को इंगित कर सकता है।
संरचनाएं वास्तविक मूल्य हैं - वे खाली हो सकती हैं लेकिन कभी भी शून्य नहीं होती हैं। इस कारण से, संरचना में हमेशा एक डिफ़ॉल्ट निर्माता होता है जिसमें कोई पैरामीटर नहीं होता है - उन्हें एक 'शुरुआती मूल्य' की आवश्यकता होती है।
संरचनाओं और वर्गों के बीच अंतर:
Microsoft की कक्षा और संरचना के बीच चयन से ...
अंगूठे के एक नियम के रूप में, एक ढांचे में अधिकांश प्रकार की कक्षाएं होनी चाहिए। हालाँकि, कुछ परिस्थितियाँ हैं, जिनमें मूल्य प्रकार की विशेषताएँ, संरचना का उपयोग करना अधिक उचित बनाती हैं।
✓ एक वर्ग के बजाय एक संरचना पर विचार करें :
- यदि प्रकार के उदाहरण छोटे होते हैं और आमतौर पर अल्पकालिक होते हैं या आमतौर पर अन्य वस्तुओं में एम्बेडेड होते हैं।
एक्स एक struct से बचें जब तक प्रकार है सभी निम्नलिखित विशेषताएं की:
- यह तार्किक रूप से आदिम प्रकार (इंट, डबल, आदि) के समान एकल मूल्य का प्रतिनिधित्व करता है।
- यह 16 बाइट्स के तहत एक उदाहरण आकार है।
- यह अपरिवर्तनीय है। (बदला नहीं जा सकता)
- इसे बार-बार बॉक्सिंग नहीं करना पड़ेगा।
अन्य उत्तरों में वर्णित सभी अंतरों के अलावा:
यदि आप सभी अंतरों को समझाने वाले वीडियो के बाद हैं, तो आप भाग 29 - C # ट्यूटोरियल की जांच कर सकते हैं - C # में कक्षाओं और संरचनाओं के बीच अंतर ।
कक्षाओं के उदाहरण प्रबंधित हीप पर संग्रहीत किए जाते हैं। सभी चर 'एक उदाहरण' युक्त केवल ढेर पर उदाहरण के लिए एक संदर्भ है। किसी विधि में किसी वस्तु को पास करने से संदर्भ की एक प्रति पारित हो जाती है, वस्तु ही नहीं।
संरचनाएँ (तकनीकी रूप से, मूल्य प्रकार) जहाँ कहीं भी उपयोग की जाती हैं, वे एक आदिम प्रकार की तरह संग्रहीत की जाती हैं। सामग्री को किसी भी समय रनटाइम द्वारा कॉपी किया जा सकता है और एक अनुकूलित कॉपी-कंस्ट्रक्टर को शामिल किए बिना। एक मूल्य प्रकार को एक विधि में पास करना संपूर्ण मूल्य की प्रतिलिपि बनाना है, फिर से किसी भी अनुकूलन कोड को शामिल किए बिना।
अंतर को C ++ / CLI नामों से बेहतर बनाया गया है: "रेफ क्लास" एक वर्ग है जैसा कि पहले वर्णित है, "मूल्य वर्ग" एक वर्ग है जिसे दूसरे के रूप में वर्णित किया गया है। सी # द्वारा उपयोग किए जाने वाले कीवर्ड "क्लास" और "स्ट्रक्चर" बस कुछ ऐसी चीजें हैं जिन्हें सीखना चाहिए।
+------------------------+------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------+
| | 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 |
| Aldel Cost | Cheap allocation-deallocation | Expensive allocation-deallocation |
| Memory usage | Boxed when cast to a reference type or one of the interfaces they implement, | No boxing-unboxing |
| | Unboxed when cast back to value type | |
| | (Negative impact because boxes are objects that are allocated on the heap and are garbage-collected) | |
| 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 |
| 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+) |
| Abstract | No | When have abstract keyword |
| Member Access Modifiers| public, private, internal | public, protected, internal, protected internal, private protected |
+------------------------+------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------+संरचना बनाम कक्षा
एक संरचना एक मूल्य प्रकार है इसलिए इसे स्टैक पर संग्रहीत किया जाता है, लेकिन एक वर्ग एक संदर्भ प्रकार है और ढेर पर संग्रहीत किया जाता है।
एक संरचना विरासत और बहुरूपता का समर्थन नहीं करती है, लेकिन एक वर्ग दोनों का समर्थन करता है।
डिफ़ॉल्ट रूप से, सभी संरचना सदस्य सार्वजनिक होते हैं लेकिन कक्षा सदस्य डिफ़ॉल्ट रूप से प्रकृति में होते हैं।
जैसा कि एक संरचना एक मूल्य प्रकार है, हम एक संरचनात्मक वस्तु को अशक्त नहीं कर सकते हैं, लेकिन यह एक वर्ग के लिए मामला नहीं है।
अन्य उत्तरों को जोड़ने के लिए, एक मूलभूत अंतर है जो ध्यान देने योग्य है, और वह यह है कि डेटा को सरणियों के भीतर कैसे संग्रहीत किया जाता है क्योंकि इससे प्रदर्शन पर एक बड़ा प्रभाव पड़ सकता है।
तो स्मृति में इस तरह की एक संरचना दिखती है
[struct][struct][struct][struct][struct][struct][struct][struct]
जबकि वर्गों की एक सरणी इस तरह दिखती है
[pointer][pointer][pointer][pointer][pointer][pointer][pointer][pointer]
कक्षाओं की एक सरणी के साथ, जिन मूल्यों में आप रुचि रखते हैं, वे सरणी में संग्रहीत नहीं हैं, लेकिन स्मृति में कहीं और हैं।
अधिकांश अनुप्रयोगों के लिए यह अंतर वास्तव में मायने नहीं रखता है, हालांकि, उच्च प्रदर्शन कोड में यह मेमोरी के भीतर डेटा के स्थानीयता को प्रभावित करेगा और सीपीयू कैश के प्रदर्शन पर बड़ा प्रभाव पड़ेगा। कक्षाओं का उपयोग करते समय जब आप कर सकते थे / उपयोग किए जाने वाले स्ट्रक्चर्स को सीपीयू पर कैश मिस की संख्या में बड़े पैमाने पर वृद्धि होगी।
आधुनिक सीपीयू जितनी धीमी गति से काम करता है, वह संख्या में कमी नहीं करता है, यह मेमोरी से डेटा प्राप्त कर रहा है, और एक L1 कैश हिट रैम से डेटा पढ़ने की तुलना में कई गुना तेज है।
यहां कुछ कोड दिए गए हैं, जिनका आप परीक्षण कर सकते हैं। मेरी मशीन पर, क्लास एरे के माध्यम से पुनरावृत्ति करना, स्ट्रक्चर ऐरे की तुलना में ~ 3x अधिक समय लेता है।
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}");
}बस इसे पूरा करने के लिए, Equalsविधि का उपयोग करते समय एक और अंतर है , जो सभी वर्गों और संरचनाओं द्वारा विरासत में मिला है।
आओ हम कहते हैं कि हमारे पास एक वर्ग और एक संरचना है:
class A{
public int a, b;
}
struct B{
public int a, b;
}और मुख्य विधि में, हमारे पास 4 ऑब्जेक्ट हैं।
static void Main{
A c1 = new A(), c2 = new A();
c1.a = c1.b = c2.a = c2.b = 1;
B s1 = new B(), s2 = new B();
s1.a = s1.b = s2.a = s2.b = 1;
}फिर:
s1.Equals(s2) // true
s1.Equals(c1) // false
c1.Equals(c2) // false
c1 == c2 // falseतो , अंक-जैसी वस्तुओं के लिए संरचनाएं अनुकूल हैं, जैसे अंक (x और y निर्देशांक सहेजें)। और कक्षाएं दूसरों के लिए अनुकूल हैं। भले ही 2 लोगों का नाम, ऊंचाई, वजन ... हो, फिर भी वे 2 लोग हैं।
खैर, शुरुआत के लिए, संदर्भ के बजाय एक संरचना को मूल्य से पारित किया जाता है। संरचनाएं अपेक्षाकृत सरल डेटा संरचनाओं के लिए अच्छी हैं, जबकि वर्गों में बहुरूपता और वंशानुक्रम के माध्यम से वास्तुकला के दृष्टिकोण से बहुत अधिक लचीलापन है।
अन्य लोग शायद आपको आई से अधिक विस्तार दे सकते हैं, लेकिन मैं उस संरचना का उपयोग करता हूं जब मैं जिस संरचना के लिए जा रहा हूं वह सरल है।
एक्सेस स्पेसियर के बुनियादी अंतर के अलावा, और ऊपर वर्णित कुछ मैं कुछ प्रमुख अंतरों को जोड़ना चाहूंगा, जिनमें से कुछ आउटपुट के साथ कोड नमूने के साथ ऊपर दिए गए हैं, जो संदर्भ और मूल्य का अधिक स्पष्ट विचार देगा।
structs:
वर्ग:
कोड नमूना
static void Main(string[] args)
{
//Struct
myStruct objStruct = new myStruct();
objStruct.x = 10;
Console.WriteLine("Initial value of Struct Object is: " + objStruct.x);
Console.WriteLine();
methodStruct(objStruct);
Console.WriteLine();
Console.WriteLine("After Method call value of Struct Object is: " + objStruct.x);
Console.WriteLine();
//Class
myClass objClass = new myClass(10);
Console.WriteLine("Initial value of Class Object is: " + objClass.x);
Console.WriteLine();
methodClass(objClass);
Console.WriteLine();
Console.WriteLine("After Method call value of Class Object is: " + objClass.x);
Console.Read();
}
static void methodStruct(myStruct newStruct)
{
newStruct.x = 20;
Console.WriteLine("Inside Struct Method");
Console.WriteLine("Inside Method value of Struct Object is: " + newStruct.x);
}
static void methodClass(myClass newClass)
{
newClass.x = 20;
Console.WriteLine("Inside Class Method");
Console.WriteLine("Inside Method value of Class Object is: " + newClass.x);
}
public struct myStruct
{
public int x;
public myStruct(int xCons)
{
this.x = xCons;
}
}
public class myClass
{
public int x;
public myClass(int xCons)
{
this.x = xCons;
}
}उत्पादन
संरचना वस्तु का प्रारंभिक मूल्य है: 10
इनसाइड स्ट्रक्चर मेथड इनसाइड मेथड ऑफ स्ट्रक्चर ऑब्जेक्ट का मान है: २०
मेथड के बाद स्ट्रक्चर ऑब्जेक्ट का कॉल वैल्यू है: १०
कक्षा वस्तु का प्रारंभिक मूल्य है: 10
इनसाइड क्लास मेथड इनसाइड मेथड ऑफ क्लास ऑब्जेक्ट है: 20
विधि के बाद क्लास ऑब्जेक्ट का मूल्य है: 20
यहां आप मूल्य द्वारा कॉल और संदर्भ द्वारा कॉल के बीच अंतर स्पष्ट रूप से देख सकते हैं।
एक कक्षा में घोषित घटनाओं में उनका + = और - = पहुंच स्वचालित रूप से लॉक के माध्यम से लॉक हो जाता है (यह) उन्हें थ्रेड को सुरक्षित बनाने के लिए (स्थिर घटनाओं को टाइपोफ़ क्लास पर लॉक किया जाता है)। एक संरचना में घोषित घटनाओं में उनका + = और - = का उपयोग स्वचालित रूप से लॉक नहीं होता है। एक संरचना के लिए एक लॉक (यह) काम नहीं करेगा क्योंकि आप केवल संदर्भ प्रकार की अभिव्यक्ति पर लॉक कर सकते हैं।
संरचना उदाहरण बनाने से कचरा संग्रह नहीं हो सकता (जब तक कि निर्माणकर्ता प्रत्यक्ष या अप्रत्यक्ष रूप से एक संदर्भ प्रकार का उदाहरण नहीं बनाता है) जबकि संदर्भ प्रकार का उदाहरण बनाने से कचरा संग्रह हो सकता है।
एक संरचना में हमेशा एक अंतर्निहित सार्वजनिक डिफ़ॉल्ट निर्माता होता है।
class DefaultConstructor
{
static void Eg()
{
Direct yes = new Direct(); // Always compiles OK
InDirect maybe = new InDirect(); // Compiles if constructor exists and is accessible
//...
}
}इसका मतलब यह है कि एक संरचना हमेशा तात्कालिक होती है जबकि एक वर्ग ऐसा नहीं हो सकता है क्योंकि उसके सभी निर्माता निजी हो सकते हैं।
class NonInstantiable
{
private NonInstantiable() // OK
{
}
}
struct Direct
{
private Direct() // Compile-time error
{
}
}एक संरचना में एक विध्वंसक नहीं हो सकता। एक विध्वंसक वस्तु का सिर्फ एक ओवरराइड है। भेष बदलकर, और संरचना, मूल्य प्रकार होने के नाते, कचरा संग्रह के अधीन नहीं हैं।
struct Direct
{
~Direct() {} // Compile-time error
}
class InDirect
{
~InDirect() {} // Compiles OK
}
And the CIL for ~Indirect() looks like this:
.method family hidebysig virtual instance void
Finalize() cil managed
{
// ...
} // end of method Indirect::Finalizeएक संरचना स्पष्ट रूप से सील है, एक वर्ग नहीं है।
एक संरचना अमूर्त नहीं हो सकती, एक वर्ग कर सकता है।
एक संरचना इसके निर्माता में आधार () को कॉल नहीं कर सकती है जबकि एक वर्ग जिसमें कोई स्पष्ट आधार वर्ग नहीं है।
एक संरचना दूसरे वर्ग का विस्तार नहीं कर सकती है, एक वर्ग कर सकता है।
एक संरचित संरक्षित सदस्यों की घोषणा नहीं कर सकता (उदाहरण के लिए, फ़ील्ड, नेस्टेड प्रकार) एक वर्ग कर सकता है।
एक संरचना सार फ़ंक्शन सदस्यों की घोषणा नहीं कर सकती, एक सार वर्ग कर सकता है।
एक संरचना वर्चुअल फ़ंक्शन सदस्यों की घोषणा नहीं कर सकती है, एक वर्ग कर सकता है।
एक संरचना सील समारोह सदस्यों की घोषणा नहीं कर सकती है, एक वर्ग कर सकता है।
एक संरचना ओवरराइड फ़ंक्शन सदस्यों की घोषणा नहीं कर सकती है, एक वर्ग कर सकता है।
इस नियम के लिए एक अपवाद यह है कि एक सिस्टम System.Object, अर्थात, () और GetHashCode (), और ToString () के वर्चुअल तरीकों को ओवरराइड कर सकता है।
Object, जो संरचना के एक बॉक्स की प्रतिलिपि का संदर्भ
जैसा कि पहले उल्लेख किया गया है: कक्षाएं संदर्भ प्रकार हैं जबकि संरचना सभी परिणामों के साथ मूल्य प्रकार हैं।
नियम फ्रेमवर्क डिज़ाइन के अंगूठे के रूप में, कक्षाओं के बजाय स्ट्रक्चर्स का उपयोग करने की अनुशंसा करता है यदि:
"वर्ग बनाम संरचना" पहेली का एक दिलचस्प मामला है - स्थिति जब आपको विधि से कई परिणाम वापस करने की आवश्यकता होती है: जो उपयोग करना है उसे चुनें। यदि आप ValueTuple कहानी जानते हैं - आप जानते हैं कि ValueTuple (संरचना) को इसलिए जोड़ा गया क्योंकि यह अधिक प्रभावी होना चाहिए तब Tuple (वर्ग)। लेकिन संख्या में इसका क्या मतलब है? दो परीक्षण: एक संरचना / वर्ग है जिसमें 2 फ़ील्ड हैं, अन्य संरचना / वर्ग के साथ जिसमें 8 फ़ील्ड हैं (आयाम अधिक तब 4 - वर्ग अधिक प्रभावी हो जाना चाहिए तब संदर्भ प्रोसेसर टिक में संरचना होती है, लेकिन निश्चित रूप से जीसी लोड को भी माना जाना चाहिए। )।
पुनश्च विशिष्ट मामले के लिए एक और बेंचमार्क 'संग्रह या संग्रह के साथ वर्ग' है: 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;
}
}
}
}संरचनाएं वास्तविक मूल्य हैं - वे खाली हो सकती हैं लेकिन कभी भी शून्य नहीं होती हैं
यह सच है, हालांकि यह भी ध्यान दें कि .NET 2 संरचना के रूप में एक अशक्त संस्करण का समर्थन करता है और सी # कुछ सिंथैटिक चीनी की आपूर्ति करता है जिससे इसका उपयोग करना आसान हो जाता है।
int? value = null;
value = 1;(object)(default(int?)) == nullजो आप किसी भी अन्य प्रकार के मूल्य के साथ नहीं कर सकते हैं, क्योंकि यहां केवल चीनी की तुलना में अधिक है। केवल चीनी है int?के लिए Nullable<int>।
प्रत्येक चर या क्षेत्र एक आदिम मूल्य प्रकार या संरचना प्रकार उस प्रकार का एक अनूठा उदाहरण रखता है, जिसमें उसके सभी क्षेत्र (सार्वजनिक और निजी) शामिल हैं। इसके विपरीत, चर या संदर्भ प्रकार के क्षेत्र अशक्त हो सकते हैं, या किसी ऑब्जेक्ट को संदर्भित कर सकते हैं, कहीं और संग्रहीत किए जा सकते हैं, जिसमें किसी भी अन्य संदर्भ में भी मौजूद हो सकते हैं। किसी संरचना के फ़ील्ड को उसी संरचना प्रकार के चर या फ़ील्ड के रूप में उसी स्थान पर संग्रहीत किया जाएगा, जो या तो स्टैक पर हो सकता है या किसी अन्य हीप ऑब्जेक्ट का हिस्सा हो सकता है ।
एक आदिम मूल्य प्रकार का एक चर या क्षेत्र बनाना एक डिफ़ॉल्ट मूल्य के साथ पैदा करेगा; एक संरचना प्रकार का एक चर या क्षेत्र बनाने से एक नया उदाहरण बनेगा, जिसमें डिफ़ॉल्ट रूप से सभी फ़ील्ड बनेंगे। एक संदर्भ प्रकार का एक नया उदाहरण बनाना डिफ़ॉल्ट रूप से सभी क्षेत्रों को बनाने और फिर प्रकार के आधार पर वैकल्पिक अतिरिक्त कोड चलाने से शुरू होगा।
एक आदिम प्रकार के एक चर या क्षेत्र की नकल दूसरे को कॉपी करेगा। संरचना के एक चर या क्षेत्र को दूसरे में कॉपी करना पूर्व उदाहरण के सभी क्षेत्रों (सार्वजनिक और निजी) को बाद के उदाहरण में कॉपी करेगा। एक चर या संदर्भ प्रकार के क्षेत्र को दूसरे में कॉपी करने से उत्तरार्द्ध पूर्व (यदि कोई हो) के समान उदाहरण को संदर्भित करेगा।
यह ध्यान रखना महत्वपूर्ण है कि कुछ भाषाओं में जैसे C ++, एक प्रकार का शब्दार्थ व्यवहार इस बात से स्वतंत्र है कि यह कैसे संग्रहीत है, लेकिन यह .NET का सच नहीं है। यदि कोई प्रकार उत्परिवर्ती मान शब्दार्थ को कार्यान्वित करता है, तो उस प्रकार के एक चर को दूसरी प्रति में कॉपी करते हुए पहले के गुणों को दूसरे उदाहरण में, दूसरे द्वारा संदर्भित किया जाता है, और दूसरे के सदस्य को उत्परिवर्तित करने के लिए उपयोग करने से यह दूसरा उदाहरण बदल जाएगा। , लेकिन पहले नहीं। यदि एक प्रकार परस्पर संदर्भ शब्दार्थों को लागू करता है, तो एक चर को दूसरे में कॉपी करना और दूसरे के सदस्य का उपयोग करके वस्तु को अलग करना पहले चर द्वारा संदर्भित ऑब्जेक्ट को प्रभावित करेगा; अपरिवर्तनीय शब्दार्थ के साथ प्रकार उत्परिवर्तन की अनुमति नहीं देते हैं, इसलिए यह शब्दार्थ से कोई फर्क नहीं पड़ता कि क्या नकल एक नया उदाहरण बनाता है या पहले एक और संदर्भ बनाता है।
.NET में, किसी भी उपरोक्त शब्दार्थ को लागू करने के लिए मूल्य प्रकारों के लिए संभव है, बशर्ते कि उनके सभी क्षेत्र इसी तरह कर सकते हैं। एक संदर्भ प्रकार, हालांकि, केवल परस्पर संदर्भ शब्दार्थ या अपरिवर्तनीय शब्दार्थ को लागू कर सकता है; परिवर्तनशील संदर्भ प्रकारों के क्षेत्रों के साथ मूल्य प्रकार या तो परस्पर संदर्भ शब्दार्थ या अजीब संकर शब्दार्थ को लागू करने तक सीमित हैं।