ක්ෂේත්ර සහ ගුණාංග එකිනෙකට සමාන බව පෙනුනද ඒවා සම්පූර්ණයෙන්ම වෙනස් භාෂා අංග 2 කි.
පන්ති මට්ටමින් දත්ත ගබඩා කරන එකම යාන්ත්‍රණය ක්ෂේත්ර වේ. ක්ෂේත්ර විෂය පථයේ සංකල්පමය වශයෙන් විචල්ය වේ. ඔබේ පංති (වස්තු) සඳහා සමහර දත්ත ගබඩා කිරීමට ඔබට අවශ්ය නම් ඔබට ක්ෂේත්ර භාවිතා කළ යුතුය. වෙනත් විකල්පයක් නැත. දේපලවලට කිසිදු දත්තයක් ගබඩා කළ නොහැකි වුවද, ඔවුන්ට එය කළ හැකි බව පෙනේ. බෙල්ල බලන්න.
අනෙක් අතට දේපල කිසි විටෙකත් දත්ත ගබඩා නොකරයි. ඒවා ක්ෂේත්රයන් හා සමාන ආකාරයකින් සින්ටැක්ටිකල් ලෙස හැඳින්විය හැකි ක්රම යුගල (ලබා ගැනීම සහ සැකසීම) වන අතර බොහෝ විට ඒවා යම් ව්‍යාකූලතාවයක මූලාශ්‍රය වන ක්ෂේත්ර වෙත ප්රවේශ වීමට (කියවීමට හෝ ලිවීමට) පිවිසේ. නමුත් දේපල ක්රම (ස්ථාවර මූලාකෘති වැනි යම් සීමාවන් සහිතව) නිත්‍ය C # ක්රම නිසා ඔවුන්ට නිත්‍ය ක්‍රමවලින් කළ හැකි ඕනෑම දෙයක් කළ හැකිය. එයින් අදහස් කරන්නේ ඔවුන්ට කේත පේළි 1000 ක් තිබිය හැකි අතර, ඔවුන්ට ව්‍යතිරේකයන් විසි කළ හැකිය, වෙනත් ක්රම අමතන්න, අථත්ය, වියුක්ත හෝ අභිබවා යා හැකිය. ගුණාංග විශේෂ වන්නේ කුමක් ද, C # සම්පාදකයා විසින් විශේෂිත ගුණාංග සෙවීම සඳහා භාවිතා කළ හැකි එක්රැස්වීම් තුළට අමතර පාර-දත්ත කිහිපයක් ගබඩා කරයි - පුළුල් ලෙස භාවිතා කරන ලක්ෂණය.
දේපල ක්රම ලබා ගැනීම සහ සැකසීම පහත සඳහන් මූලාකෘති ඇත.
PROPERTY_TYPE get();
void set(PROPERTY_TYPE value);
එබැවින් ක්ෂේත්‍රයක් සහ ඊට අනුරූප ක්රම 2 ක් නිර්වචනය කිරීමෙන් ගුණාංග 'අනුකරණය' කළ හැකිය.
class PropertyEmulation
{
private string MSomeValue;
public string GetSomeValue()
{
return(MSomeValue);
}
public void SetSomeValue(string value)
{
MSomeValue=value;
}
}
සම්මත C ++ වැනි දේපල සඳහා සහය නොදක්වන ක්‍රමලේඛන භාෂාවන් සඳහා එවැනි දේපල අනුකරණයන් සාමාන්‍ය වේ. C # හි ඔබ සැමවිටම ඔබේ ක්ෂේත්ර වෙත ප්රවේශ වන ආකාරය ලෙස දේපල වලට වැඩි කැමැත්තක් දැක්විය යුතුය.
දත්ත පමණක් ගබඩා කළ හැක්කේ ක්ෂේත්‍රයන්ට පමණක් බැවින්, එයින් අදහස් වන්නේ පන්තියේ වැඩි ක්ෂේත්ර ප්‍රමාණයක් අඩංගු වන බැවින් එවැනි පන්තියේ වැඩි මතක වස්තු පරිභෝජනය කරනු ඇති බවයි. අනෙක් අතට, පන්තියකට නව ගුණාංග එකතු කිරීමෙන් එවැනි පංතියේ වස්තූන් විශාල නොවේ. මෙන්න උදාහරණය.
class OneHundredFields
{
public int Field1;
public int Field2;
...
public int Field100;
}
OneHundredFields Instance=new OneHundredFields() // Variable 'Instance' consumes 100*sizeof(int) bytes of memory.
class OneHundredProperties
{
public int Property1
{
get
{
return(1000);
}
set
{
// Empty.
}
}
public int Property2
{
get
{
return(1000);
}
set
{
// Empty.
}
}
...
public int Property100
{
get
{
return(1000);
}
set
{
// Empty.
}
}
}
OneHundredProperties Instance=new OneHundredProperties() // !!!!! Variable 'Instance' consumes 0 bytes of memory. (In fact a some bytes are consumed becasue every object contais some auxiliarity data, but size doesn't depend on number of properties).
දේපල ක්‍රමවලට ඕනෑම දෙයක් කළ හැකි වුවද, බොහෝ විට ඒවා වස්තු ක්ෂේත්‍රයට ප්රවේශ වන ක්‍රමයක් ලෙස සේවය කරයි. ඔබට වෙනත් පංතිවලට ප්රවේශ විය හැකි ක්ෂේත්‍රයක් කිරීමට අවශ්ය නම් ඔබට ක්රම 2 කින් කළ හැකිය.
- ක්ෂේත්ර පොදු බවට පත් කිරීම - සුදුසු නොවේ.
- ගුණාංග භාවිතා කිරීම.
මෙන්න පොදු ක්ෂේත්ර භාවිතා කරන පන්තියක්.
class Name
{
public string FullName;
public int YearOfBirth;
public int Age;
}
Name name=new Name();
name.FullName="Tim Anderson";
name.YearOfBirth=1979;
name.Age=40;
කේතය පරිපූර්ණ ලෙස වලංගු වන අතර, සැලසුම් දෘෂ්ටි කෝණයෙන් බලන විට, එහි අඩුපාඩු කිහිපයක් තිබේ. ක්ෂේත්ර කියවීමට හා ලිවීමට හැකි බැවින්, පරිශීලකයාට ක්ෂේත්ර වෙත ලිවීම වැළැක්විය නොහැක. ඔබට readonlyයතුරුපදය යෙදිය හැකිය , නමුත් මේ ආකාරයෙන්, ඔබට කියවිය හැකි ක්ෂේත්ර ආරම්භ කළ යුත්තේ ඉදිකිරීම්කරු තුළ පමණි. එපමණක්ද නොව, ඔබගේ ක්ෂේත්ර වල වලංගු නොවන අගයන් ගබඩා කිරීමට කිසිවක් ඔබව වළක්වන්නේ නැත.
name.FullName=null;
name.YearOfBirth=2200;
name.Age=-140;
කේතය වලංගු වේ, සියලු පැවරුම් තර්කානුකූල නොවන නමුත් ක්රියාත්මක වේ. Agenegative ණ අගයක් ඇති අතර YearOfBirthඑය අනාගතයේ දී බොහෝ දුරට වන අතර එය වයසට අනුරූප නොවන අතර FullNameඑය ශුන්‍ය වේ. ක්ෂේත්ර සමඟ පරිශීලකයින්ට class Nameඑවැනි වැරදි කිරීම වලක්වා ගත නොහැක .
මෙන්න මෙම ගැටළු නිරාකරණය කරන ගුණාංග සහිත කේතයක්.
class Name
{
private string MFullName="";
private int MYearOfBirth;
public string FullName
{
get
{
return(MFullName);
}
set
{
if (value==null)
{
throw(new InvalidOperationException("Error !"));
}
MFullName=value;
}
}
public int YearOfBirth
{
get
{
return(MYearOfBirth);
}
set
{
if (MYearOfBirth<1900 || MYearOfBirth>DateTime.Now.Year)
{
throw(new InvalidOperationException("Error !"));
}
MYearOfBirth=value;
}
}
public int Age
{
get
{
return(DateTime.Now.Year-MYearOfBirth);
}
}
public string FullNameInUppercase
{
get
{
return(MFullName.ToUpper());
}
}
}
පන්තියේ යාවත්කාලීන කළ අනුවාදයට පහත වාසි ඇත.
FullNameසහ YearOfBirthඅවලංගු අගයන් සඳහා පරීක්ෂා කරනු ලැබේ.Ageලිවිය නොහැක. එය YearOfBirthවර්තමාන වර්ෂයේ සිට ගණනය කර ඇත .- නව දේපලක් UPPER CASE
FullNameInUppercaseබවට පරිවර්තනය FullNameවේ. මෙය දේපල භාවිතය පිළිබඳ කුඩා උපක්‍රමශීලී උදාහරණයකි, එහිදී පරිශීලකයාට වඩාත් සුදුසු ආකෘතියේ ක්ෂේත්ර අගයන් ඉදිරිපත් කිරීමට දේපල බහුලව භාවිතා වේ - නිදසුනක් ලෙස නිශ්චිත සංඛ්‍යාත්මක DateTimeආකෘතියක් මත වත්මන් පෙදෙසි භාවිතා කිරීම .
මේ හැරුණු විට, ගුණාංග අථත්ය හෝ අභිබවා යන ලෙස අර්ථ දැක්විය හැකිය - ඒවා නිතිපතා .NET ක්රම නිසා. නිත්‍ය ක්රම සඳහා වන දේපල ක්රම සඳහා එකම නීති අදාළ වේ.
C # දේපල ක්‍රමවල දර්ශක පරාමිතියක් ඇති ගුණාංග වන දර්ශක සඳහා ද සහාය දක්වයි. මෙන්න උදාහරණය.
class MyList
{
private string[] MBuffer;
public MyList()
{
MBuffer=new string[100];
}
public string this[int Index]
{
get
{
return(MBuffer[Index]);
}
set
{
MBuffer[Index]=value;
}
}
}
MyList List=new MyList();
List[10]="ABC";
Console.WriteLine(List[10]);
C # 3.0 මඟින් ඔබට ස්වයංක්රීය ගුණාංග අර්ථ දැක්වීමට ඉඩ ලබා දේ. මෙන්න උදාහරණය.
class AutoProps
{
public int Value1
{
get;
set;
}
public int Value2
{
get;
set;
}
}
class AutoPropsගුණාංග පමණක් අඩංගු වුවද (හෝ එය පෙනේ), එයට අගයන් 2 ක් ගබඩා කළ හැකි අතර මෙම පන්තියේ වස්තූන්ගේ ප්‍රමාණය sizeof(Value1)+sizeof(Value2)= 4 + 4 = 8 බයිට් වලට සමාන වේ.
මේ සඳහා හේතුව සරල ය. ඔබ ස්වයංක්රීය දේපලක් නිර්වචනය කරන විට, C # සම්පාදකයා විසින් සැඟවුණු ක්ෂේත්‍රයක් සහ මෙම සැඟවුණු ක්ෂේත්‍රයට ප්රවේශ වන දේපල ක්රම සහිත දේපලක් අඩංගු ස්වයංක්රීය කේතයක් ජනනය කරයි. මෙන්න කේත සම්පාදකයා නිෂ්පාදනය කරයි.
සම්පාදනය කරන ලද එකලස් කිරීමෙන් ILSpy විසින් ජනනය කරන ලද කේතයක් මෙන්න . පන්තියේ ජනනය කරන ලද සැඟවුණු ක්ෂේත්ර සහ ගුණාංග අඩංගු වේ.
internal class AutoProps
{
[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private int <Value1>k__BackingField;
[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private int <Value2>k__BackingField;
public int Value1
{
[CompilerGenerated]
get
{
return <Value1>k__BackingField;
}
[CompilerGenerated]
set
{
<Value1>k__BackingField = value;
}
}
public int Value2
{
[CompilerGenerated]
get
{
return <Value2>k__BackingField;
}
[CompilerGenerated]
set
{
<Value2>k__BackingField = value;
}
}
}
එබැවින්, ඔබට පෙනෙන පරිදි, සම්පාදකයා තවමත් අගයන් ගබඩා කිරීම සඳහා ක්ෂේත්ර භාවිතා කරයි - වස්තු තුළ අගයන් ගබඩා කරන්නේ කෙසේද යන්න ක්ෂේත්ර පමණක් වන බැවින්.
ඔබට පෙනෙන පරිදි, දේපල හා ක්ෂේත්ර වලට සමාන භාවිත සින්ටැක්ස් තිබුණද ඒවා බෙහෙවින් වෙනස් සංකල්ප වේ. ඔබ ස්වයංක්රීය ගුණාංග හෝ සිදුවීම් භාවිතා කළත් - සැඟවුණු ක්ෂේත්ර ජනනය කරනු ලබන්නේ සැබෑ දත්ත ගබඩා කර ඇති සම්පාදකයා විසිනි.
ඔබට ක්ෂේත්ර වටිනාකමක් බාහිර ලෝකයට ලබා දීමට අවශ්ය නම් (ඔබේ පන්තියේ පරිශීලකයින්) පොදු හෝ ආරක්ෂිත ක්ෂේත්ර භාවිතා නොකරන්න. ක්ෂේත්ර සෑම විටම පුද්ගලික ලෙස සලකුණු කළ යුතුය. ගුණාංග මඟින් ඔබට වටිනාකම් පරීක්ෂා කිරීම, හැඩතල ගැන්වීම, පරිවර්තනය කිරීම ආදිය කළ හැකි අතර සාමාන්‍යයෙන් ඔබේ කේතය ආරක්ෂිත, කියවිය හැකි සහ අනාගත වෙනස් කිරීම් සඳහා පුළුල් කළ හැකිය.