You are here: Home / C# Programming Language in Hindi / C# Property Get Set | C# Getter Setter
by on September 14, 2015

C# Property Get Set | C# Getter Setter

C# Property Get Set | C# Getter Setter: Encapsulation का मूल उद्देश्‍य ये है कि Object के Internal Data को केवल उसी Class का कोई Object Instance, Directly Access कर सके। इसीलिए Class के सभी Data Members को private Keyword के साथ Private Access में Define किया जाता है।

इसलिए यदि कोई Caller, Object की State में परिवर्तन करना चाहता है, तो उसे Indirectly एक Public Method को Use करके Object की State में परिवर्तन करना पडता है। इस प्रक्रिया को हम निम्न Code Segment द्वारा बेहतर तरीके से समझ सकते हैं:

	class Book
	{
		private int numberOfPages;
		
		public setPages(int page)
		{
			numberOfPages = page;
		}
	}

	class UsingBook
	{
		public static void Main()
		{
			Book cInHindi = new Book();
			cInHindi.setPages(56000);
		}
	}

जैसाकि इस Program के Main() Method में हम देख सकते हैं कि हालांकि Book Class के numberOfPages Data Member को Private Declare करके हमने इसे किसी भी External Class से Directly Access होने से रोक लिया है।

लेकिन setPages() Method द्वारा हम इसकी Value को जब Set करते हैं, तब हम ऐसा मान Specify कर सकते हैं, जो कि सही नहीं होने के बावजूद Object के numberOfPages Field में Store हो जाएगा।

चूंकि हम जानते हैं कि किसी भी Book में Pages की संख्‍या 56000 नहीं हो सकती, फिर भी उपरोक्त Code किसी भी तरह का Error Generate नहीं करेगा, क्योंकि हमने numberOfPages को Integer Type का Declare किया है और Integer Type का Variable 56000 मान Store कर सकता है।

लेकिन यदि हम हमारे Program में इस बात को निश्चित करने के लिए कि numberOfPages Variable में कभी भी 1500 से ज्यादा मान Store न हो, एक Business Rule Set करना चाहें, तो हमें हमारे setPages() Method को निम्नानुसार Modify करना होगा:

	class Book
	{
		private int numberOfPages;
		
		public setPages(int page)
		{
			if(page <= 1500)
				numberOfPages = page;
			else
				Console.WriteLine("No book can have as many pages.");
		}
	}

	class UsingBook
	{
		public static void Main()
		{
			Book cInHindi = new Book();
			cInHindi.setPages(56000);
		}
	}

हालांकि अब ये Program numberOfPages नाम के Field में 1500 से ज्यादा बडी संख्‍या Store नहीं होने देगा, लेकिन हर Method में इस तरह का Validation Rule Specify करना काफी Typical काम हो सकता है।

क्योंकि यदि कभी भविद्ग; में Business Rule Change किया गया और 1500 के स्थान पर 1800 मान को Pages की Maximum Limit रखा गया, तो Class के उन सभी Methods को Change करना होगा, जिसमें हमने Constant 1500 मान Specify किया है।

हालांकि हम एक Constant Symbol का प्रयोग करके भी इस Requirement को पूरा कर सकते हैं और यदि भविद्ग; में कभी जरूरत पडे, तो मात्र एक Constant का मान Change करके पूरे Program को नए Business Rule के लिए Reprogram कर सकते हैं। लेकिन C# हमें इस जरूरत को पूरा करने के लिए एक ज्यादा Flexible Coding System Provide करता है, जिसे Property नाम से जाना जाता है।

Property किसी Class या Object का एक ऐसा Member होता है, जो Class या Object के किसी Data Item को Represent करता है। Property का प्रयोग करके हम किसी Field के Data को Read करते हैं अथवा Field में नए Data को Write करते हैं, जबकि Property के माध्‍यम से Field के Data को Read या Write करने का Syntax समान ही होता है।

साथ ही हम इस Property में विभिन्न प्रकार के Field Level Business Rules को भी काफी आसानी से Apply कर सकते हैं, जिसके लिए हमें किसी Method में Business Rules के लिए Extra Codes नहीं लिखने पडते। किसी Field की तरह Property की भी निम्न Characteristics होती हैं:

  • Property किसी Class का एक Named Member होता है।
  • हर Property का एक Type होता है।
  • Property को Read/Write यानी Get/Set किया जा सकता है।

क्योंकि Property वास्तव में Class का एक Member Method होता है न कि Data Member, इसलिए-

  • Property को Data Store करने के लिए Memory Allocate नहीं किया जाता। और
  • Property वास्तव में एक Executable Code को Execute करता है।

किसी Class की Property निम्नानुसार Matching Methods Pair का एक Named Set होता है, जिसे Accessors कहा जाता है:

  • set Accessors का प्रयोग किसी Property को Value Assign या Write करने के लिए किया जाता है। जबकि
  • get Accessors का प्रयोग किसी Property की Value को Retrieve या Read करने के लिए किया जाता है।

उदाहरण के लिए यदि MyValue नाम की एक Integer Type की Property Define किया जाए, तो इस Property के दोनों Accessors को हम निम्नानुसार तरीके से Create कर सकते हैं:

	class Program
	{
		int MyValue
		{
			set
			{
				SetAccessorCode
			}
			get
			{
				GetAccessorCode
			}
		}
		. . .
	}

जबकि यदि हम इसे एक चित्र के रूप में Represent करें, तो हमारा चित्र कुछ निम्नानुसार हो सकता है:

C# Property Get Set - Hindi

Property Declaration and Accessors

get व set Accessors का Syntax व Semantic Predefined है। इसलिए set Accessor को हम एक ऐसे Method के रूप में मान सकते हैं, जो एक Single Parameter को कोई Value Assign या Set करता है। जबकि get Accessor कोई Parameter Accept नहीं करता बल्कि किसी Specific Property की Value को Return करता है।

set Accessor में हमेंशा value नाम का एक Single, Implicit Value Parameter होता है, जिसका Type वही होता है, जो Property का Type होता है और इसका Return Type void होता है। जबकि get Accessor में कोई Parameter नहीं होता है और इसका Return Type वही होता है, जो Property का Type होता है। दोनों प्रकार के Accessors से सम्बंधित इन Special बातों को हम निम्न चित्र द्वारा बेहतर तरीके से समझ सकते हैं:

Property Declaration and Accessors - Hindi

set Accessor का value Parameter किसी भी अन्‍य Value Parameter की तरह एक Normal Value Parameter ही होता है, जिसका प्रयोग हमारे set Accessor की Body में Data Pass करने के लिए किया जा सकता है।

जब एक बार Value को set Accessor द्वारा Set कर दिया जाता है, उसके बाद हम value को Normal Variable की तरह Use कर सकते हैं। यानी इसे Value Assign कर सकते हैं अथवा इसकी Value को Read कर सकते हैं।

set व get Accessor को किसी भी क्रम में Define किया जा सकता है और किसी Property में इन दोनों के अलावा और कोई Method Define नहीं किया जा सकता। जबकि get Accessor में हमेंशा एक Return Statement Specify करना जरूरी होता है।

उदाहरण के लिए हम निम्नानुसार एक Class Define कर सकते हैं, जिसमें MyValue नाम की एक Property है:

File Name: PropertyExample.cs
using System;

namespace CSharpClass
{
    class PropertyClass
    {
        private int TheRealValue; 	// Field: memory allocated
        public int MyValue 		// Property: no memory allocated
        {
            set
            {
                TheRealValue = value;
            }
            get
            {
                return TheRealValue;
            }
        }
    }
}

यदि हम इस Example Property को चित्रानुसार दर्शाऐं, तो कुछ निम्नानुसार दर्शा सकते हैं:

C# Getter Setter - Hindi

Property स्वयं कभी भी कोई Memory Storage Reserve नहीं करता। बल्कि Accessors तय करते हैं कि Property के माध्‍यम से Class के Field में Store होने के लिए set Accessor द्वारा Data किस तरह से आ,गा और Field के Data को किस तरह से Property के माध्‍यम से get Accessor द्वारा Return किया जाएगा।

जैसाकि उपरोक्त Example द्वारा हम समझ सकते हैं कि set Accessor value नाम का अपना एक Input Parameter लेता है और उसके मान को TheRealValue नाम के Field में Assign कर देता है। जबकि get Accessor TheRealValue नाम के Field के Value को Return कर देता है।

Properties and Associated Fields

जैसाकि पिछले उदाहरण द्वारा हम समझ सकते हैं कि किसी भी Property को सामान्‍यत: किसी न किसी Field के साथ Associate किया जाता है। इसलिए सामान्‍यत: किसी भी Class के किसी भी Method में किसी भी Field को Directly Access व Manipulate नहीं किया जाताए बल्कि हर Field को एक Property के साथ Associate कर दिया जाता है तथा Field को Read या Write करने के लिए Properties को ही Use किया जाता है।

इसलिए Class के सभी Fields को तो Private Access में रखा जाता है जबकि सभी Properties को Public Access में रखा जाता है, ताकि Class के बाहर यदि किसी Field के मान को Access करना हो, तो हम Properties का प्रयोग कर सकें।

जब किसी Field को किसी Property के साथ Associate कर दिया जाता है, तो इस प्रकार के Field को Backing Field या Backing Store कहा जाता है। उदाहरण के लिए यदि हम पिछले Example Program को ही उपयोग में लेते हुए इस Concept को समझें, तो हमारा Modified Program कुछ निम्नानुसार हो सकता है:

// File Name: AccessingPropertyExternalClass.cs
using System;

namespace CSharpClass
{
    class PropertyClass
    {
        private int TheRealValue; 		// Field: memory allocated
        public int MyValue 			// Property: no memory allocated
        {
            set{ TheRealValue = value; }
            get{ return TheRealValue; }
        }

        class AccessingPropertyExternalClass
        {
            public static void Main(String[] arg)
            {
                PropertyClass propertyObject = new PropertyClass();
                int fieldValue;
                fieldValue = propertyObject.MyValue;	//Get Field Value via Property's set Accessor
                Console.WriteLine("MyValue: " + fieldValue);

                propertyObject.MyValue = 100; 	//Set Field Value via Property's set Accessor
                fieldValue = propertyObject.MyValue;
                Console.WriteLine("MyValue: " + propertyObject.MyValue);
            }
        }
    }
}

// Output:
   MyValue: 0
   MyValue: 100

इस Program में हम PropertyClass नाम की Class में Declare किए गए Field MyValue के मान को एक दूसरी Class AccessingPropertyExternalClass में Access कर रहे हैं और Field के मान को Read करने के लिए हमने निम्न Statement Specify किया है:

fieldValue = propertyObject.MyValue;

ये Statement Execute होने पर Internally PropertyClass के निम्नानुसार get Accessor को Execute करता है,

get{ return TheRealValue; }

और Class TheRealValue Field के मान को Return करता है, जिसे fieldValue नाम के Local Variable में Store करके Display करवा दिया जाता है।

चूंकि जब किसी Field को Declare करते समय कोई मान Initialize नहीं करते, तो Automatically उसका मान Default Value से Set हो जाता है। इसीलिए TheRealValue नाम का Field Integer Type का होने की वजह से मान 0 से Initialize हो जाता है और निम्न Statement Execute होने पर-

Console.WriteLine(“MyValue: ” + fieldValue);

हमें निम्नानुसार पहला Output प्राप्त होता है:

MyValue: 0

फिर जब निम्नानुसार अगला Statement Execute होता है:

propertyObject.MyValue = 100;

तो ये Statement Execute होने पर निम्नानुसार PropertyClass का set Accessor Execute होता है:

set{ TheRealValue = value; }

और मान 100 इस Accessor के value Parameter को Pass होते हुए PropertyClass के Object propertyObject के MyValue Field को Assign हो जाता है। इसलिए जब अगली बार निम्न Statement Execute होता है:

fieldValue = propertyObject.MyValue;

तो हमें Output में रूप में निम्न Result प्राप्त होता है:

MyValue: 100

जो इस बात को Represent करता है कि PropertyClass के Object propertyObject के MyValue Field का मान set Accessor के माध्‍यम से 100 Set हो चुका है, इसीलिए get Accessor के माध्‍यम से हमें इस Field का मान 100 प्राप्त हो रहा है।

Field Name व Property Name में Confusion न हो, इसलिए सामान्‍यत: Field Names को camelCase में लिखा जाता है, जबकि Property Names को PascalCase में Specify किया जाता है। जैसे:

class PropertyClass
{
    private int theRealValue; 
    public int MyValue 
    {
        set{ theRealValue = value; }
        get{ return theRealValue; }
    }
    . . .
}

इसके अलावा Naming Confusion को Resolve करने के लिए एक और तरीका सामान्‍यत: Use किया जाता है, जिसमें Property Name को PascalCase में लिखा जाता है, जबकि Field Names की शु:आत एक Underscore से करते हुए CamelCase को Use किया जाता है। जैसे:

    class PropertyClass
    {
        private int _theRealValue; 
        public int MyValue 
        {
            set{ _theRealValue = value; }
            get{ return _theRealValue; }
        }
        . . .
    }

Computation Before Read or Write Fields

Property Accessors का प्रयोग केवल Field के Values को Get या Set करने के लिए ही नहीं किया जाताए बल्कि हम इन्हें इस तरह से Program कर सकते हैं, कि Field में Value Store करने से पहले set Accessor Assign किए जाने वाले मान के साथ किसी प्रकार का Computation कर सकता है, जबकि get Accessor Return किए जाने वाले मान के साथ किसी प्रकार का Computation करके Modified Value Return कर सकता है।

लेकिन जब हम get Accessor को Define कर रहे होते हैं, तब हमें केवल इस बात का ध्‍यान रखना होता है कि get Accessor हमेंशा कोई न कोई मान जरूर Return करता है। Accessors के इस Behavior को हम निम्न उदाहरण द्वारा बेहतर तरीके से समझ सकते हैं:

// File Name: UsingComputationInAccessors.cs
using System;

namespace CSharpClass
{
    class PropertyClass
    {
        private int TheRealValue;
        public int MyValue
        {
            set
            {
                if (value > 100)
                    TheRealValue = value;
                else
                    TheRealValue = 300;
            }
            get { return TheRealValue; }
        }
    }

    class UsingComputationInAccessors
    {
        public static void Main(String[] arg)
        {
            PropertyClass propertyObject = new PropertyClass();
            int fieldValue;
            fieldValue = propertyObject.MyValue;
            Console.WriteLine("MyValue: " + fieldValue);

            propertyObject.MyValue = 90;
            fieldValue = propertyObject.MyValue;
            Console.WriteLine("MyValue: " + propertyObject.MyValue);
        }
    }
}

// Output:
   MyValue: 0
   MyValue: 300

इसलिए जब UsingComputationInAccessors Class में निम्न Statement द्वारा MyValue Field को Set किया जाता है:

propertyObject.MyValue = 90;

तो set Accessor Execute होता है और इस बात को Check करता है कि Set किया जाने वाला मान 100 से ज्यादा है या नहीं। चूंकि हम इस Statement द्वारा TheRealValue Field में मान 90 Set करना चाहते हैं, इसलिए set Accessor का if Statement False हो जाता है और else Block में Specified Statement TheRealValue Field का मान 300 Set कर देता है। परिणामस्वरूप हमें Output में MyValue Property के माध्‍यम से TheRealValue Field का मान 300 प्राप्त होता है।

Read-Only and Write-Only Properties

हम get या set में से किसी एक Accessor को Undefined रख सकते हैं, लेकिन दोनों को Undefined नहीं रखा जा सकता। जिस Property में केवल get Accessor को Define किया जाता है, उस Property को Read-Only Property कहते हैं। जबकि जिस Property में केवल set Accessor को Define किया जाता है, उसे Write-Only Property कहा जाता है।

Read-Only Property Define करके हम Class के Field को Object या Outer Class द्वारा Secure तरीके से Access करने की सुविधा Provide करते हैं, जहां Object या Outer Class, Field Data को केवल Read कर सकता है, Write नहीं।

जबकि Write-Only Property Define करके हम Class के Field में Object या Outer Class द्वारा Secure तरीके से Data को Write करने की सुविधा Provide करते हैं, जहां Object या Outer Class, Field Data को केवल Property के माध्‍यम से Write कर सकता है, Read नहीं।

Public Fields के स्थान पर Properties को ही प्राथमिकता के साथ Use किया जाना चाहिए, क्योंकि Properties वास्तव में Methods होते हैं, इसलिए इनके माध्‍यम से हम Input व Output की Processing भी कर सकते हैं, जबकि Public Fields के साथ ऐसा नहीं किया जा सकता। साथ ही Properties को हम Read-Only या Write-Only Define कर सकते हैं, लेकिन Fields के साथ हम इन दोनों Features को Set नहीं कर सकते।

क्योंकि यदि हम Fields को Public रखते हैं, तो उसे किसी भी अन्‍य Class द्वारा Read व Write किया जा सकता है। जबकि यदि हम Fields को Private रखते हैं, तो Fields किसी भी अन्‍य Class के लिए हमेंशा के लिए Invisible हो जाते हैं।

Read-Only Computed Property

जरूरी नहीं है हम हर Property को किसी Field के साथ ही Associate करें, बल्कि हम ऐसी Read-Only Property भी Define कर सकते हैं, जो कि किसी Computation के आधार पर कोई ऐसी Value Return करता हो। इस प्रकार की Property को Change नहीं किया जा सकता।

उदाहरण के लिए हम निम्नानुसार एक RightTriangle नाम की Class Define कर सकते हैं, जिसमें Hypotenuse नाम की एक Computed Read-Only Property है, जो किसी समकोण के विकर्ण का मान Return करता है, जबकि समकोण के लम्ब व आधार को Public रखा गया है, ताकि कोई भी अन्‍य Class अथवा Object लम्ब व आधार के मान को Set कर सके।

चूंकि यदि लम्ब व आधार का मान ज्ञात हो, तो विकर्ण के मान को Memory में Store करने की जरूरत नहीं होती, क्योंकि इस मान को हम कभी भी Pythagorean Mathematical Formula द्वारा Calculate कर सकते हैं। इसीलिए इस Class में हमने Hypotenuse को Field के रूप में Store नहीं किया है।

// File Name: RightTriangleReadOnlyComputedProperty.cs
using System;

namespace CSharpClass
{
    class RightTriangle
    {
        public double L;
        public double A;

        public double Hypotenuse 				// Read-Only property
        {
            get { return Math.Sqrt((A * A) + (L * L)); } 	// Calculate return value
        }
    }

    class Program
    {
        static void Main()
        {
            RightTriangle objTR = new RightTriangle();
            objTR.L = 3;
            objTR.A = 4;
            Console.WriteLine("Hypotenuse: {0}", objTR.Hypotenuse);
        }
    }
}

// Output:
	Hypotenuse: 5

जैसाकि इस Program द्वारा हम समझ सकते हैं कि हमने Hypotenuse को किसी Field से Associate नहीं किया है बल्कि जब हम इसे निम्नानुसार Statement में Use करते हैं:

            Console.WriteLine(“Hypotenuse: {0}”, objTR.Hypotenuse);

तो C# Compiler Automatically objTR Object के L यानी लम्ब व A यानी आधार में Stored मानों के साथ Calculation Perform करके हमें Hypotenuse यानी विकर्ण का मान Return करता है।

चूंकि हमने हमारे RightTriangle Class में Hypotenuse को किसी Field के रूप में Store नहीं किया है बल्कि एक Calculation के माध्‍यम से Generate किया है, इसलिए इस तरह की Property को Read-Only Computed Property कहा जाता है। इस तरह की Property को हम निम्न चित्रानुसार Represent कर सकते हैं:

Automatically Implemented Properties - Hindi

जहां इस चित्र द्वारा हम समझ सकते हैं कि Hypotenuse Property का RightTriangle Class के किसी Field से Directly Association नहीं हैं, बल्कि Hypotenuse Property का get Accessor RightTriangle Class के दोनों Fields को Access करके उनके आधार पर Calculation Perform करता है और Generated Result Return कर देता है।

Automatically Implemented Properties

चूंकि Properties को सामान्‍यत Backing Fields के साथ Associate किया जाता है, इसलिए C# स्वयं ही Automatically Implemented Properties या Auto Implemented Properties Provide करता है, जो हमें बिना Backing Fields को Declare किए हुए Directly Properties को Declare करने की सुविधा Provide करता है। क्योंकि C# Compiler स्वयं ही हमारी हर Property के लिए एक Hidden Backing Field Create कर देता है और get या set Accessor को उसके साथ Hook कर देता है।

जब हम Automatically Implemented Properties Define करते हैं, तो C# Compiler स्वयं ही हमारी Property की Value के Type के अनुसार Backing Field Create कर देता है और उन्हें Memory Allocate कर देता है।

जब हम Automatically Implemented Properties प्राप्त करना चाहते हैं, तब हमें get व set Accessors को Define नहीं करना होताए बल्कि हमें get व set के तुरन्त बाद एक Semicolon Specify करना होता है।

जब हम Automatically Implemented Properties Create करते हैं, तब हम किसी भी तरीके से किसी Backing Field को Directly Access नहीं कर सकते, बल्कि इन्हें Access करने के लिए हमें हमेंशा get व set Accessors को ही Use करना जरूरी होता है। इसलिए Auto-Implemented Properties कभी भी Read-Only या Write-Only नहीं होते। C# द्वारा Provided इस Property को हम निम्नानुसार Define कर सकते हैं:

// File Name: AutoImplementedProperty.cs
using System;

namespace CSharpClass
{
    class PropertyClass
    {
        public int MyValue		// Auto Implemented Property
        {
            set;
            get;
        }

        class AutoImplementedProperty
        {
            public static void Main(String[] arg)
            {
                PropertyClass propertyObject = new PropertyClass();
                int fieldValue;
                fieldValue = propertyObject.MyValue;	//Get Field Value via Property's set Accessor
                Console.WriteLine("MyValue: " + fieldValue);

                propertyObject.MyValue = 100; 	//Set Field Value via Property's set Accessor
                fieldValue = propertyObject.MyValue;
                Console.WriteLine("MyValue: " + propertyObject.MyValue);
            }
        }
    }
}

// Output:
   MyValue: 0
   MyValue: 100

जैसाकि इस Program के Output द्वारा हम समझ सकते हैं कि ये Program Normal तरीके से काम कर रहा है, जबकि हमने इस Program में PropertyClass में TheRealValue नाम का Field Define नहीं किया है। क्योंकि इस Program में हमने निम्नानुसार तरीके से Auto-Implemented Property Define किया है:

public int MyValue                          // Auto Implemented Property
{
set;
get;
}

इसलिए C# Compiler स्वयं ही अपने स्तर पर एक Integer Type का Field Create कर लेता है, क्योंकि MyValue नाम की हमारी Property एक Integer Property है।

चूंकि Private Baking Fields हमेंशा Program के Compile Time में Create होते हैं, इसलिए हम new Keyword का प्रयोग करते हुए किसी Reference Type को Initialization Syntax के माध्‍यम से Directly Value Initialize नहीं कर सकते और यदि हम ऐसा करने की कोशिश करते हैं, तो C# Compiler हमें Error Return करता है।

Visual Studio हमें prop Code Snippet Provide करता है। यानी यदि हम Visual Studio में Coding करते समय “prop” शब्द Type करके दो बार Tab Key Press करें, तो Visual Studio IDE स्वयं ही नई Automatic Property के लिए Starter Code Generate कर देता है। जबकि फिर से Tab Key Press करके हम Generate होने वाली Definition के हर Part में Navigate कर सकते हैं।

हालांकि हम इस Automatically Implemented Property के माध्‍यम से Private Backing Files को Automatically Create कर सकते हैं। लेकिन इस तरीके का प्रयोग करके हम सामान्‍य Getting व Setting के अलावा अन्‍य किसी प्रकार का Code नहीं लिख सकते।

उदाहरण के लिए यदि हम Data Validation Logic या Event Log लिखना चाहते हैं या फिर Database के साथ प्रक्रिया करना चाहते हैं, तो विभिन्न प्रकार के Business Logics को Underlying Private Field पर Apply करने के लिए get व set Accessor कोई विशेष सुविधा नहीं देते। इस स्थिति में Automatically Implemented Properties के स्थान पर Normal Properties को Define करना ही उपयुक्त रहता है।

Static Properties

जिस तरह से हम Fields व Methods को Static Declare करते हैं, उसी तरह से हम किसी Property को भी Static Declare कर सकते हैं। इसलिए किसी भी अन्‍य Static Member की तरह ही Static Property की भी निम्न Characteristics होती हैं:

  • Static Property किसी Class के Instance Members को Access नहीं कर सकते, क्योंकि Static Member, Object Level या Instance Level नहीं बल्कि Class Level होते हैं।
  • Static Property उस स्थिति में भी Exist व Accessible रहते हैं, जब कि उस Class का एक भी Instance या Object Create नहीं किया गया होता।
  • Static Properties को External Class में भी Class Name के साथ Dot Operator का प्रयोग करके Access किया जाता है।

// File Name: UsingStaticProperty.cs
using System;

namespace CSharpClass
{
    class Box
    {
        public static double count { get; set; }
        double width { get; set; }
        double height { get; set; }
        double length { get; set; }

        public void SetSize(double h, double l, double w)
        {
            height = h;
            width = w;
            length = l;
            count++;
        }
    }

    class UsingBoxClassWithStaticProperty
    {
        static void Main(String[] arg)
        {
            Console.WriteLine("CPU Cabinet Information");
            Box cpuCabinet = new Box();
            cpuCabinet.SetSize(10, 20, 30);
            Console.WriteLine("Total Object Created: " + Box.count);

            Console.WriteLine("\nHard Disk Information");
            Box hardDisk = new Box();
            hardDisk.SetSize(5, 8, 10);
            Console.WriteLine("Total Object Created: " + Box.count);

            Console.WriteLine("\nMonitor Information");
            Box monitor = new Box();
            monitor.SetSize(10, 3, 20);
            Console.WriteLine("Total Object Created: " + Box.count);
        }
    }
}

// Output:
   CPU Cabinet Information
   Total Object Created: 1

   Hard Disk Information
   Total Object Created: 2

   Monitor Information
   Total Object Created: 3

इस Program में हमने एक भी Field Create नहीं किया है बल्कि सभी Fields को Automatically- Implemented Property Syntax द्वारा Automatically Create होने दिया है। साथ ही जिस तरह से हम Field को Static Declare करते हैं, उसी तरह से हमने इस Program में Automatically-Implemented Property को Static Declare किया है और हम देख सकते हैं कि हमें Exactly वही Output प्राप्त हो रहा है, जैसा BoxClassStaticDataMemberOutsideClassNormalAccess.cs Program से प्राप्त हुआ था।

यानी हम Properties को Exactly उसी तरह से Use कर सकते हैं, जिस तरह से Fields को करते हैं। जबकि Properties को Use करना, Fields को Use करने की तुलना में ज्यादा सुरिक्षत व सुविधाजनक भी है।

C# Static Class
Constructor in C#

C# in Hindiये Article इस वेबसाईट पर Selling हेतु उपलब्‍ध EBook C#.NET in Hindi से लिया गया है। इसलिए यदि ये Article आपके लिए उपयोगी रहा, तो निश्चित रूप से ये पुस्तक भी आपके लिए काफी उपयोगी साबित होगी। 

C#.NET in Hindi | Page:908 | Format: PDF

BUY NOW GET DEMO REVIEWS

Filed Under: C# Programming Language in Hindi