டாட்நெட் தொழில் நுட்பம் கற்றுக் கொள்ளலாம்-பகுதி-13

·மெத்தட் வடிவமைப்பு

ஒரு மெத்தட் ஆனது ஒன்று அல்லது ஒன்றுக்கு மேற்பட்ட ஸ்டேட்மெண்டுகளினால் ஆனது. இதை அதன் பெயரை கூறி அழைப்பதன் மூலம் இயக்கலாம்.இதன் மூலம் ஒரு சிக்கலான வடிவமைப்பு கொண்ட அப்ளிகேசன் flexible ஆகவும் நிர்வாகிக்க எளிதாகவும் மாறுகின்றது. திரும்ப திரும்ப இயங்கும் ஒரே நிரல் வரிகள் ஒரு தடவை தான் எழுதப்படுகின்றது. எளிதாக மறுபயன்பாடு நடைபெறுகின்றது.

1) Define methods

2) Call methods

1) Define methods: ஒரு மெதத்தடை வரையரை செய்வது என்பது அதன் எலிமெண்டுகளின் அறிவித்தல் ஆகும். அதன் சிண்டாக்ஸ் கீழே கொடுக்கப்பட்டுள்ளது.

சிண்டாக்ஸ்:

?

1 2 3 4

<Access specifier><Return Type><Method Name>(Parameter List) {     Method Body }

In the syntax mentioned above, the elements in the method are as follows:

• Access specifier:இது மற்ற கிளாஸிலிருந்து எவ்வாறு இதை ஆக்சஸ் செய்யலாம் என்பதை குறிப்பிட பயன்படுகின்றது.
• Return Type: ஒரு மெத்தட் ஆனது ஒரு மதிப்பை திருப்பி அனுப்பலாம். அதன் டேட்டா டைப் இங்கே குறிப்பிட படுகின்றது. எதையும் ரிடர்ன் செய்யாது எனில் void என குறிப்பிட படுகின்றது.
• Method Name: இது மெத்தடின் பெயராகும். இது கிளாஸின் மற்ற ஐட்டம் பெயரிலிருந்து வேறுபட்டு இருக்க வேண்டும்.
•  Parameter List: இது மெத்தட் ஒன்றிற்கு டேட்டாவை அனுப்புவதற்கும் பெறுவதற்கும் பயன்படுகின்றது.
• Method Name:இது நிரல் வரிகளின் தொகுப்பாகும். இது குறிப்பிட்ட செயலைச் செய்கின்றது.

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

?

1 2 3 4 5 6 7 8 9

class Calculate1 {     public int AddNumber ( int no1, int no2)     {         int result;         result = no1+no2;         return result;     } }

இதில் public என்பது இந்த மெத்தட் ஆனது கிளாஸிற்கு வெளிலிருந்தும் அழைக்கபடலாம் என்பதைக் குறிப்பிடுகின்றது. இந்த மெத்தட் ஆனது ஒரு int மதிப்பை திருப்பி அனுப்புகின்றது. AddNumber எனப்படுவது மெத்தடின் பெயராகும்.. இந்த மெத்தட் இரண்டு int டைப் மதிப்புகளை பராமீட்டர் ஆக ஏற்றுக் கொள்கின்றது.

2) Call methods:ஒரு மெத்தடை வரையரை செய்த பின் அந்த பெயர்  மற்றும் ஏதாவது பாரா மீட்டர் இருந்தால் அதையும் கூறி அழைக்க வேண்டும்.

The code to call methods is as shown below:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

class Program {     public int AddNumber ( int no1, int no2)     {         int result;         result = no1+no2;         return result;     }     static void Main ( string[ ] args)     {         Program p = new Program();         int value = p.AddNumber(2,4);         Console.WriteLine(“the result of numbers is:”+value);         Console.Read();     } }

The output is as shown below:

the result of numbers is:6

மேலே உள்ள நிரலில் Main() மெத்தடிலிருந்து நிரல் இயக்கம் தொடங்குகின்றது. P என்று ஒரு ஆப்ஜெக்ட் உருவாக்கப்பட்டு அதன் மூலம் மெத்தட் அழைக்கப்படுகின்றது. 2, 4 என்று பராமீட்டர்கள் பாஸ் செய்யப்படுகின்றது.

6.2 Static and Instance methods

Static மெத்தட் ஆனது ஆப்ஜெக்ட் மூலம் அல்லாமல் நேரடியாக கிளாஸ் பெயர் மூலம் அழைக்கப்பட்டால் அது ஸ்டேட்டிக் மெத்தட் ஆகும். Main() மெத்தடும் ஒரு ஸ்டேடிக் ஆகும். அவை பப்ளிக் ஆகவோ அல்லது பிரைவேட் ஆகவோ இருக்கலாம்.

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

class Program {     static void A()     {         Console.WriteLine(“First Static method”);     }     static int B()     {         Console.WriteLine(“Second Static method”);         return 1;     }     static void Main ( string[ ] args )     {         Program.A();         Program.B();         Console.Read();     } }

The output is as shown below:

first static method

Second static method

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

class Program {     void C()     {         Console.WriteLine(“First Instance method”);     }     void D()     {         Console.WriteLine(“Second Instance method”);     }     static void Main( string[ ] args )     {         Program p = new Program();         p.C();         p.D();         Console.Read();     } }

The output for the code is as shown below:

First Instance method

Second Instance method

பராமீட்டருடன் மெத்தட் அழைக்கபடுதல்

மெத்த்டில் பாராமீட்டரும் இருக்கலாம். மெத்தட் ஆனது அழைக்கபடும் பொழுது அதன் பெயரைத் தொடர்ந்து பிராக்கெட்டுக்குள் பாராமீட்டர் இருக்கும்.
   void MethodwithParameters( int x, int y )
   {
   }

மேலே உள்ள நிரல் வரிகளில் x,y என்கின்ற இரு இண்ட்  டைப் பாரா மீட்டர் கொண்டுள்ளது

1) Value:  இது இன்புட் பாராமீட்டர் எனப்படுகின்றது. இவை மெத்தடிற்கு பாஸ் செய்யபடும் ரிடர்ன் ஆகாது. ஒரு மெதடிற்குள் உள்ளே இதற்கு நடக்கும் மாற்றங்கள் வெளியே  பாதிக்கப்படது.

 2) Reference: இவை input/output பாராமீட்டர் எனப்படுகின்றது. மெத்தடிற்கு உள்ளே நடக்கும் மாற்றங்கள் வெளியே பாதிக்கபடும்.

 3) Output: இவை output பாராமீட்டர் எனப்படுகின்றது. இதம் மூலம் மெத்தடிலிருந்து  ஒன்றிற்க்கும் மேற்பட்ட டேட்டாக்கள் ரிடர்ன் செய்யப் படுகின்றன.

Passing parameters by value:

இயல்பாக மெதடிற்கு பாராமீட்டர்கள் value ஆகவே பாஸ் செய்யப் பயன்படுகின்றது.இது டேட்டா டைப் அதைத் தொடர்ந்து வேரியபிள் பெயருடன் இருக்கும்.நாம் அனுப்பும் பாரா மீட்டரும், மெத்தடில் உள்ள பாராமீட்டரும் டைப், எண்ணிக்கை ஆகியவற்றில் பொருந்த வேண்டும்.

 கீழே உள்ள சிண்டாக்ஸ் மெத்தடிற்கு பாராமீட்டரை value ஆக பாஸ் செய்கின்றது

    <return type>MethodName ( <data type> variable name )
    {
    }

 சான்று நிரல்

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

class IncrementData {     void AddOne(int i)     {         i++;     }     static void Main( string[ ] args )     {         IncrementData d = new IncrementData();         int no = 3;         d.AddOne(no);         Console.WriteLine(“The new number is:”+no);         Console.Read();     } } output: The number is 3

Passing parameters by reference:

ஒரு மெதடிற்கு பாராமீட்டரை reference ஆக பாஸ் செய்யலாம்.இது பாராமீட்டரின் மெமரி லொகேசனை அணுப்புகின்றது. மெத்தடின் உள்ளே புதியதாக மெமரி லொகேசன் உருவாக்கபடுவதில்லை. என்வே மெத்தடின் உள்ளே நடக்கும் மாற்றங்கள் வெளியே பிரதிபலிக்கின்றது

சிண்டாக்ஸ்

1 2 3 4

void ShowReference( ref int Id, ref int age ) { }

சான்று நிரள்

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

class IncrementData {     void AddOne( ref int i)     {         i++;     }     static void Main ( string[ ] args )     {         IncrementData d = new IncrementData();         int no = 3;         d.AddOne ( ref no );         Console.WriteLine(“The new number is:”+no);         Console.Read();     } } outout: The new number is 4

Passing parameters by Output:

ரிடர்ன் ஸ்டேட்மென்ட் ஒரு மதிப்பை மெத்தடிலிருந்து பெற உதவுகின்றது. ஆனால் ரிடர்ன் ஸ்டேட்மென்டால் ஒன்றுக்கும் மேற்பட்ட மதிப்புகளை ரிடர்ன் செய்ய இயலாது. Out பாராமீட்டர் இந்த குறையைப் போக்குகின்றது.

Output பாராமீட்டர் ரெஃபெரன்ஸ் பாராமீட்டர் போல செயல்படுகின்றது. ஆனால் மெத்தடிலிருந்து டேட்டாவை ரிடர்ன் செய்ய பயன்படுகின்றது. Out பாராமீட்டர் பயன்படுத்தி ஒன்றுக்கும் மேற்பட்ட மதிப்பை ரிடர்ன் செய்கின்றது

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class OutDemo {     static void OutSample( out int i )     {         i=20;     }     static void Main ( string [ ] args )     {         int no;         OutSample( out no );         Console.WriteLine(“Value for the number is:”+no );         Console.Read();     } } output: Value for the number is 20

 this reference

 this கீவேர்டு கிளாஸின் கரண்ட் இன்ஸ்டன்ஸை refer செய்கின்றது.இது மெத்தட் மற்றும் கன்ஸ்ட்ரக்டர் உள்ளே இருக்கும் மெம்பர்களை ஆக்சஸ் செய்ய உதவுகின்றது.  இது நேம் கன்ஃப்லிட்டியை நீக்க உதவுகின்றது. இதை ஸ்டேட்டிக் கிளாஸ் உள்ளே பயன்படுத்த இயலாது

சான்று நிரல்

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

class OutDemo {     int I;     public OutDemo()     {         this.Decrease();     }     public void Decrease()     {         i--;         this.i--;         Console.WriteLine(“The value of I is”+i);     }     static void Main (string [ ] args)     {         OutDemo o = new OutDemo();         o.Decrease();         Console.Read();     } }

The output for the code is as shown below:

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

.