சி ஷார்ப்பில் கன்ஸ்ட்ரக்டர்கள்.

கன்ஸ்ட்ரக்டர் என்பது என்ன?

கன்ஸ்ட்ரக்டர் என்பது கிளாசின் சிறப்பு மெம்பர் ஃபங்க்சன் ஆகும். இது கிளாசிற்கு ஆப்ஜெக்ட் உருவாக்கும் பொழுது தானாக அழைக்கப்படும்.

கன்ஸ்ட்ரக்டரின் முக்கிய பயன் அந்த கிளாஸிற்க்கு ஆப்ஜெக்ட் உருவாக்கும் பொழுது அதன் பிரைவேட் ஃபீல்டுகளை தொடக்க மதிப்பிருத்தல் ஆகும்.

ஒரு கிளாசில் நாம் ஏதும் கன்ஸ்ட்ரக்டர் எழுதாத பொழுது சி ஷார்ப் கம்பைலர் ஆனதுடிஃபால்ட் கன்ஸ்ட்ரக்டரை வழங்கும்.

டிஃபால்ட் கன்ஸ்ட்ரக்டர் ஆனது எல்லா வேல்யூ டைப்களை 0 விற்க்கும் எல்லா ரெஃபெரென்ஸ்(ஸ்ட்ரிங்க், ஆப்ஜெக்ட்) நல்(null) மதிப்பிருத்திகின்றது.

கன்ஸ்ட்ரக்டர் குறித்து சில கருத்துக்கள்.

1.      ஒரு கிளாசில் எத்தனை கன்ஸ்ட்ரக்டர் வேண்டுமானாலும் இருக்கலாம்.

2.      கன்ஸ்ட்ரக்டருக்கு எந்த ரிடர்ன் டைப்பும் கிடையாது.( வாய்ட்(void) உள்ளிட்டு.)

3.      ஒரு ஸ்டேட்டிக் கன்ஸ்ட்ரக்டரால்  பாராமீட்டர்களை ஏற்பது இயலாது.

4.      ஒரு கிளாசிற்கு ஒரு கன்ஸ்ட்ரக்டர் மட்டும் தான்.

சி ஷார்ப்பின் 5 வகை கன்ஸ்ட்ரக்டர்கள்.

1.      டிஃபால்ட் கன்ஸ்ட்ரக்டர்

2.      பாராமீட்டரைஸ்டு கன்ஸ்ட்ரக்டர்.

3.      காப்பி கன்ஸ்ட்ரக்டர்

4.      ஸ்டேட்டிக் கன்ஸ்ட்ரக்டர்

5.      பிரைவேட் கன்ஸ்ட்ரக்டர்.

டிஃபால்ட் கன்ஸ்ட்ரக்டர்கள்.

எந்த பாராமீட்டரையும் ஏற்காத கன்ஸ்ட்ரக்டர்களை டிஃபால்ட் கன்ஸ்ட்ரக்டர் என்று அழைக்கின்றோம்.இதன் முக்கிய குறைபாடு கிளாசின் எல்லா ஆப்ஜெக்டும் ஒரே தொடக்க மதிப்பை கொண்டிருக்கும்.

சான்று நிரல்-1

1.    using System;  

2.    namespace DefaultConstractor  

3.    {  

4.        class addition  

5.        {  

6.            int a, b;   

7.            public addition()   //default contructor  

8.            {  

9.                a = 100;  

10.                                   b = 175;  

11.                               }  

12.                          

13.                               public static void Main()  

14.                               {  

15.                                   addition obj = new addition(); //an object is created , constructor is called  

16.                                   Console.WriteLine(obj.a);  

17.                                   Console.WriteLine(obj.b);  

18.                                   Console.Read();  

19.                               }  

20.                           }  

21.                       }  

வெளியீடு:

100

175.

பாராமீட்டரைஸ்டு கன்ஸ்ட்ரக்டர்கள்.

குறைந்த பட்சம் ஒரு பாராமீட்டராவது ஏற்கும் கன்ஸ்ட்ரக்டர் பாராமீட்டரைஸ்டு கன்ஸ்ட்ரக்டர் ஆகும். இதன் முக்கிய பயன்பாடு ஒவ்வொரு ஆப்ஜெக்டிற்கும் வெவ்வேறு மதிப்பிருத்தலாம்.

சான்று நிரல்-2

1.    using System;  

2.    namespace Constructor  

3.    {  

4.        class paraconstrctor  

5.        {  

6.          public  int a, b;  

7.          public paraconstrctor(int x, int y)  // decalaring Paremetrized Constructor with ing x,y parameter  

8.            {  

9.                a = x;  

10.                                   b = y;  

11.                               }  

12.                          }  

13.                           class MainClass  

14.                           {  

15.                               static void Main()  

16.                               {  

17.                                   paraconstrctor v = new paraconstrctor(100, 175);   // Creating object of Parameterized Constructor and ing values   

18.                                   Console.WriteLine("-----------parameterized constructor example-----------");  

19.                                   Console.WriteLine("\t");  

20.                                   Console.WriteLine("value of a=" + v.a );  

21.                                   Console.WriteLine("value of b=" + v.b);  

22.                                   Console.Read();  

23.                               }  

24.                           }  

25.                       }  

வெளியீடு:

Value of a=100

Value of b=175

காப்பி கன்ஸ்ட்ரக்டர்கள்.

ஒரு ஆப்ஜெக்டில் இருந்து மதிப்பை எடுத்து மற்றொரு ஆப்ஜெக்டுக்கு காப்பி செய்யும் கன்ஸ்ட்ரக்டர் காப்பி கன்ஸ்ட்ரக்டர் எனப்படும்.

சான்று நிரல்.

1.    using System;  

2.    namespace copyConstractor  

3.    {  

4.        class employee  

5.        {  

6.            private string name;  

7.            private int age;  

8.            public employee(employee emp)   // declaring Copy constructor.  

9.            {  

10.                                   name = emp.name;  

11.                                   age = emp.age;  

12.                               }  

13.                               public employee(string name, int age)  // Instance constructor.  

14.                               {  

15.                                   this.name = name;  

16.                                   this.age = age;  

17.                               }  

18.                               public string Details     // Get deatils of employee  

19.                               {  

20.                                   get  

21.                                   {  

22.                                       return  " The age of " + name +" is "+ age.ToString();  

23.                                   }  

24.                               }  

25.                           }  

26.                           class empdetail  

27.                           {  

28.                               static void Main()  

29.                               {  

30.                                   employee emp1 = new employee("karthikeyan", 46);  // Create a new employee object.  

31.                                   employee emp2 = new employee(emp1);          // here is emp1 details is copied to emp2.  

32.                                   Console.WriteLine(emp2.Details);  

33.                                   Console.ReadLine();  

34.                               }  

35.                           }  

36.                       }  

வெளியீடு:

The age of karthikeyan is 46.

ஸ்டேட்டிக் கன்ஸ்ட்ரக்டர்.

ஒரு கன்ஸ்ட்ரக்டர் ஆனது static என்ற் கீவர்டுடன் சேர்ந்து குறிப்பிடும் பொழுது அது ஸ்டேட்டிக் கன்ஸ்ட்ரக்டர் எனப்படுகின்றது. இது எல்லா ஆப்ஜெக்டிற்கும் சேர்த்து ஒரே ஒரு முறை தான் அழைக்கப்படுகின்றது.

இது முதன் முதலாய் ஒரு கிளாசின் ஆப்ஜெக்ட் உருவாக்கும் பொழுதோ அல்லது முதல் ஸ்டேட்டிக் மெம்பர் உருவாக்கும் பொழுதோ அழைக்கப் படுகின்றது.

ஸ்டேட்டிக் கன்ஸ்ட்ரகடர் ஆனது ஒரு ஸ்டேட்டிக் ஃபீல்டை தொடக்க மதிப்பிருத்த பயன்படுகின்றது.

ஸ்டேட்டிக் பாராமீட்டர் குறித்த குறிப்புகள்.

1.      ஸ்டேட்டிக் கன்ஸ்ட்ரக்டர்கள் எந்த ஆக்சஸ் மாடிஃபையரையும், பாராமீட்டரையும் ஏற்பதில்லை.

2.      இது எந்த ஆப்ஜ்ஜெக்டும் உருவாக்குவதற்கு முன் அழைக்கப்படுகின்றது.

3.      ஸ்டேட்டிக் கன்ஸ்ட்ரக்டரை நேரடியாக அழைக்க இயலாது.

4.      டெவலெப்பரால் எப்பொழுது இது அழைக்கப்படும் என உறுதியாக கூற முடியாது.

5.      ஒரு கிளாஸ் ஆனது log ஃபைல்களைய கொண்டிருக்கும் பொழுது கன்ஸ்ட்ரக்டர் ஆனது அந்த ஃபைலிற்கு உள்ளீடு கொடுப்பதற்கு பயன்படுத்தலின் பொழுது ஸ்டேடிக் கன்ஸ்ட்ரக்டர் ஆனது பயன்படுகின்றது.

சான்று நிரல்-4.

1.    using System;  

2.    namespace staticConstractor  

3.    {  

4.        public class employee  

5.        {  

6.            static employee() // Static constructor   

7.     declaration{Console.WriteLine("The static constructor ");  

8.        }  

9.        public static void Salary()  

10.                           {  

11.                               Console.WriteLine();  

12.                               Console.WriteLine("The Salary method");  

13.                           }  

14.                       }  

15.                       class details  

16.                       {  

17.                           static void Main()  

18.                           {  

19.                               Console.WriteLine("----------Static constrctor example by Muthu karthikeyan------------------");  

20.                               Console.WriteLine();  

21.                               employee.Salary();  

22.                               Console.ReadLine();  

23.                           }  

24.                         }  

25.                       }  

வெளியீடு:

----------Static constrctor example by Muthu karthikeyan----------------

The Static Constructor.

The salary Method.

பிரைவேட் கன்ஸ்ட்ரக்டர்:

ஓரு கிளாஸ் ஆனது பிரைவேட் கன்ஸ்ட்ரக்டரை கொண்டிருக்கும் பொழுது அதை இன் ஹெரிட் செய்வதோ அல்லது ஆப்ஜெக்ட் உருவாக்குவதோ இயலாது.

இது ஸ்டேட்டிக் மெம்பர்களை மட்டும் கொண்டிருக்கும் கிளாசில் பயன்படுகின்றது.

Singleton class pattern ஆனதை கிளாஸ் இம்ப்ளிமெண்ட் செய்ய பயன்படுகின்றது.

சான்று நிரல்-5

1.    using System;  

2.    namespace defaultConstractor  

3.    {  

4.        public class Counter  

5.        {  

6.            private Counter()   //private constrctor declaration  

7.            {  

8.            }  

9.            public static int currentview;  

10.                               public static int visitedCount()  

11.                               {  

12.                                   return ++ currentview;  

13.                               }  

14.                           }  

15.                           class viewCountedetails  

16.                           {  

17.                               static void Main()  

18.                               {  

19.                                   // Counter aCounter = new Counter();   // Error  

20.                                   Console.WriteLine("-------Private constructor example by Muthu karthikeyan----------");  

21.                                   Console.WriteLine();  

22.                                   Counter.currentview = 500;  

23.                                   Counter.visitedCount();  

24.                                   Console.WriteLine("Now the view count is: {0}", Counter.currentview);  

25.                                   Console.ReadLine();  

26.                               }  

27.                           }  

28.                       }  

வெளியீடு:

-------Private constructor example by Muthu karthikeyan----------

Now the view count is: 501

பின் குறிப்பு:

ஓரு கிளாசில் எந்த ஆப்ஜெக்டும் இல்லாத பொழுது கம்பைலர் ஒரு டிஃபால்ட் கன்ஸ்ட்ரக்டரை உருவாக்கும். ஆனால் ஒரு பாரா மீட்டரைஸ்டு கன்ஸ்ட்ரக்டரை நாம் எழுதினால் டிஃபால்ட் கன்ஸ்ட்ரக்டரையும் நாமே எழுதியாக வேண்டும்.

நன்றி.

முத்து கார்த்திகேயன்,மதுரை.