উত্তর:
.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.ক্লাস কিছুই হতে পারে না - রেফারেন্স একটি নাল ইঙ্গিত করতে পারে।
স্ট্রাক্টগুলি আসল মান - এগুলি খালি থাকতে পারে তবে কখনই নਾਲ হয় না। এই কারণে স্ট্রাইকগুলির সর্বদা কোনও পরামিতি ছাড়াই একটি ডিফল্ট নির্মাতা থাকে - তাদের একটি 'আরম্ভের মান' প্রয়োজন।
স্ট্রাক্ট এবং ক্লাসের মধ্যে পার্থক্য:
মাইক্রোসফ্ট ক্লাস এবং স্ট্রাক্টের মধ্যে নির্বাচন করা থেকে ...
থাম্বের নিয়ম হিসাবে, কাঠামোর বেশিরভাগ ধরণের শ্রেণি হওয়া উচিত। তবে, এমন কিছু পরিস্থিতি রয়েছে যেখানে মান ধরণের বৈশিষ্ট্যগুলি স্ট্রাক্ট ব্যবহার করা আরও উপযুক্ত করে তোলে।
✓ একটি struct বিবেচনা একটি বর্গ পরিবর্তে:
- প্রকারের দৃষ্টান্তগুলি যদি ছোট এবং সাধারণত স্বল্পকালীন হয় বা সাধারণত অন্য বস্তুগুলিতে এম্বেড থাকে।
এক্স একটি struct এড়িয়ে চলুন যদি না টাইপ হয়েছে সব নিম্নলিখিত বৈশিষ্ট্য:
- এটি যৌক্তিকভাবে একটি একক মান উপস্থাপন করে, আদিম ধরণের (int, ডাবল, ইত্যাদি) এর অনুরূপ।
- এটির একটি আকারের আকার 16 বাইটের নিচে রয়েছে।
- এটি অপরিবর্তনীয়। (পরিবর্তন করা যাবে না)
- এটি ঘন ঘন বক্স করতে হবে না।
অন্যান্য উত্তরে বর্ণিত সমস্ত পার্থক্য ছাড়াও:
আপনি যদি কোনও ভিডিওর পরে সমস্ত পার্থক্য ব্যাখ্যা করে থাকেন তবে আপনি পার্ট 29 - সি # টিউটোরিয়াল - C # তে ক্লাস এবং স্ট্রাক্টের মধ্যে পার্থক্যটি পরীক্ষা করে দেখতে পারেন ।
ক্লাসের উদাহরণগুলি ম্যানেজড গাদাতে সংরক্ষণ করা হয়। সমস্ত ভেরিয়েবলগুলি 'উদাহরণস্বরূপ' থাকে সেগুলি হিপগুলিতে থাকা উদাহরণের জন্য কেবল একটি রেফারেন্স। কোনও পদ্ধতিতে কোনও বস্তু পাস করার ফলে রেফারেন্সের একটি অনুলিপি পাস করা হয়, বস্তুটি নিজেই নয়।
কাঠামোগুলি (প্রযুক্তিগতভাবে, মান ধরণের) যেখানেই ব্যবহৃত হয় সেখানে সংরক্ষণ করা হয়, অনেকটা আদিম ধরণের মতো। সামগ্রীগুলি রানটাইম দ্বারা যে কোনও সময় এবং কাস্টমাইজড অনুলিপি-নির্মাণকারীকে অনুরোধ না করে অনুলিপি করা যেতে পারে। কোনও পদ্ধতিতে একটি মান প্রকার পাস করার জন্য কোনও কাস্টমাইজযোগ্য কোড না করে আবার পুরো মানটি অনুলিপি করা।
পার্থক্যটি সি ++ / সিএলআই নাম দ্বারা আরও উন্নত করা হয়েছে: "রেফ শ্রেণি "টি প্রথম বর্ণিত হিসাবে একটি শ্রেণি," মান শ্রেণি "দ্বিতীয় বর্ণিত হিসাবে একটি শ্রেণি। সি # দ্বারা ব্যবহৃত "শ্রেণি" এবং "স্ট্রাক্ট" কীওয়ার্ডগুলি কেবল এমন কিছু যা শিখতে হবে।
+------------------------+------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------+
| | 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]
ক্লাসগুলির একটি অ্যারে সহ, আপনি যে মানগুলি আগ্রহী সেগুলি অ্যারের মধ্যে সংরক্ষণ করা হয় না, তবে স্মৃতিতে অন্য কোথাও।
বেশিরভাগ অ্যাপ্লিকেশনগুলির জন্য এই পার্থক্যটি আসলেই কিছু যায় আসে না, তবে উচ্চ পারফরম্যান্স কোডে এটি মেমরির মধ্যে থাকা ডেটার লোকালটিকে প্রভাবিত করবে এবং সিপিইউ ক্যাশের কার্যকারিতাতে বড় প্রভাব ফেলবে। আপনি যখন স্ট্র্টগুলি ব্যবহার করতে পারতেন তখন ক্লাস ব্যবহার করা সিপিইউতে ক্যাশ মিস করার সংখ্যাটি ব্যাপকভাবে বাড়িয়ে তোলে।
একটি আধুনিক সিপিইউ সবচেয়ে ধীর কাজটি সংখ্যার ক্রাঞ্চ করা নয়, এটি মেমরি থেকে ডেটা আনছে, এবং একটি এল 1 ক্যাশে হিট র্যামের ডেটা পড়ার চেয়ে বহুগুণ দ্রুত।
আপনি পরীক্ষা করতে পারেন এমন কিছু কোড এখানে। আমার মেশিনে, শ্রেণীর অ্যারের মাধ্যমে পুনরাবৃত্তি স্ট্রাক্ট অ্যারের থেকে ~ 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
স্ট্রাক্ট মেথডের ভিতরে স্ট্রাক্ট মেথডের ভিতরে মেথডের মান: 20
স্ট্রাক্ট অবজেক্টের মেথড কলের পরে মান 10:
ক্লাস অবজেক্টের প্রাথমিক মান: 10
শ্রেণীর পদ্ধতির অভ্যন্তরে শ্রেণীর পদ্ধতির শ্রেণীর অবজেক্টের অভ্যন্তরের পদ্ধতির মান: 20 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একটি কাঠামো স্পষ্টভাবে সিল করা হয়, একটি শ্রেণি নেই।
একটি স্ট্রাক্ট বিমূর্ত হতে পারে না, একটি শ্রেণি পারে।
একটি কাঠামো কল করতে পারে না: বেস () এর নির্মাতায় যেখানে কোনও শ্রেণীর কোনও সুস্পষ্ট বেস শ্রেণি নেই।
একটি কাঠামো অন্য শ্রেণি বাড়াতে পারে না, একটি শ্রেণি পারে।
কোনও কাঠামো কোনও শ্রেণিবদ্ধ সুরক্ষিত সদস্যদের (উদাহরণস্বরূপ, ক্ষেত্রগুলি, নেস্টেড প্রকারের) ঘোষণা করতে পারে না।
একটি স্ট্রাক্ট বিমূর্ত ফাংশন সদস্যদের ঘোষণা করতে পারে না, একটি বিমূর্ত শ্রেণি পারে।
একটি কাঠামো ভার্চুয়াল ফাংশন সদস্যদের ঘোষণা করতে পারে না, একটি শ্রেণি পারে।
এই নিয়মের একটি ব্যতিক্রম হ'ল স্ট্রাক্টটি সিস্টেম.অবজেক্ট, যেমন, সমান (), এবং গেটহ্যাশকোড (), এবং টসস্ট্রিং () এর ভার্চুয়াল পদ্ধতিগুলিকে ওভাররাইড করতে পারে।
একটি কাঠামো সিল ফাংশন সদস্যদের ঘোষণা করতে পারে না, একটি শ্রেণি পারে।
একটি কাঠামো ওভাররাইড ফাংশন সদস্যদের ঘোষণা করতে পারে না, একটি শ্রেণি পারে।
Objectএকটি বাক্সযুক্ত অনুলিপিটির জন্য একটি রেফারেন্স ধারণ করে
পূর্বে উল্লিখিত হিসাবে: শ্রেণিগুলি রেফারেন্স টাইপ হয় যখন স্ট্রাক্টস সমস্ত ফলাফল সহ মান ধরণের হয়।
নিয়মের অঙ্গুলি হিসাবে ফ্রেমওয়ার্ক ডিজাইনের গাইডলাইনগুলি ক্লাসের পরিবর্তে স্ট্রোকট ব্যবহার করার পরামর্শ দেয় যদি:
"ক্লাস বনাম স্ট্রাক্ট" ধাঁধাটির একটি আকর্ষণীয় কেস রয়েছে - পরিস্থিতি যখন আপনাকে পদ্ধতি থেকে বেশ কয়েকটি ফলাফল ফেরত দিতে হয়: কোনটি ব্যবহার করবেন তা চয়ন করুন। আপনি যদি ভ্যালুটিপল গল্পটি জানেন - আপনি জানেন যে ভ্যালুআপল (স্ট্রাক্ট) যুক্ত করা হয়েছিল কারণ এটি টিউপল (শ্রেণি) আরও কার্যকর হওয়া উচিত। তবে সংখ্যায় এর অর্থ কী? দুটি পরীক্ষা: একটি স্ট্রাক্ট / ক্লাস যার 2 টি ক্ষেত্র রয়েছে, অন্যটি কাঠামো / শ্রেণীর সাথে 8 টি ক্ষেত্র রয়েছে (মাত্রা 4 এর বেশি হবে - ক্লাসটি আরও কার্যকর হওয়া উচিত শর্তাবলীর প্রসেসরের টিকের ক্ষেত্রে কাঠামো, তবে অবশ্যই জিসি লোডটিও বিবেচনা করা উচিত) )।
PS সুনির্দিষ্ট ক্ষেত্রে 'সংগ্রহ বা স্ট্রাক্ট সহ শ্রেণীর' জন্য আরও একটি মানদণ্ড রয়েছে: 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;
}
}
}
}স্ট্রাক্টগুলি আসল মান - এগুলি খালি থাকতে পারে তবে কখনই নਾਲ হয় না
এটি সত্য, তবে এটিও নোট করুন যে নেট 2 স্ট্রাইক হিসাবে একটি নুলযোগ্য সংস্করণ সমর্থন করে এবং সি # এটি ব্যবহারকে আরও সহজ করার জন্য কিছু সিনট্যাকটিক চিনি সরবরাহ করে।
int? value = null;
value = 1;(object)(default(int?)) == nullযা আপনি অন্য কোনও মান ধরণের সাথে করতে পারবেন না, কারণ এখানে চিনি ছাড়াও আরও কিছু রয়েছে। একমাত্র চিনির int?জন্য Nullable<int>।
কোনও আদিম মান ধরণের বা কাঠামোর ধরণের প্রতিটি পরিবর্তনশীল বা ক্ষেত্রের সমস্ত ক্ষেত্র (পাবলিক এবং বেসরকারী) সহ সেই ধরণের একটি অনন্য উদাহরণ রয়েছে। বিপরীতে, ভেরিয়েবল বা রেফারেন্স প্রকারের ক্ষেত্রগুলি শূন্য করে থাকতে পারে বা অন্য কোনও জায়গায় সঞ্চিত কোনও অবজেক্টের রেফারেন্স করতে পারে, যেখানে অন্যান্য উল্লেখগুলির সংখ্যাও উপস্থিত থাকতে পারে। কাঠামোর ক্ষেত্রগুলি সেই কাঠামোর ধরণের পরিবর্তনশীল বা ক্ষেত্রের মতো একই জায়গায় সংরক্ষণ করা হবে, যা হয় স্ট্যাকের উপরে থাকতে পারে বা অন্য কোনও হিপ অবজেক্টের অংশ হতে পারে ।
কোনও আদিম মান ধরণের একটি পরিবর্তনশীল বা ক্ষেত্র তৈরি করা এটি একটি ডিফল্ট মান সহ তৈরি করবে; কাঠামোর ধরণের ভেরিয়েবল বা ফিল্ড তৈরি করা একটি নতুন উদাহরণ তৈরি করবে, এতে সমস্ত ক্ষেত্রকে ডিফল্ট পদ্ধতিতে তৈরি করা হবে। একটি রেফারেন্স টাইপের একটি নতুন উদাহরণ তৈরি করা ডিফল্ট পদ্ধতিতে সমস্ত ক্ষেত্র তৈরি করে এবং পরে প্রকারের উপর নির্ভর করে alচ্ছিক অতিরিক্ত কোড চালিয়ে শুরু হবে।
একটি আদিম প্রকারের একটি পরিবর্তনশীল বা ক্ষেত্রের অনুলিপি করা অন্যটির সাথে অনুলিপি করবে। কাঠামোর ধরণের ক্ষেত্রের একটি পরিবর্তনশীল বা ক্ষেত্রটিকে অন্যটিতে অনুলিপি করা পূর্ববর্তী উদাহরণের সমস্ত ক্ষেত্র (সরকারী এবং ব্যক্তিগত) অনুলিপি করে দেবে। একটি পরিবর্তনশীল বা রেফারেন্সের ক্ষেত্রের ক্ষেত্রটিকে অন্যটিতে অনুলিপি করার ফলে পরবর্তীটি পূর্ববর্তী (যদি কোনও হয়) হিসাবে একই উদাহরণটি উল্লেখ করবে।
এটি লক্ষণীয় গুরুত্বপূর্ণ যে সি ++ এর মতো কিছু ভাষায়, কোনও ধরণের শব্দার্থক আচরণ এটি কীভাবে সংরক্ষণ করা হয় তার থেকে পৃথক, তবে এটি নেট। এর ক্ষেত্রে সত্য নয়। যদি কোনও প্রকার পরিবর্তনীয় মান শব্দার্থক প্রয়োগ করে, সেই ধরণের একটি ভেরিয়েবলের অনুলিপি করে অন্যের প্রথমটির বৈশিষ্ট্য অনুলিপি করে, দ্বিতীয় দ্বারা উল্লেখ করা হয়, এবং দ্বিতীয়টির কোনও সদস্যকে পরিবর্তনের জন্য এটি ব্যবহার করে দ্বিতীয় ঘটনাটি পরিবর্তিত হতে পারে , তবে প্রথমটি নয়। যদি কোনও প্রকার পরিবর্তনীয় রেফারেন্স শব্দার্থক প্রয়োগ করে, একটি ভেরিয়েবলের অন্যটিতে অনুলিপি করে এবং দ্বিতীয়টির সদস্যকে বস্তুর রূপান্তর করতে ব্যবহার করে তবে প্রথম ভেরিয়েবল দ্বারা চিহ্নিত বস্তুকে প্রভাবিত করবে; অপরিবর্তনীয় শব্দার্থবিজ্ঞানযুক্ত প্রকারগুলি রূপান্তরকে অনুমতি দেয় না, তাই অনুলিপি করা কোনও নতুন বিষয় তৈরি করে না বা প্রথমটির জন্য অন্য একটি রেফারেন্স তৈরি করে কিনা তা নির্বিচারে বিবেচনা করে না।
.NET- এ, মান ধরণের পক্ষে উপরের যে কোনও শব্দার্থক প্রয়োগ করা সম্ভব, যদি তাদের সমস্ত ক্ষেত্র একইভাবে করতে পারে। একটি রেফারেন্স টাইপ, তবে কেবল পরিবর্তনযোগ্য রেফারেন্স শব্দার্থ বা অপরিবর্তনীয় শব্দার্থক প্রয়োগ করতে পারে; পরিবর্তনীয় রেফারেন্স ধরণের ক্ষেত্রগুলির সাথে মানগুলি প্রকারভেদ রেফারেন্স শব্দার্থক বা অদ্ভুত হাইব্রিড শব্দার্থবিজ্ঞান প্রয়োগের মধ্যেই সীমাবদ্ধ।