2012-06-22 32 views
29

में गेटर्स/सेटर्स के संक्षिप्त और सरल उदाहरण की तलाश में मुझे सी # भाषा में गेटर्स और सेटर्स की अवधारणा को समझने में समस्या हो रही है। Objective-C जैसी भाषाओं में, वे सिस्टम का एक अभिन्न हिस्सा प्रतीत होते हैं, लेकिन सी # (में इतना नहीं है, जहां तक ​​मैं बता सकता हूं)। मैंने पुस्तकों और लेखों को पहले से ही पढ़ा है, इसलिए मेरा सवाल यह है कि सी # में गेटर्स & सेटर्स समझने वाले लोगों के लिए, यदि आप एक पूर्ण शुरुआत करने वाले व्यक्ति को अवधारणा पढ़ रहे थे तो आप किस उदाहरण का व्यक्तिगत रूप से उपयोग करेंगे (इसमें कुछ पंक्तियां शामिल होंगी कोड) के रूप में कोड?सी #

+0

यह सुंदर व्यापक है। विशेष रूप से आपको सी # गुणों के साथ परेशानी क्यों दे रही है? – arcain

+0

यह * संभवतः * http://stackoverflow.com/questions/1209359/properties-and-methods – arcain

+0

का डुप्लिकेट है, मुझे आश्चर्य है कि उद्देश्य सी की तुलना में सी # में गेटर्स/सेटर्स में क्या गुम है? – Vlad

उत्तर

13

सी #, Properties में अपने गेटर्स और सेटर्स का प्रतिनिधित्व करते हैं।

public class PropertyExample 
{ 
    private int myIntField = 0; 

    public int MyInt 
    { 
     // This is your getter. 
     // it uses the accessibility of the property (public) 
     get 
     { 
      return myIntField; 
     } 
     // this is your setter 
     // Note: you can specifiy different accessibility 
     // for your getter and setter. 
     protected set 
     { 
      // You can put logic into your getters and setters 
      // since they actually map to functions behind the scenes 
      DoSomeValidation(value) 
      { 
       // The input of the setter is always called "value" 
       // and is of the same type as your property definition 
       myIntField = value; 
      } 
     } 
    } 
} 

तुम सिर्फ एक क्षेत्र की तरह इस संपत्ति का उपयोग होगा:

यहाँ एक उदाहरण है। उदाहरण के लिए:

PropertyExample example = new PropertyExample(); 
example.MyInt = 4; // sets myIntField to 4 
Console.WriteLine(example.MyInt); // prints 4 

कुछ अन्य बातें ध्यान रखें: 1) आप दोनों एक गेटर और एक सेटर specifiy की जरूरत नहीं है, आप या तो एक को छोड़ सकते हैं।

2) गुण आपके पारंपरिक गेटर और सेटर के लिए सिर्फ "सिंटेक्टिक चीनी" हैं। कंपाइलर वास्तव में दृश्यों के पीछे get_ और set_ फ़ंक्शंस (संकलित आईएल में) का निर्माण करेगा और उन कार्यों में आपकी संपत्ति के सभी संदर्भों को मानचित्र करेगा।

11

अधिकांश भाषाएं इस तरह से करती हैं, और आप इसे सी # में भी कर सकते हैं।

public void setRAM(int RAM) 
    { 
     this.RAM = RAM; 
    } 
    public int getRAM() 
    { 
     return this.RAM; 
    } 

लेकिन सी # भी इस के लिए एक अधिक सुरुचिपूर्ण समाधान देता है:

public class Computer 
    { 
     int ram; 
     public int RAM 
     { 
      get 
      { 
        return ram; 
      } 
      set 
      { 
        ram = value; // value is a reserved word and it is a variable that holds the input that is given to ram (like in the example below) 
      } 
     } 
    } 

और के साथ बाद में पहुँच यह।

Computer comp = new Computer(); 
    comp.RAM = 1024; 
    int var = comp.RAM; 

सी # के नए संस्करण के लिए यह और भी बेहतर है:

public class Computer 
{ 
    public int RAM { get; set; } 
} 

और बाद में:

Computer comp = new Computer(); 
comp.RAM = 1024; 
int var = comp.RAM; 
+0

खराब मूल्य के मामले में सेटर को अनदेखा करने के लिए वास्तव में 'मूल्य' – jskidd3

0

यह होगा एक प्राप्त/कोड संभव सबसे छोटी राशि का उपयोग सी # में निर्धारित किया है। आपको auto-implemented properties in C# 3.0+ मिलते हैं।

public class Contact 
{ 
    public string Name { get; set; } 
} 
1

सरल उदाहरण

public class Simple 
    { 
     public int Propery { get; set; } 
    } 
1

जहां तक ​​मेरा getters और setters को समझने कैप्सूलीकरण सुधार करने के लिए कर रहे हैं। सी # में उनके बारे में कुछ भी जटिल नहीं है।

आप इस तरह वस्तु पर की संपत्ति को परिभाषित:

int m_colorValue = 0; 
public int Color 
{ 
    set { m_colorValue = value; } 
    get { return m_colorValue; } 
} 

यह सबसे सरल प्रयोग है। यह मूल रूप से एक आंतरिक चर सेट करता है या इसके मूल्य को पुनः प्राप्त करता है। आप इस प्रकार का संपत्ति का उपयोग करें:

someObject.Color = 222; // sets a color 222 
int color = someObject.Color // gets the color of the object 

अंततः आप इस तरह setters या टिककर खेल में मूल्य पर कुछ प्रसंस्करण कर सकता है:

public int Color 
{ 
    set { m_colorValue = value + 5; } 
    get { return m_colorValue - 30; } 
} 

आप सेट या प्राप्त छोड़ते हैं, अपनी संपत्ति हो जाएगा केवल पढ़ें या लिखें। इस तरह मैं सामान को समझता हूं।

3

सी # गुण है जो आप के लिए भारी उठाने के सबसे अधिक है ...

परिचय यानी

public string Name { get; set; } 

लिखने के लिए एक सी # शॉर्टकट ...

private string _name; 

public string getName { return _name; } 
public void setName(string value) { _name = value; } 

मूल रूप से ही टिककर खेल है और सेटर्स सिर्फ encapsulation की मदद करने के साधन हैं। जब आप कक्षा बनाते हैं तो आपके पास कई वर्ग चर होते हैं जो शायद आप अन्य कक्षाओं में बेनकाब करना चाहते हैं ताकि वे आपके द्वारा संग्रहीत डेटा के कुछ झलक प्राप्त कर सकें। जबकि बस शुरू करने वाले चर बनाने के लिए एक स्वीकार्य विकल्प की तरह लग सकता है, लंबे समय तक आप अन्य कक्षाओं को सीधे अपने वर्ग सदस्य चर का उपयोग करने में पछतावा करेंगे। यदि आप उन्हें एक सेटर के माध्यम से करने के लिए मजबूर करते हैं, तो आप यह सुनिश्चित करने के लिए तर्क जोड़ सकते हैं कि कोई अजीब मूल्य कभी न हो, और आप भविष्य में उस तर्क को हमेशा बदल सकते हैं बिना इस वर्ग को पहले से जोड़ना।

यानी

private string _name; 

public string getName { return _name; } 
public void setName(string value) 
{ 
    //Don't want things setting my Name to null 
    if (value == null) 
    { 
     throw new InvalidInputException(); 
    } 
    _name = value; 
} 
+0

चुप है, यह जानने के लिए धन्यवाद आमतौर पर एक बुरा विचार – Vlad

+0

शायद एक साधारण उदाहरण के लिए ठीक है, लेकिन मैंने एक चुप अनदेखा के बजाय अपवाद में संपादित किया। –

0

आंतरिक रूप से, getters और setters सिर्फ तरीके हैं। सी # संकलित है, यह अपने getters और इस तरह setters के लिए तरीकों उत्पन्न करता है, उदाहरण के लिए:

public int get_MyProperty() { ... } 
public void set_MyProperty(int value) { ... } 

सी # आप एक छोटा हाथ सिंटैक्स का उपयोग इन तरीकों घोषित करने के लिए अनुमति देता है। जब आप अपना आवेदन बनाते हैं तो नीचे दी गई रेखा उपरोक्त विधियों में संकलित की जाएगी।

public int MyProperty { get; set; } 

या

private int myProperty; 
public int MyProperty 
{ 
    get { return myProperty; } 
    set { myProperty = value; } // value is an implicit parameter containing the value being assigned to the property. 
} 
0

Getters और सी # में Setters कुछ है कि कोड को सरल कर रहे हैं।

private string name = "spots"; 

public string Name 
{ 
    get { return name; } 
    set { name = value; } 
} 

और यह बुला (मान हम एक नाम संपत्ति के साथ एक व्यक्ति obj है):

Console.WriteLine(Person.Name); //prints "spots" 
Person.Name = "stops"; 
Console.Writeline(Person.Name); //prints "stops" 

यह आपके कोड सरल करता है। जावा में जहां आपको दो विधियां होनी चाहिए, एक प्राप्त करने के लिए() और एक() सेट करने के लिए, सी # में, यह सब एक ही स्थान पर किया जाता है। मैं आमतौर पर मेरी कक्षाओं के शुरू में ऐसा करते हैं:

public string foobar {get; set;} 

यह मेरा foobar संपत्ति के लिए एक गेटर और सेटर पैदा करता है। इसे कॉल करना वैसे ही जैसा दिखता है जैसा कि पहले दिखाया गया है। ध्यान देने योग्य बात यह है कि आपको दोनों को प्राप्त करने और सेट करने की आवश्यकता नहीं है। यदि आप नहीं चाहते कि संपत्ति संशोधित की जा रही है, तो सेट शामिल न करें!

41

मुझे लगता है कि कोड का एक सा मदद मिलेगी उदाहरण देकर स्पष्ट करना क्या setters और getters हैं:

public class Foo 
{ 
    private string bar; 

    public string GetBar() 
    { 
     return bar; 
    } 

    public void SetBar(string value) 
    { 
     bar = value; 
    } 
} 

इस उदाहरण में हम वर्ग कि बार कहा जाता है के लिए एक निजी सदस्य है। गेटबार और सेटबार विधियों का सटीक रूप से उनका नाम है - एक बार बार सदस्य को पुनर्प्राप्त करता है, और दूसरा इसका मूल्य निर्धारित करता है।

सी # 1.1 + में आपके पास गुण हैं। मूल कार्यक्षमता भी वही है:

public class Foo 
{ 
    private string bar; 

    public string Bar 
    { 
     get { return bar; } 
     set { bar = value; } 
    } 
} 

निजी सदस्य बार कक्षा के बाहर पहुंच योग्य नहीं है। हालांकि सार्वजनिक "बार" है, और इसमें दो एक्सेसर्स हैं - प्राप्त करें, जैसा कि "गेटबार()" से ऊपर का उदाहरण निजी सदस्य देता है, और एक सेट भी - जो कि प्रीबैर में सेटबार (स्ट्रिंग वैल्यू) विधि से मेल खाता है उदाहरण।

सी # 3.0 से शुरू और संकलक के ऊपर से उस बिंदु पर अनुकूलित किया गया जहां ऐसे गुणों को निजी सदस्य को उनके स्रोत के रूप में रखने की आवश्यकता नहीं है। संकलक स्वचालित रूप से उस प्रकार का एक निजी सदस्य उत्पन्न करता है और इसे किसी संपत्ति के स्रोत के रूप में उपयोग करता है।

public class Foo 
{ 
    public string Bar { get; set; } 
} 

कोड शो एक स्वचालित संपत्ति है जिसमें संकलक द्वारा उत्पन्न एक निजी सदस्य होता है। आप निजी सदस्य नहीं देखते हैं लेकिन यह वहां है। इसने कुछ अन्य मुद्दों को भी पेश किया - मुख्य रूप से अभिगम नियंत्रण के साथ। सी # 1.1, और 2.0 में आप एक संपत्ति के हिस्से को मिलता है या सेट छोड़ सकता है:

public class Foo 
{ 
    private string bar; 

    public string Bar 
    { 
     get{ return bar; } 
    } 
} 

आप सीमित करने का तरीका अन्य वस्तुओं फू वर्ग के "बार" संपत्ति के साथ बातचीत का मौका देते। - सी # 3.0 और इसके बाद के संस्करण के साथ शुरू करता है, तो आप स्वत: गुणों का उपयोग करने के लिए चुना आप इस प्रकार संपत्ति के लिए उपयोग निर्दिष्ट करने के लिए होगा:

public class Foo 
{ 
    public string Bar { get; private set; } 
} 

क्या है कि साधन केवल वर्ग ही कुछ मूल्य के लिए बार सेट कर सकते हैं वह यह है कि, हालांकि कोई भी बार में मूल्य पढ़ सकता है।

3

मेरी व्याख्या निम्नलिखित होगी। (यह नहीं तो कम है, लेकिन यह काफी सरल है।)


एक चर के साथ एक कक्षा की कल्पना कीजिए:

class Something 
{ 
    int weight; 
    // and other methods, of course, not shown here 
} 

ठीक है, इस वर्ग के साथ एक छोटी सी समस्या है: कोई भी weight देख सकते हैं । हम weight सार्वजनिक कर सकते हैं, लेकिन फिर सभी किसी भी पल में weight को बदलने में सक्षम होंगे (जो शायद हम नहीं चाहते हैं)। तो, ठीक है, हम एक समारोह कर सकते हैं:

class Something 
{ 
    int weight; 
    public int GetWeight() { return weight; } 
    // and other methods 
} 

यह पहले से ही बेहतर है, लेकिन अब सादे something.Weight के बजाय हर किसी को टाइप करने के लिए something.GetWeight() है, जो है, ठीक है, बदसूरत है। इसलिए गुणों के साथ हम चर का उपयोग पर बेहतर नियंत्रण है

class Something 
{ 
    public int weight { get; private set; } 
    // and other methods 
} 

int w = something.weight // works! 
something.weight = x; // doesn't even compile 

नाइस,:

गुण के साथ, हम भी ऐसा कर सकते हैं, लेकिन कोड स्वच्छ रहता है।

एक और समस्या: ठीक है, हम चाहते हैं कि बाहरी कोड weight सेट करने में सक्षम हो, लेकिन हम इसके मूल्य को नियंत्रित करना चाहते हैं, और 100 से कम वजन कम करने की अनुमति नहीं देते हैं। इसके अलावा, कुछ अन्य आंतरिक चर density हैं , जो weight पर निर्भर करता है, इसलिए हम परिवर्तनों जैसे ही density को पुन: गणना करना चाहते हैं।

यह पारंपरिक रूप से निम्नलिखित तरीके से हासिल की है:

class Something 
{ 
    int weight; 
    public int SetWeight(int w) 
    { 
     if (w > 100) 
      throw new ArgumentException("weight too small"); 
     weight = w; 
     RecalculateDensity(); 
    } 
    // and other methods 
} 

something.SetWeight(anotherSomething.GetWeight() + 1); 

लेकिन फिर, हम चाहते हैं अपने ग्राहकों को बेनकाब नहीं है कि वजन की स्थापना एक जटिल ऑपरेशन है, यह अर्थ की दृष्टि से लेकिन एक नए वजन बताए कुछ भी नहीं है। तो एक सेटर के साथ कोड उसी तरह दिखता है, लेकिन अच्छे:

class Something 
{ 
    private int _w; 
    public int Weight 
    { 
     get { return _w; } 
     set 
     { 
      if (value > 100) 
       throw new ArgumentException("weight too small"); 
      _w = value; 
      RecalculateDensity(); 
     } 
    } 
    // and other methods 
} 

something.Weight = otherSomething.Weight + 1; // much cleaner, right? 

तो, कोई संदेह नहीं है, गुण हैं "बस" एक वाक्यात्मक चीनी। लेकिन यह ग्राहक के कोड को बेहतर बनाता है। दिलचस्प बात यह है कि संपत्ति जैसी चीजों की आवश्यकता अक्सर उत्पन्न होती है, आप जांच सकते हैं कि आप अन्य भाषाओं में GetXXX() और SetXXX() जैसे कार्यों को कितनी बार पाते हैं।

+0

यह मेरी सीखने की शैली – CM90

+1

@ CM90 के लिए एक शानदार उदाहरण है: धन्यवाद! :) – Vlad

+0

वास्तव में अच्छा स्पष्टीकरण :) –

1

अच्छी तरह से यहाँ, वास्तविक उपयोग के मामले में गेटर के आम उपयोग है

public class OrderItem 
{ 
public int Id {get;set;} 
public int quantity {get;set;} 
public int Price {get;set;} 
public int TotalAmount {get {return this.quantity *this.Price};set;} 
} 
0

यह getters और setters के साथ एक वस्तु "अनुच्छेद" की एक बुनियादी उदाहरण है:

public class Article 
    { 

     public String title; 
     public String link; 
     public String description; 

     public string getTitle() 
     { 
      return title; 
     } 

     public void setTitle(string value) 
     { 
      title = value; 
     } 

     public string getLink() 
     { 
      return link; 
     } 

     public void setLink(string value) 
     { 
      link = value; 
     } 
     public string getDescription() 
     { 
      return description; 
     } 

     public void setDescription(string value) 
     { 
      description = value; 
     } 
    } 
+0

यहां कम अच्छी बात यह है कि चर स्वयं को सार्वजनिक कर दिया जाता है, जो एक खराब ओओ प्रतिमान है। विशेष रूप से जब आपके पास स्पष्ट सेटर्स और इसके आगे के गेटर्स होते हैं। सी # प्रतिमान तैनात करना बेहतर है: सार्वजनिक स्ट्रिंग शीर्षक {प्राप्त करें; सेट}; (अन्य 2 चर के लिए समान)। यह बाहरी दुनिया से (दृश्यमान, लेकिन जेनरेट) निजी चर शामिल करता है। – GeertVc

 संबंधित मुद्दे

  • कोई संबंधित समस्या नहीं^_^