यद्यपि फ़ील्ड और गुण एक-दूसरे के समान दिखते हैं, वे 2 पूरी तरह से अलग भाषा तत्व हैं।
फ़ील्ड स्तर पर डेटा संग्रहीत करने के लिए फ़ील्ड्स एकमात्र तंत्र हैं। फ़ील्ड वैचारिक रूप से वर्ग दायरे में होते हैं। यदि आप अपनी कक्षाओं (वस्तुओं) के उदाहरणों के लिए कुछ डेटा संग्रहीत करना चाहते हैं, तो आपको फ़ील्ड का उपयोग करने की आवश्यकता है। और कोई विकल्प नहीं है। गुण किसी भी डेटा को संग्रहीत नहीं कर सकते हैं, भले ही ऐसा लग सकता है कि वे ऐसा करने में सक्षम हैं। नीचे देखें।
दूसरी ओर गुण कभी भी डेटा संग्रहीत नहीं करते हैं। वे केवल तरीकों की जोड़ी हैं (प्राप्त करें और सेट करें) को समान रूप से फ़ील्ड के रूप में कहा जा सकता है और ज्यादातर मामलों में वे खेतों (पढ़ने या लिखने के लिए) का उपयोग करते हैं, जो कुछ भ्रम का स्रोत है। लेकिन क्योंकि संपत्ति के तरीके (कुछ सीमाएं जैसे निश्चित प्रोटोटाइप के साथ) नियमित सी # विधियां हैं जो वे कर सकते हैं जो नियमित तरीके कर सकते हैं। इसका मतलब है कि उनके पास कोड की 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;
कोड मान्य है, सभी असाइनमेंट निष्पादित किए जाएंगे, हालांकि वे अतार्किक हैं। Ageएक नकारात्मक मूल्य है, 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;
}
}
}
इसलिए, जैसा कि आप देख सकते हैं, संकलक अभी भी मूल्यों को संग्रहीत करने के लिए फ़ील्ड का उपयोग करता है - चूंकि फ़ील्ड एकमात्र तरीका है कि वस्तुओं में मूल्यों को कैसे संग्रहीत किया जाए।
तो जैसा कि आप देख सकते हैं, हालांकि गुणों और क्षेत्रों में समान उपयोग सिंटैक्स हैं वे बहुत अलग अवधारणाएं हैं। यहां तक कि अगर आप स्वचालित गुणों या घटनाओं का उपयोग करते हैं - तो छिपे हुए फ़ील्ड संकलक द्वारा उत्पन्न होते हैं जहां वास्तविक डेटा संग्रहीत होते हैं।
यदि आपको किसी फ़ील्ड मान को बाहरी दुनिया (आपकी श्रेणी के उपयोगकर्ता) तक पहुँच योग्य बनाने की आवश्यकता है, तो सार्वजनिक या संरक्षित फ़ील्ड का उपयोग न करें। फ़ील्ड को हमेशा निजी के रूप में चिह्नित किया जाना चाहिए। गुण आपको मूल्य जांच, प्रारूपण, रूपांतरण आदि बनाने की अनुमति देते हैं और आम तौर पर भविष्य के संशोधनों के लिए आपके कोड को अधिक सुरक्षित, अधिक पठनीय और अधिक विस्तारणीय बनाते हैं।