අනුගමනය කළ යුතු පොදු රීතිය නම්, ව්‍යුහයන් කුඩා, සරල (එක්-මට්ටමේ) ආශ්‍රිත දේපල එකතුවක් විය යුතු අතර ඒවා නිර්මාණය කිරීමෙන් පසු වෙනස් කළ නොහැකි ය; වෙනත් ඕනෑම දෙයක් සඳහා, පන්තියක් භාවිතා කරන්න.
සී # ඉතා හොඳයි, ව්‍යුහයන් සහ පංතිවල අර්ථ දැක්වීමේ මූල පදය හැර ප්‍රකාශයේ පැහැදිලි වෙනස්කම් නොමැත; එබැවින්, ඔබට ව්‍යුහයක් පන්තියකට “උත්ශ්‍රේණිගත” කිරීමට අවශ්ය යැයි ඔබට හැඟේ නම් හෝ ඊට ප්‍රතිවිරුද්ධ ලෙස පන්තියක් ව්‍යුහයකට පහත හෙලන්න, එය බොහෝ විට මූලික පදය වෙනස් කිරීමේ සරල කාරණයකි (තවත් ගොචා කිහිපයක් තිබේ; ව්‍යුහයන්ට ව්‍යුත්පන්න කළ නොහැක වෙනත් ඕනෑම පන්තියකින් හෝ ව්‍යුහාත්මක වර්ගයකින් වන අතර ඔවුන්ට පෙරනිමි පරාමිති රහිත ඉදිකිරීම්කරුවෙකු පැහැදිලිව නිර්වචනය කළ නොහැක).
මම "බොහෝ දුරට" කියමි, මන්දයත් ව්‍යුහයන් ගැන දැන ගැනීමට වඩා වැදගත් දෙය නම්, ඒවා වටිනාකම් වර්ග බැවින් ඒවා පන්ති (යොමු වර්ග) ලෙස සැලකීම වේදනාව හා එකහමාරක් විය හැකිය. විශේෂයෙන්, ව්‍යුහයක ගුණාංග විකෘති කිරීම අනපේක්ෂිත ලෙස හැසිරීමට හේතු වේ.
නිදසුනක් ලෙස, ඔබට A සහ B යන ගුණාංග දෙකක් සහිත පන්තියේ සරල පන්තියක් ඇති බව පවසන්න. ඔබ මෙම පන්තියේ පිටපතක් ක්ෂණිකව සකසා, A සහ B ආරම්භ කර, පසුව වෙනත් ක්‍රමයකට යොමු කරන්න. එම ක්රමය මඟින් A සහ B තවදුරටත් වෙනස් කරයි. නැවත ඇමතුම් ශ්‍රිතයේ (උදාහරණය නිර්මාණය කළ), ඔබේ නිදසුනෙහි A සහ B වලට ඇමතුම් ක්රමය මඟින් ලබා දුන් අගයන් ඇත.
දැන්, ඔබ එය ව්‍යුහයක් බවට පත් කරයි. ගුණාංග තවමත් විකෘති වී ඇත. ඔබ පෙර මෙන් එකම සින්ටැක්ස් සමඟ එකම මෙහෙයුම් සිදු කරයි, නමුත් දැන්, A සහ B හි නව අගයන් ක්රමය ඇමතීමෙන් පසුව නොවේ. සිදුවුයේ කුමක් ද? හොඳයි, ඔබේ පන්තිය දැන් ව්‍යුහයකි, එයින් අදහස් වන්නේ එය අගය වර්ගයකි. ඔබ අගය වර්ගයක් ක්‍රමයකට යොමු කරන්නේ නම්, පෙරනිමිය (පිටත හෝ ref යතුරු පදයක් නොමැතිව) “අගය අනුව” සම්මත කිරීමයි; ක්‍රමයේ භාවිතය සඳහා නිදසුනෙහි නොගැඹුරු පිටපතක් සාදනු ලබන අතර, ආරම්භක අවස්ථාව නොවෙනස්ව පවතින විට ක්රමය විනාශ වූ විට විනාශ වේ.
මෙම ඊටත් වඩා ඔබ ඔබේ struct සාමාජිකයෙකු ලෙස සඳහනක් වර්ගය ඇති කිරීමට නම් (භව්ය ලෙසින් නොව, අවුල් බවට පත් අතිශය සියලු ම පාහේ අවස්ථාවල දී නරක පුරුදු); පංතිය ක්ලෝන නොකෙරේ (එය ව්‍යුහයේ සඳහනක් පමණි), එබැවින් ව්‍යුහයේ වෙනස්වීම් මුල් වස්තුවට බලපාන්නේ නැත, නමුත් struct හි උප පංතියේ වෙනස්වීම් ඇමතුම් කේතයේ උදාහරණයට බලපායි. මෙය ඉතා පහසුවෙන් නොගැලපෙන තත්වයන් තුළ විකෘති ව්‍යුහයන් තැබිය හැකි අතර එමඟින් දෝෂ ඇති විය හැකි අතර සැබෑ ගැටළුව පවතින තැනට බොහෝ away තින්.
මේ හේතුව නිසා, C # හි ඇති සෑම අධිකාරියක්ම පාහේ පවසන්නේ ඔබේ ව්‍යුහයන් සැමවිටම වෙනස් කළ නොහැකි බවයි; වස්තුවක් තැනීමේදී පමණක් දේපලවල අගයන් නියම කිරීමට පාරිභෝගිකයාට ඉඩ දෙන්න, එම අවස්ථාවෙහි අගයන් වෙනස් කිරීමට කිසි විටෙකත් ක්‍රමයක් සපයන්නේ නැත. කියවීමට පමණක් ඇති ක්ෂේත්ර, හෝ ලබා ගත හැකි ගුණාංග රීතිය වේ. පාරිභෝගිකයාට වටිනාකම වෙනස් කිරීමට අවශ්ය නම්, ඔවුන්ට අවශ්ය වෙනස්වීම් සමඟ පැරණි වස්තුවේ වටිනාකම් මත පදනම්ව නව වස්තුවක් නිර්මාණය කළ හැකිය, නැතහොත් ඔවුන්ට එයම කරන ක්‍රමවේදයක් කැඳවිය හැකිය. මෙය ඔබේ ව්‍යුහයේ එක් අවස්ථාවක් එක් සංකල්පීය “වටිනාකමක්” ලෙස සැලකීමට බල කරයි, වෙන් කළ නොහැකි සහ අනෙක් සියල්ලන්ට වඩා වෙනස් (නමුත් සමහර විට සමාන විය හැකිය). ඔවුන් ඔබේ වර්ගය මගින් ගබඩා කර ඇති "වටිනාකමක්" මත මෙහෙයුමක් සිදු කරන්නේ නම්, ඔවුන්ට ඔවුන්ගේ ආරම්භක අගයට වඩා වෙනස් "වටිනාකමක්" ලැබේ,
හොඳ උදාහරණයක් සඳහා, ඩේටයිම් වර්ගය දෙස බලන්න. ඔබට ඩේටයිම් නිදසුනක කිසිදු ක්ෂේත්‍රයක් කෙලින්ම පැවරිය නොහැක; ඔබ එක්කෝ නව එකක් සෑදිය යුතුය, නැතහොත් පවතින එකක් පිළිබඳව ක්‍රමවේදයක් අමතන්න, එය නව අවස්ථාවක් බිහි කරයි. මෙයට හේතුව දිනය හා වේලාව අංක 5 වැනි “අගයක්” වන අතර අංක 5 ට වෙනස් වීමෙන් 5 නොවන නව අගයක් ලැබෙනු ඇත. 5 + 1 = 6 යන්නෙන් අදහස් නොකෙරේ 5 දැන් 6 යි ඔබ එයට 1 ක් එකතු කළ නිසා. දිනය වේලාවන් එකම ආකාරයකින් ක්‍රියා කරයි; 12:00 "බවට පත් නොවේ" 12:01 ඔබ විනාඩියක් එකතු කළහොත්, ඒ වෙනුවට ඔබට නව අගයක් ලැබෙනු ඇත 12:01 එය 12:00 ට වඩා වෙනස් වේ. මෙය ඔබගේ වර්ගය සඳහා තාර්කික තත්වයක් නම් (.NET වෙත ගොඩනගා නැති හොඳ සංකල්පීය උදාහරණ නම් මුදල්, දුර, බර සහ UOM හි වෙනත් ප්‍රමාණයන් ය. එහිදී මෙහෙයුම් වල වටිනාකමෙහි සියලු කොටස් සැලකිල්ලට ගත යුතුය), ඉන්පසු struct එකක් භාවිතා කර ඒ අනුව එය සැලසුම් කරන්න. වස්තුවක උප අයිතම ස්වාධීනව විකෘති විය යුතු වෙනත් බොහෝ අවස්ථාවන්හිදී, පන්තියක් භාවිතා කරන්න.