Tuesday, September 11, 2018

டாட்நெட் தொழில் நுட்பம் கற்றுக் கொள்வோம் –பகுதி-11


C#  அர்ரே உதாரணங்கள்
ஒரு அர்ரே ஆனது ஒரே டேட்டா டைப்பை சேர்ந்த ஒன்றுக்கும் மேற்பட்ட மதிப்புகளின் தொகுப்பாகும். ஒவ்வொரு எலிமெண்டையும் அதன் இண்டெக்ஸை வைத்து அனுகலாம். அர்ரே இண்டெக்ஸ் ஆனது 0-வில் தொடங்குகின்றது.வேல்யூ வகையைச் சார்ந்த அர்ரேக்களின் டிஃபால்ட் மதிப்பு  0 ஆகும். ரெஃபெரென்ஸ் வகையைச் சேர்ந்த  அர்ரே எலிமெண்டுகளின் டிஃபால்ட் மதிப்பு null  ஆகும்.

Integer Array

இண்டிஜெர் அர்ரே.
அர்ரேயின் எலிமெண்டுகளுக்கு மதிப்பிருத்தல்.
இண்டிஜர் அர்ரேயின் அறிவிப்பு மற்றும் அதில் தொடக்க மதிப்பிருத்தல்
int[] array = new int[4];

array[0] = 10;
array[1] = 20;
array[2] = 30;
array[3] = 40;
மேலே உள்ள நிரல் வரிகளில் ஒரு அர்ரேயை அறிவித்து அதன் ஒவ்வொரு எலிமெண்டுக்கும் மதிப்பிருத்தியுள்ளோம்.
மேலே உள்ள அர்ரேயின் சைஸ் 4 ஆதலால் அதன் இண்டெக்ஸ் 0-3 வரை இருக்கும்.
கீழே உள்ள நிரலில் ஃபார் லூப் உபயோகித்து அர்ரே எலிமெண்டுகள் மதிப்பிருத்தப் ப்டுகின்றன.
 
int[] items = new int[100];
for (int cnt = 0; cnt <= 100; cnt++)
{
    items[cnt] = yourValueHere;
}

கீழே உள்ள நிரலில் அர்ரே எலிமெண்டுகளின் மதிப்பு பெறப் படிகின்றது.
 
      for (int i = 0; i < array.Length; i++)
      {
            MessageBox.Show (array[i]);
      }

Initialize Array

ஒரே வரியில் நம்மால் ஒரு அர்ரேயை அறிவித்து அதற்கு மதிப்பிருத்தவும் முடியும்.
 
      int[] array = new int[] {10, 20, 30, 40};

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

ஒரு அர்ரேயின் மதிப்புகளை எவ்வாறு ஒரே வரிசையில் வெளியீடு செய்வது என்பதற்கு கீழே உள்ள நிரல் வரிகள் பயன்படுகின்றது.

 
int[] array = new int[] {10, 20, 30, 40};
foreach(var item in array)
{
    Console.Write(item.ToString());
}


String Array

ஸ்டிரிங் வகையைச் சேர்ந்த அர்ரேயை எவ்வாறு அறிவித்து அதற்கு மதிப்பிருத்துவது என்பதற்கான நிரல் வரிகள் கீழே உள்ளது
 
string[] week = new string[7];
week[0] = "Sunday";
week[1] = "Monday";

ஓரே வரியில் ஸ்டிரிங்க் அர்ரேயை அறிவித்து அதை மதிப்பிருத்துதல்.
 
string[] week = new string[] {"Sunday","Monday","Tuesday"};

ஒரு ஸ்டிரிங் அர்ரேயிலிருந்து மதிப்பை பெறுதல்
string str = week[1];
 ஒரு அர்ரேயை அதன் நியூமெரிக் இண்டெக்ஸை வைத்து அணுகலாம். மேலே உள்ள வரிகளில் இரண்டாவது எலிமெண்ட் ஆக்சஸ் செய்யப் பட்டுள்ளது.
 கீழே உள்ள நிரலில் ஒரு அர்ரே ஆனது அறிவிக்கப்பட்டு அதன் ஏழு இண்டக்ஸுகளுக்கும் மதிப்பிருத்தப்பட்டுள்ளது. அடித்த  படியாக அதன் மதிப்புகள் பெறப் பட்டுள்ளன. ஒரு அரேயின் கசைசி இண்டெக்ஸை கணக்கிருவதற்கு அதன் length பண்பானது பயன்படுகின்றது.
 
    string[] week = new string[7];
    week[0] = "Sunday";
    week[1] = "Monday";
    week[2] = "Tuesday";
    week[3] = "Wednsday";
    week[4] = "Thursday";
    week[5] = "friday";
    week[6] = "Saturday";
    for (int i = 0; i &lt; = week.Length-1; i++)
    {
        MessageBox.Show(week[i]);
    }

ஒரு அர்ரேயின் லெங்தை எவ்வாறு கணக்கிடுவது?

Array.Length பண்பானது ஒரு அர்ரேயின் ஒட்டு மொத்த எலிமெண்டுகளின் எண்ணிக்கையை கணக்கிடுகின்றது.
 
      String[] flag = new string[] {"TRUE","FALSE"};
      int sizeOfArray = flag.Length;

ஒரு அர்ரேயை ரிசைஸ் செய்வது எவ்வாறு?

ஒரு அர்ரே ஒன்றின் சைஸை கணக்கிடுவதற்கு Array.Resize < T > Method  பயன்படுகின்றது. Array.Resize < T > - T என்பது அர்ரயின் டேட்டா டைப்பாகும்.
 Resize Array
 
    // Initialize array for example
    char[] array = new char[5];
    array[0] = 'A';
    array[1] = 'B';
    array[2] = 'C';
    array[3] = 'D';
    array[4] = 'E';
    for (int i = 0; i < array.Length; i++)
    {
        MessageBox.Show (array[i].ToString ());
    }
    Array.Resize(ref array, 3);
    for (int i = 0; i < array.Length; i++)
    {
        MessageBox.Show(array[i].ToString ());
    }

Array.Resize(ref array, 3);
மேலே உள்ள நிரல் வரியில் ஒரு அர்ரேயின் சைஸ் 3 ஆக மாற்றப் படுகின்றது.

for..each loop மற்றும் array

 
      int[] array = { 10, 30, 50 }; //array declaration
      foreach (int element in array)
      {
          Console.WriteLine(element);
      }

Converting String array to List

 
  string[] week = new string[7];
  week[0] = "Sunday";
  week[1] = "Monday";
  week[2] = "Tuesday";
  week[3] = "Wednsday";
  week[4] = "Thursday";
  week[5] = "friday";
  week[6] = "Saturday";
  List<string> lst = new List<string>(week);
  foreach (string day in lst)
  {
      MessageBox.Show(day);
  }

ஒரு அர்ரேயில் குறிபிடப்பட்ட மதிப்புள்ளதா என்று எவ்வாறு கண்டுபிடிப்பது?

 
string[] week = new string[7];
week[0] = "Sunday";
week[1] = "Monday";
week[2] = "Tuesday";
week[3] = "Wednsday";
week[4] = "Thursday";
week[5] = "friday";
week[6] = "Saturday";
string value = "Wednsday";
int pos = Array.IndexOf(week, value);
if (pos > -1)
    MessageBox.Show(value + " exist !");
else
    MessageBox.Show(value + " not exist !");

Array Sort

அர்ரே ஒன்றை ஏறு வரிசையிலோ அல்லது இறங்கு வரிசையிலோ சார்ட் (SORT) செய்யலாம்.இதற்கு Array.Sort மெத்தட் பயன்படுகின்றது. அதே மாதிரி Array.Reverse ஆனது ஒரு அர்ரேயை ரிவர்ஸ் செய்கின்றது.

System.Array.CopyTo and System.Array.Clone()

The System.Array.CopyTo மெத்தட் ஆனது ஒரு அர்ரேயின் எலிமெண்டுகளை ஏற்கனவே உள்ள அர்ரே ஒன்றின் குறிபிடப்பட்ட இண்டெக்ஸில் இருந்து நகல் எடுக்கின்றது.  System.Array.Clone() மெத்தட் ஆனது புதிய அர்ரே ஆப்ஜெக்ட் ஒன்றை உருவாக்கி முற்றிலும் புதிய அர்ரே ஒன்றாக நகல் எடுக்கின்றது.
அர்ரே ஒன்றில் குறிப்பிடப்பட்ட பட்ட வேல்யூ உள்ளதா என கண்டு பிடித்தல்

string stringToCheck = "GHI";
string[] stringArray = { "ABC", "DEF", "GHI", "JKL" };
foreach (string x in stringArray)
{
    if (x.Equals (stringToCheck))
    {
        MessageBox.Show("Find the string ..." + x);
    }
}
for each loop in C# Array
foreach லூப்பை வைத்து ஒரு அர்ரேயின் மதிப்புகளை பெறுவது வசதியாக உள்ளது. கீழே உள்ள நிரலில் foreach லூப் பயன்படுத்தப்பட்டுள்ளது.
using System;
using System.Collections;
using System.Windows.Forms;

namespace WindowsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            string[] week = new string[7];
            week[0] = "Sunday";
            week[1] = "Monday";
            week[2] = "Tuesday";
            week[3] = "Wednsday";
            week[4] = "Thursday";
            week[5] = "friday";
            week[6] = "Saturday";

            foreach (string day in week)
            {
                MessageBox.Show(day);
            }
        }
    }
}

 C# List Class எவ்வாறு உபயோகிப்பது?

List < T > Class
 கலக்சன் கிளாஸ் என்பது ஆப்ஜெக்டுகளின் தொகுப்பாகும்.அதன் மேல் நாம் செயல்பட முடியும். லிஸ்ட் கிளாஸ் என்பது ஒரு கலக்சன் ஆகும்.இது System.Collections.Generic என்கின்ற நேம்பேஸில் டிஃபைன் செய்யப் பட்டுள்ளது.இது Add, insert,remove, search போன்ற மெதட் மற்றும் பிராப்பர்ட்டிகளை கொண்டுள்ளது. இது arrays, linked lists, queues போன்ற ஒரு டைமன்சனல் டேட்டா ஸ்ட்ரக்சர்களுக்கு மாற்றாக பயன்படுகின்றது. ஏனெனில் இது மற்றவற்றைக் காட்டிலும் அதிக பயன்பாடுகள், இதன் சைஸை வேண்டிய நேரத்தில் மாற்றியமைப்பது என திறன் கொண்டது.
C# List < T > கிளாஸ் என்பது strongly typed ஆப்ஜெக்ட்டுகளின் லிஸ்ட் ஆகும். அதன் எலிமெண்டுகளின் அதன் இண்டெக்ஸை உபயோகித்து ஆக்சஸ் செய்யலாம். இது ஒரு குறிப்பிட்ட இனத்தைச் சார்ந்த டேட்டாவை ஆப்ஜெட்டுக்கு கேஸ்டிங் செய்யாமல் சேமிக்கலாம்.


List < T >
பராமீட்டர் T என்பது எலிமெண்டுகளின் டேட்டா டைப் ஆகும்.
ஒரு லிஸ்டுக்கு ஐட்டம் எவ்வாறு ஆட் செய்வது?
ஒரு லிஸ்டிற்கு இன்டிஜெர் மதிப்புகள் எவ்வாறு ஆட் செய்வது என காண்போம்.
 
      List<int> iList = new List<int>();
      iList.Add(2);
      iList.Add(3);
      iList.Add(5);
      iList.Add(7);

Add String values in the List
 
    List<string> colors = new List<string>();
    colors.Add("Red");
    colors.Add("Blue");
    colors.Add("Green");

ஒரு லிஸ்டின் சைஸ் எவ்வாறு கண்டறிவது?
அதற்கு count பிராப்பர்ட்டி பயன்படுகின்றது.
 
      colors.Count

ஒரு லிஸ்டின் ஐட்டம்களை எவ்வாறு ரிடிரைவ் செய்வது? ஃபார் லூப்புகளை உபயோகித்து ஒரு லிஸ்ட் ஐட்டம்களை ரிடிரைவ் செய்யலாம்.
foreach loop
 
    foreach (string color in colors)
    {
        MessageBox.Show(color);
    }

for loop
 
    for (int i = 0; i < colors.Count; i++)
    {
        MessageBox.Show(colors[i]);
    }

லிஸ்டில் ஐட்டம் ஒன்றினை ரிடிரைவ் செய்வது எவ்வாறு?
ஒரு இண்டெக்ஸை குறிப்பிட்டு அதில் ஐட்டம்  இன்செர்ட் செய்யலாம்.
 
           colors.Insert(1, "violet");

மேலே உள்ள நிரல் வரியில் violet என்னும் color இண்டெக்ஸ் ஒன்றில் இன்செர்ட் செய்யப்பட்டுள்ளது.
 C# List  சார்ட் செய்தல்.
 sort()  மெத்தட் உபயோகித்து ஒரு c# லிஸ்டை சார்ட் செய்யலாம்.
 
           colors.Sort();

குறிப்பிட்ட ஐட்டத்தை எவ்வாறு அகற்றுவது?
 Remove()  மெத்தட் உபயோகித்து ஒரு குறிப்பிட்ட ஐட்டத்தை அகற்றலாம்.
 
 
                  colors.Remove("violet");
ஒரு குறிப்பிட்ட ஐட்டம் லிஸ்டில் உள்ளதா என எவ்வாறு கண்டறிவது?

 List.Contains()  என்கின்ற மெத்தட் அதற்கு பயன்படுகின்றது.
 
    if (colors.Contains("Blue"))
    {
        MessageBox.Show("Blue color exist in the list");
    }

அர்ரேயிலிருந்து லிஸ்டிற்கு ஐட்டம்களை எவ்வாறு காப்பி (COPY) செய்வது?
 
    string[] strArr = new string[3];
    strArr[0] = "Red";
    strArr[1] = "Blue";
    strArr[2] = "Green";
      //here to copy array to List
    List<string> arrlist = new List<string>(strArr);
ஒரு லிஸ்டை ஸ்டிரிங்க் ஆக காப்பி செய்வது எப்படி?
பின் வரும் வழியில் அதை செய்யலாம்
 
      string combindedString = string.Join(",", colors);

வெளியீடு பின் வருமாறு இருக்கும்.
 "Red,Blue,Green"
“,” தவிர வேறு ஏதாவது கேரக்டர் உபயோகித்தும் ஸ்டிரிங்காக மாற்றலாம்.
 List ஒன்றை Array ஆக மாற்றுதல்.

toArray()  என்கின்ற மெத்தட் இதற்கு பயன்படுகின்றது.
 
      string[] arr = colors.ToArray();

ஒரு லிஸ்டை எவ்வாறு கிளியர் செய்வது?
  clear  மெத்தட் அதற்கு பயன்படுகின்றது
 
      arrlist.Clear ();

லிஸ்ட் மற்றும் அர்ரே லிஸ்ட் என்ன வித்தியாசம்.
மெமரியை கையாளுவதில் அர்ரே திறன் வாய்ந்தது. அர்ரே மேல் லிஸ்ட் பில்ட் செய்யப்பட்டுள்ளது. ஒரே டேட்டாவனது அர்ரேயில் சேவ் செய்யபடுவைதை லிஸ்ட் ஆக சேவ் செய்வது அதிக மெமரி எடுத்துக் கொள்கின்றது. அர்ரேயானது நிலையான length இருக்கும் போது பயன்படுகின்றது. லெங்க்த் மாறுபடும் நிலையில் லிஸ்ட் உகந்தது. ஒரு ஐட்டம் ஆட் மற்றும் ரிமூவ் செய்யும் பட்சத்தில் லிஸ்டே உகந்தது.
Linq உபயோகித்து லிஸ்டிலிருந்து டூப்ளிகேட் ஐட்டம் பெற்வதற்கு கீழ் காணும் வரிகள் பயன்படுகின்றது.
 
List<String> duplicates = lst.GroupBy(x => x)
                             .Where(g => g.Count() > 1)
                             .Select(g => g.Key)
                             .ToList();

லிஸ்ட் மற்றும் டிக்ஸ்னரி என்ன வேறுபாடு?

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

லிஸ்டிற்கான சான்று நிரல்:


using System;
using System.Collections.Generic;
using System.Windows.Forms;
 
namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            List < string > colors = new List < string > ();
 
            //add items in a List collection
            colors.Add("Red");
            colors.Add("Blue");
            colors.Add("Green");
 
            //insert an item in the list
            colors.Insert(1, "violet");
 
            //retrieve items using foreach loop
            foreach (string color in colors)
            {
                MessageBox.Show(color);
            }
 
            //remove an item from list
            colors.Remove("violet");
 
            //retrieve items using for loop
            for (int i = 0; i < colors.Count; i++)
            {
                MessageBox.Show(colors[i]);
            }
 
            if (colors.Contains("Blue"))
            {
                MessageBox.Show("Blue color exist in the list");
            }
            else
            {
                MessageBox.Show("Not exist");
            }
 
            //copy array to list
            string[] strArr = new string[3];
            strArr[0] = "Red";
            strArr[1] = "Blue";
            strArr[2] = "Green";
            List < string > arrlist = new List < string > (strArr);
 
            foreach (string str in strArr)
            {
                MessageBox.Show(str);
            }
 
            //call clear method
            arrlist.Clear ();
 
            MessageBox.Show(arrlist.Count.ToString ());
        }
    }
}

C# Dictionary

ஒரு டிக்ஸ்னரி கிளாஸ் ஆனது கீ மற்றும் வேல்யூ ஆகியவற்றின் கலக்சன் ஆகும். கீ மதிப்பு யுனிக் ஆக இருக்கும். ஆனால் வேல்யூ ஆனது வெவ்வெறு கீக்களுக்கு ஒன்றாக அமையலாம்.
இந்த கிளாஸ் ஆனது  System.Collections.Generic நேம் பேஸில் டிஃபைன் செய்யப்பட்டுள்ளது. என்வே நாம் System.Collections.Generic namespace இம்போர்ட் செய்து கொள்ள வேண்டும்.
 
      using System.Collections.Generic

Syntax:
Parameters :
 
      TKey – கீயின் டேட்டா டைப்.
      TValue –வேல்யூவின் டேட்டா டைப்.

e.g.
 
      Dictionary<string, string>
      Dictionary<string, int>

டிக்ஸ்னரிக்கு மதிப்பு ஆட் செய்தல்:

ஆட் மெத்தட் இரண்டு பராமீட்டர்களை ஏற்கின்றது.ஒனறு கீ மற்றது வேல்யூ ஆகும்.
Syntax:
 
      public void Add(TKey key,TValue value)

சான்று:
dictionary.Add("dozen",12);
கீ  null ஆக இருக்கலாம். ஆனால் மதிப்பானது ரெஃபரன்ஸ் டைப்பாக இருந்தால் null ஆக இருக்கலாம். pe.
 
Dictionary<string, int> dict = new Dictionary<string, int>();
dict.Add("one", 1);
dict.Add("two", 2);
dict.Add("three", 3);
dict.Add("four", 4);

டிக்ஸ்னரியிலிருந்து கீ மற்றும் வேல்யூ இரண்டையும் ரிடிரைவ் செய்தல்.

foreach loop உபயோகித்து ரிடிரைவ் செய்யலாம்.
 
foreach (KeyValuePair<string, int> pair in dict)
{
    MessageBox.Show(pair.Key.ToString ()+ "  -  "  + pair.Value.ToString () );
}

Key ஒன்றை தேடுதல்:

ஒரு கீ ஒன்று டிக்ஸ்னரியில் உள்ளதா என செக் செய்வதற்கு  ContainsKey மெத்தட் பயன்படுகின்றது.
 
if (dict.ContainsKey("four") == true)
{
      MessageBox.Show(dict["four"].ToString ());
}
else
{
      MessageBox.Show("Key does not exist");
}

Iterate over a Dictionary


Dictionary < string, int > dict = new Dictionary < string, int > ();
dict.Add("one", 1);
dict.Add("two", 2);
dict.Add("three", 3);
dict.Add("four", 4);
 
foreach (KeyValuePair < string, int >  pair in dict)
{
      MessageBox.Show(pair.Key.ToString() + "  -  " + pair.Value.ToString());
}

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

ads Udanz

No comments:

Post a Comment