Generic Collections

ในบทนี้ คุณจะได้รู้จักกับ Collections ในภาษา C# และการใช้งาน Collections ประเภทต่างๆ ที่มีความจำเป็นในสภานะการณ์ที่แตกต่างกัน
Collections (คอลเล็กชัน) หรือ Generic Collections นั้นเป็นไลบรารี่ของภาษา C# ที่มีอยู่แล้ว ซึ่งเราสามารถที่จะนำมาใช้งานได้เลย โดยมันจะอยู่ภายใน Namespace System.Collections.Generic อย่างไรก็ตาม เราจะพูดถึงเฉพาะ Collection ที่มีการใช้บ่อยๆ ที่สุดเท่านั้น โดยรูปแบบการใช้งาน Generic Collections จะเป็นดังนี้

Type<Data_type> collection_name = new Type<Data_type>();

การใช้ List

List (ลิสต์) นั้นเป็นโครงสร้างข้อมูลที่ใช้ในการเก็บข้อมูลแบบเป็นลำดับ โดยมันมาแทน ArrayList ที่ถูกเลิกใช้ไปตั้งแต่ .Net Framework 2.0 สิ่งแตกต่างของมันกับอาเรย์คือ มันสามารถเก็บข้อมูลได้แบบไดนามิกส์ หรือเพิ่มขึ้นเรื่อยๆ โดยที่เราไม่ต้องบอกขนาดล่วงหน้า และเช่นเดียวกัน Collections ทกตัวนั้นเป็นไดนามิกส์ทั้งหมด
ต่อไปมาดูตัวอย่างการใช้ List ในภาษา C#

using System;
using System.Collections.Generic;

namespace CollectionsExample
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> number = new List<int>();

            number.Add(1);
            number.Add(3);
            number.Add(5);
            number.Add(7);
            number.Add(9);

            for (int i = 0; i < number.Count; i++) {
                int n = number.ElementAt<int>(i);
                Console.Write("{0}, ", n);
            }

            Console.ReadKey();
        }
    }
}

จากตัวอย่าง เราได้สร้าง List ขึ้นมาโดยลิสต์นี้จะใช้เก็บข้อมูลประเภท Integer โดยลิสต์ของเรานั้นจะมีขนาดเป็นแบบไดนามิกส์

List number = new List();

คุณสามารถเพิ่มข้อมูลเข้าไปในลิสต์ได้ไม่จำกัด โดยใช้เมธอด Add() และพารามิเตอร์นั้นเป็นข้อมูลชนิด Integer ที่คุณได้ประกาศไว้ในตอนแรก ในตัวอย่างเราได้เพิ่มเข้าไป 5 หมายเลข
number.Add(1);
number.Add(3);
number.Add(5);
number.Add(7);
number.Add(9);
ต่อมาเป็นการแสดงผลข้อมูลในลิส โดยCount; นั้นเป็นตัวแปรที่ใช้สำหรับรับค่าขนาดของลิสต์มา และเมธอด ElementAt<int>() สำหรับการนำข้อมูลออกจาก List โดยมีพารามิเตอร์เป็น index ของมัน

            for (int i = 0; i < number.Count; i++) {
                int n = number.ElementAt<int>(i);
                Console.Write("{0}, ", n);
            }

ข้างล่างนี้ผมเป็นรันของโปรแกรม ที่แสดงข้อมูลทั้งหมดภายใน List โดยการใช้คำสั่ง for loop ในการแสดงผล

1, 3, 5, 7, 9,

การใช้ Dictionary

Dictionary เป็น Generic ชนิดหนึ่งในภาษา C# ที่เก็บข้อมูลเป็นแบบคูอันดับของ Key และ Value นั่นหมายความว่ามันใช้ Key เป็น index เพื่อนำข้อมูลมาใช้ มันมักจะถูกนำมาใช้ในงานกรณีที่ Key นั้นเป็นข้อมูลชนิดอื่นๆ เช่น String ซึ่งมันรวดเร็วและสะดวก
มาดูตัวอย่างการใช้งาน Dictionary ในภาษา C#

using System;
using System.Collections.Generic;

namespace CollectionExample2
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<string, string> country = new Dictionary<string, string>();

            country.Add("us", "United State");
            country.Add("uk", "Ukrain");
            country.Add("be", "Belgium");
            country.Add("gr", "Greece");

            // Get key and value from  KeyValuePair object
            foreach (KeyValuePair<string, string> cnt in country)
            {
                Console.WriteLine("Key = {0}, Value = {1}", cnt.Key, cnt.Value);
            }

            // Direct access the value via key
            country["gr"] = "GREECE";
            Console.WriteLine("\nuk = " + country["uk"]);
            Console.WriteLine("gr = " + country["gr"]);

            // Remove string object via key
            country.Remove("us");

            if (!country.ContainsKey("us"))
            {
                Console.WriteLine("\nKey \"us\" is not found.");
            }

            Console.WriteLine("\nCount = " + country.Count);

            Console.ReadKey();
        }
    }
}

จากตัวอย่างข้างบน เราได้สร้าง Dictionary ชื่อมีชื่อว่า country โดยมี Key และ Value เป็น string เพื่อสำหรับเก็บข้อมูลตัวย่อและชื่อของประเทศนั้นๆ ด้วยคำสั่ง

Dictionary<string, string> country = new Dictionary<string, string>();

หลังจากนั้นเราใช้ฟังก์ชัน Add(para1, para2) ในการเพิ่มข้อมูล โดยมันจะมีพารามิเตอร์ของตัวคือ Key และ Value ของมัน ซึ่งแตกต่างจาก Generic แบบ List เล็กน้อย และเราได้ใช้ foreach ในการวนอ่านค่าจาก Dictionary โดยอ่านมาเก็บไว้ในออบเจ็บ KeyValuePair ที่ชื่อ cnt และเราสามารถเข้าถึง Key ได้โดย cnt.Key และสำหรับ Value โดย cnt.Value และแสดงผลมันออกมาทางหน้าจอ

            foreach (KeyValuePair<string, string> cnt in country)
            {
                Console.WriteLine("Key = {0}, Value = {1}", cnt.Key, cnt.Value);
            }

ต่อไปเป็นการเข้าถึงข้อมูลโดย Key โดยจะเข้าโดยชื่อตัวแปรและวงเล็บ [] จากตัวอย่างเราได้เปลี่ยนค่าให้กับสมาชิกที่มี Key เป็น gr ให้เป็นตัวพิมพ์ใหญ่ และแสดงผลมันออกมา

            country["gr"] = "GREECE";
            Console.WriteLine("\nuk = " + country["uk"]);
            Console.WriteLine("gr = " + country["gr"]);

ต่อไปเราได้ใช้เมธอด Remove() เพื่อลบ Key "us" ออกจาก Dictionary โดยใส่ Key ที่ต้องการลบเป็นพารามิเตอร์ และเราใช้เมธอด ContainsKey() เพื่อตรวจสอบว่ามี Key นี้อยู่หรือไม่ ถ้าไม่มีจะแสดงผลว่า ไม่พบ Key
เนื่องจากมันเป็น Generic ที่ Implement มาจากคลาสเดียวกันคุณสามารถใช้ตัวแปร Count เพื่อดูจำนวนใน Generic ชนิดต่างๆ ได้เสมอ และนี่เป็นผลลัพธ์เมื่อรันโปรแกรม

Key = us, Value = United State
Key = uk, Value = Ukrain
Key = be, Value = Belgium
Key = gr, Value = Greece

uk = Ukrain
gr = GREECE

Key "us" is not found.

Count = 3

มัน ยังมีเมธอดต่างๆ อีกมากมายที่คุณสามารถใช้ได้สำหรับ Generic แต่ละชนิดคุณสามารถตรวจสอบได้โดย Intellisense (code suggestion) ของโปรแกรม

Generic class ประเภทอื่นๆ

ในภาษา C# ยังมี Generic Collection แบบอื่นๆ อีกที่คุณสามารภใช้ได้ ตามรูปแบบของโปรแกรมของคุณ เช่น Stack เป็นออบเจ็คข้อมูลแบบสมาชิกที่เข้าทีหลังจะออกมาก่อน หรือ Queue สมาชิกที่เข้าก่อนจะออกจาก เป็นต้น
ในบทนี้คุณได้รู้จักกับ Generic พื้นฐานในภาษา C# และการใช้งานแบบต่างๆ และคุณสามารถดู Generic ทั้งหมดได้ที่นี่ https://msdn.microsoft.com/en-us/library/system.collections.generic(v=vs.110).aspx

Encapsulation

Encapsulation คืออะไร

Encapsulation (คุณสมบัติการห่อหุ้ม) เป็นคุณสมบัติหนึ่งของการเขียนโปรแกรมเชิงวัตถุ ซึ่งเป็นการกำหนดความสามารถในการเข้าถึงสมาชิกภายในคลาส ไม่ว่าทั้งจากภายนอกและภายในคลาสก็ตาม มันถูกใช้เพื่อทำให้ข้อมูลภายในเป็นความลับและมีความปลอดภัย และง่ายต่อการเขียนโปรแกรม

Access Modifiers

ประเภทข้อมูลและ ตัวแปรต่างๆ นั้นจะมีระดับการเข้าถึง ซึ่งเป็นสิ่งที่ใช้บอกว่ามันจะมีขอบเขตในการใช้งานของโปรแกรมส่วนนี้หรือ ส่วนอื่นด้วยหรือไม่ โดยรายการเข้าถึงในภาษา C# มีดังนี้

public

ตัวแปรสามารถเข้าถึงได้โดยโปรแกรมในส่วนเดียวกัน หรือจากโปรแกรมในส่วนอื่นๆ เช่น อยู่คนละ namespace หรือไฟล์

private

ตัวแปรสามารถเข้าถึงได้โดยคลาสเดียวกันหรือ struct เดียวกัน

protected

ตัวแปรสามารถเข้าถึงได้โดยคลาสเดียวกันหรือ struct เดียวกัน หรือในคลาสที่ได้รับการถ่ายทอด (inherit) มายัง

internal

ตัวแปรสามารถเข้าถึงได้โดยโปรแกรมเดียวกันเท่านั้น หรือในคลาสเดียวกัน ไม่สามารถเข้าถึงจากภายนอกคลาสได้
ต่อไปมาดูตัวอย่างของการกำหนดระดับของการเข้าถึงในภาษา C# อย่างไรก็ตามคุณได้เห็นบ้างแล้วในบทเรียนที่ผ่านมา

using System;

namespace EncapsulationExample
{
    class Program
    {
        static void Main(string[] args)
        {
            Planet a = new Planet();
            a.name = "Mars";
            a.SetRadius(3390);

            Console.WriteLine("Planet name = " + a.name);
            Console.WriteLine("Planet radius = " + a.GetRadius() + " km");

            Console.ReadKey();
        }
    }

    class Planet {

        public string name;
        private int radius;
        
        public void SetRadius (int r) {
            radius = r;
        }

        public int GetRadius () {
            return radius;
        }
    }
}

ใน ตัวอย่างด้านบน เป็นตัวอย่างการใช้ access modifier แบบ public และ private ในการสร้างตัวแปรที่อยูในคลาส Planet หลังจากนั้นเราไปสร้างออบเจ็คของคลาสนี้ในคลาสหลักของเรา คลาส Program ในการเข้าถึงตัวแปร name ของออบเจ็คสามารถเข้าผ่านคำสั่ง a.name ได้ในทันที แต่สำหรับตัวแปร radius นั้นเนื่องจากระดับการเข้าถึงเป็น private เราจะต้องเข้าถึงผ่านเมธอด SetRadius และ GetRadius ที่สร้างขึ้นในคลาสและกำหนดระดับการเข้าถึงให้กับฟังก์ชันเหล่านี้เป็น public
ใน บทนี้คุณได้เรียนรู้เกี่ยวกับ Encapsulation ในภาษา C# ซึ่งเป็นการกำหนดระดับในการเข้าถึงข้อมูลระดับต่างๆ เพื่อช่วยให้การจัดการต่างๆ ในการเขียนโปรแกรมง่ายขึ้น หรือช่วยปกติความลับบางอย่างในโปรแกรมของเรา

Overloading Operators

ในบทนี้ คุณจะได้รู้จักและการใช้งานกับ Overloading Operators ที่เราจะใช้ในการทำการดำเนินการทางคณิตศาสตร์กับข้อมูลอื่นๆ เช่น ออบเจ็ค

Overloading Operators คืออะไร

Overloading Operators คือการเปลี่ยนแปลงวิธีการทำงานของตัวดำเนินการทางคณิตศาสตร์ให้ทำงานตามที่ ต้องการ ยกตัวอย่างเช่น ในการบวกเลขสองตัวนั้น เป็นการนำค่าของพวกมันมารวมกัน ซึ่งมันใช้ได้กับตัวเลข เช่น 2 + 3 = 5
แต่ สำหรับข้อมูลแบบอื่นเช่น ต้องการเอาน้ำสองแก้วมารวมกัน ข้อมูลที่มีอาจจะเป็นรัศมีของแก้ว หรืออื่นๆ ถ้าหากแก้วนั้นเป็นเหมือนออบเจ็ค มันจึงทำให้การทำงานเมื่อนำมารวมกันนั้น ไม่ได้เป้นเหมือนตัวเลข แต่เราใช้เครื่องหมาย + เช่นเดิม
นี่เป็นรูปแบบของการทำ Overloading Operators ในภาษา C#

class MyClass
{
    public static MyClass1 operator + (MyClass2 a, MyClass3 b)
    {
        MyClass c = b;
        return c;
    }
}

จากรูปแบบข้างบนนั้นเป็นการทำ Overloading operators สำหรับคลาส MyClass1 สำหรับเครื่องหมาย + (บวก) โดยสร้างฟังก์ชันภายในคลาสนั้นให้เป็น static และใช้คำสั่ง operator ตามด้วยเครื่องหมายที่ทำการ Overload และส่งอากิวเมนต์สองตัวสำหรับ operand ทั้งสอง

การสร้างและการใช้ Overloading Operators

ในตัวอย่างนี้ เราจะขอยกตัวอย่างสำหรับการหาผลรวมน้ำในแก้วน้ำ โดยเราจะสร้างคลาสของแก้สน้ำขึ้นมา

using System;

namespace OverloadingOperators
{
    class Program
    {
        static void Main(string[] args)
        {
            Glass g1 = new Glass(5.2f, 8);
            Glass g2 = new Glass(3.2f, 10);

            float totalvolume = g1 + g2;
            Console.WriteLine("g1 and g2 sumation of volume = " + totalvolume);

            Console.ReadKey();
        }     
    }  
}

class Glass
{
    const float PI = 3.14F;

    private float radius;
    private float height;

    public Glass (float r, float h) 
    {
        radius = r;
        height = h;
    }

    public static float operator +(Glass a, Glass b)
    {
        float totalvolume = a.GetVolume() + b.GetVolume();
        return totalvolume;
    }

    public float GetVolume()
    {
        return (2 * radius * 3.14f) * height;
    }
}

ในตัวอย่างเป็นการหาผลรวม ของออบเจ็คที่สร้างจากคลาส Glass และมีค่า return เป็น float โดยในคำสั่ง g1 + g2 นั้นเป็นการทำงานจากการ overloading และมเื่อรันโปรแกรมจะได้ผลลัพธ์ดังข้างล่าง

g1 and g2 sumation of volume = 462.208

เพื่อ ให้เข้าใจมากขึ้น การทำ overloading operators นั้นคล้ายกันกับ overloading method แต่สิ่งที่ต่างกันคือในการ return ค่าต้องเลือกสำหรับค่าใดค่าหนึ่งเท่านั้น ตัวอย่างต่อไปแทนที่เราส่งค่าผลรมของปริมาตรของแก้วทั้งสองกลับ เราจะทำการส่งแก้วใบใหม่ที่มีปริมาตรเท่าเดิมแทน

using System;

namespace OverloadingOperators
{
    class Program
    {
        static void Main(string[] args)
        {
            Glass g1 = new Glass(5.2f, 8);
            Glass g2 = new Glass(3.2f, 10);

            Glass g3 = g1 + g2;
            Console.WriteLine("g3 radius = " + g3.radius);
            Console.WriteLine("g3 height = " + g3.radius);
            Console.WriteLine("g3 volume = " + g3.GetVolume());

            Console.ReadKey();
        }     
    }  
}

class Glass
{
    const float PI = 3.14F;

    public float radius;
    public float height;

    public Glass (float r, float h) 
    {
        radius = r;
        height = h;
    }

    public static Glass operator +(Glass a, Glass b)
    {
        float totalvolume = a.GetVolume() + b.GetVolume();
        float totalArea = a.GetBaseArea() + b.GetBaseArea();

        float newRadius = totalArea / 2 / PI;
        float newHeight = totalvolume / totalArea;
        Glass c = new Glass(newRadius, newHeight);
        return c;
    }

    public float GetBaseArea()
    {
        return 2 * radius * PI;
    }

    public float GetVolume()
    {
        return (2 * radius * PI) * height;
    }
}

ในตัวอย่าง นั้นเป็นการสร้าง overloading operators สำหรับออบเจ็คจากคลาส Glass เช่นเดิม แต่ตอนนี้ค่าที่ส่งกลับจำเป็นออบเจ็คของ Glass เช่นเดิม ที่มีปริมาตรเท่าเดิม และนี่เป็นผลลัพธ์เมื่อรันโปรแกรม

g3 radius = 8.4
g3 height = 8.4
g3 volume = 462.208

จากผลของโปรแกรมั้นเราได้ทำการเปลี่ยนให้เครื่องหมาย + สำหรับออบเจ็คของ Glass นั้น return ออบเจ็คของ Glass อันใหม่ ที่มีปริมาตรเท่าเดิม และมีรัศมีและความสูงใหม่เป็นอย่างที่เห็น
และแน่นอนคุณสามารถใช้เครื่องหมายเหล่านี้ ในการทำ overloading operators ในภาษา C#

Operators	Number of operand
+	1 or 2
-	1 or 2
!	1
~	1
++	1
--	1
*	2
/	2
%	2
==	2
!=	2
<	2
>	2
<=	2
>=	2

ตัวอย่างการใช้งานต่างๆ

public static SomeObjectA operator - (SomeObjectB a, SomeObjectC b)
{
    // do something
    return ...; // SomeObjectA
}

public static bool operator == (SomeObjectB a, SomeObjectC b)
{
    // do something
    return ...; // SomeObjectA
}

public static SomeObjectA operator ++ (SomeObjectB a)
{
    // do something
    return ...; // SomeObjectA
}

ในบทนี้คุณได้รู้จักและได้รู้การสร้างและการใช้งาน Overloading operators เพื่อให้การทำงานเป็นไปตามที่ต้องการได้

Enums

Enum คืออะไร

Enum เป็นประเภทข้อมูลที่เป็นชุดของตัวเลขจำนวนเต็ม โดยค่าที่ใช้ในการประกาศ enum นั้นจะเป็น String literal ใดๆ โดยค่าเหล่านี้ถือว่าเป็นค่าคงที่ของจำนวนเต็ม รูปแบบการใช้ enum ในภาษา C# เป็นดังนี้:

enum Name{ Value1, Value2, ... };

โดยคำสั่ง enum นั้นจะใช้สำหรับการสร้าง enum และ Name เป็นชื่อชอง enum ที่สร้างขึ้น และภายในวงเล็บ {} นั้นจะเป็นชุดค่าของ enum โดยมาสามารถเป็น literal ใดๆ ที่ C# อนุญาติให้ทำได้
ต่อไปมาดูตัวอย่างการสร้างและใช้งานของ enum

using System;

namespace EnumExample
{
    class Program
    {
        enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };

        static void Main(string[] args)
        {
            int a = (int)Days.Sunday;
            int b = (int)Days.Monday;
            Console.WriteLine("Sunday is number #" + a);
            Console.WriteLine("Monday is number #" + b);

            Console.ReadKey();
        }
    }
}

ใน ตัวอย่าง เราได้ประกาส enum ของวันขึ้นมา โดยค่าของมันจะเรียงจาก Sunday ถึง Saturday ซึ่งมันแทนได้กับค่าจำนวนเต็มที่เริ่มจาก 0 ในการเปรียบเทียบหรือกำหนดค่านั้นในภาษา C# ข้อมูลต้องตรงกันเสมอ นั้นคือต้องทำการ casting ก่อนทุกครั้ง และข้างล่างนี้คือผลของการรันโปรแกรมนี้

Sunday is number #0
Monday is number #1

นอกจากนี้เรายังสามารถสร้างตัวแปรประเภท Enum เพื่อที่จะนำมาเก็บข้อมูล และ casting ข้อมูลเป็นในรูปแบบของ enum ได้

using System;

namespace EnumExample
{
    class Program
    {
        enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };

        static void Main(string[] args)
        {
            Days weekend = Days.Monday;
            
           if (weekend == Days.Sunday || weekend == (Days)6) {
                Console.WriteLine("This is week end.");
           } 
           else
           {
                Console.WriteLine("This is week day.");
           }

            Console.ReadKey();
        }
    }
}

จากตัวอย่าง เราได้สร้างตัวแปร enum คือ weekend มาเก็บข้อมูล มันสามารถนำไปเปรียบเทียบกับข้อมูลประเภท enum ได้เลยหรือตัวเลขก็ได้

Custom enum indexes

นอกจากนี้ ในภาษา C# ยังมีความสามารถที่จะให้เรากำหนดค่าให้กับ enum เองได้

using System;

namespace EnumExample
{
    class Program
    {    
        enum CarStatus {
            Poweroff = 0,
            Runing = 5,
            Stoped = 2,
            Overhead = 10,
            Runing_backward = 9
        }; 

        static void Main(string[] args)
        {
            int[] schedul = { 5, 5, 10, 2, 0 };

            for (int i = 0; i <schedul.Length; i++) {
                Console.WriteLine("Step " + (i + 1) + ": " + (CarStatus)schedul[i]);
            } 
            Console.ReadKey();
        }
    }
}

ใน ตัวอย่าง เราได้ใช้ enum ในการเก็บ state ของรถยนต์ ซึ่งในภาษา C# เราสามารถแสดงค่าของ enum ได้เช่นกัน ข้างล่างเป็นลัพธ์ของโปรแกรม

Step 1: Runing
Step 2: Runing
Step 3: Overhead
Step 4: Stoped
Step 5: Poweroff

ในบทนี้ คุณจะได้รู้จักและเรียนรู้วิธีการใช้ enum ในภาษา C# ซึ่งมันสามารถนำไปประยุกต์ใช้ได้ในหลายสถานะการณ์

Exception

ในบทนี้ คุณจะได้เรียนและทำความรู้จักกับ Exception ในภาษา C# รวมถึงการใช้งาน Exception ไลบรารี่ที่ภาษา C# มีให้ และการจัดการและสร้าง Exception แบบกำหนดเองของคุณ

Exception คืออะไร

Exception คือข้อผิดพลาดที่เกิดขึ้นที่เกิดขึ้น ในขณะที่โปรแกรมกำลังทำงานในเงื่อนไขที่ไม่เหมาะสม แล้วโปรแกรมไม่รู้วิธีการจัดการกับข้อผิดพลาดนี้ ทำให้โปรแกรมแสดงข้อผิดพลาดให้เราทราบออกทาง Console และโปรแกรมหยุดทำงานหรือ Crash
ในบางครั้งโปรแกรมของเราทำงานขึ้นกับ สภาวะแวดล้อมอื่น เช่น การหารตัวเลขด้วย 0 การรับค่ามาจากผู้ใช้ หรือการที่ไม่สามารถเชื่อมต่ออินเตอร์เน็ตได้ ทำให้เกิด Exception ขึ้น เราต้องจัดการเพื่อให้โปรแกรมสามารถที่จะทำงานต่อไปได้ ในภาษา C# คุณสามารถใช้ Exception จากไลบรารี่ทีมีอยู่หรือสร้างขึ้นมาเองได้ โดยมีรูปแบบการใช้งานดังนี้

try {
    // Statement to execute
}
catch (ExceptionType1 ex1) {
    // Handing exception 1
}
catch (ExceptionType2 ex2) {
    // Handing exception 2
}
...
catch (ExceptionTypen exn) {
    // Handing exception n
}

โดยในบล็อคคำสั่ง try เป็นส่วนของการทำงานที่ของโปรแกรม และบล็อคคำสัง catch เป็นการจัดการกับ exception แต่ละแบบที่เกิดขึ้น โดย Exception นั้นสามารถเกิดขึ้นได้เพียงหนึ่งอย่างเท่านั้นในขณะหนึ่งเวลาของโปรแกรม

การใช้งาน Exception

ต่อไปเป็นตัวอย่างการจัดการ Exception ที่เกิดขึ้น โดยตัวอย่างนี้จะเป็นการใช้ Exception ออบเจ็ค DivideByZeroException จาก namespace system ของภาษา C# โดยเป็นโปรแกรมหารตัวเลขอย่างง่าย โดยโปรแกรมจะรับตัวเลขสองตัวมาจากผู้ใช้และทำการหาร

using System;

namespace Exception1
{
    class Program
    {
        static void Main(string[] args)
        {
            int a;
            int b;

            Console.WriteLine("Divider Program");

            Console.Write("Enter number a: ");
            a = Int16.Parse(Console.ReadLine());
            Console.Write("Enter number b: ");
            b = Int16.Parse(Console.ReadLine());

            try {
                Console.WriteLine("The result of a / b is " + (a / b));
            } catch (DivideByZeroException ex) {
                Console.WriteLine("Exception Divide by Zero occur:" + ex);
            }
            Console.ReadKey();
        }
    }
}

จาก ตัวอย่างนั้น เราได้รับค่าตัวเลขสองตัวจากผู้ใช้มาทางคีย์บอร์ด ผู้ใช้สามารถใส่ค่าของตัวเลขใดๆ และหน้าที่ของโปรแกรมคือการนำตัวเลขมาหารและแสดงผลให้กับผู้ใช้

คำสั่ง try catch

การใช้ Exception นั้นจะเริ่มต้นด้วยคำสั่ง try โดยในบล็อคของคำสั่งนี้จะเป็นส่วนที่คาดว่า Exception จะเกิดขึ้น โดยในตัวอย่างก็คือการหารตัวเลขด้วย 0 นั่นหมายความว่ามันมีโอกาศที่ผู้ใช้จะกรอกค่า b เป็น 0 ได้

            try {
                Console.WriteLine("The result of a / b is " + (a / b));
            }

และต่อมาในบล็อคของคำสั่ง catch เป็นส่วนในการจัดการเมื่อเกิด Exception ขึ้น นั่นคือเมื่อผู้ใช้ใส่ตัวเลขสำหรับ b เป็น 0 โปรแกรมจะทำการ throw exception มายังบล็อคนี้

            catch (DivideByZeroException ex) {
                Console.WriteLine("Exception Divide by Zero occur:" + ex);
            }

และข้างล่างเป็นตัวอย่างของโปรแกรม เมื่อผู้ใช้กรอกตัวเลขที่สามารถการกันได้ นั่นก็คือตัวหารไม่เป็น 0

Divider Program
Enter number a: 15
Enter number b: 3
The result of a / b is 5

แหละ ข้างล่างเป็นตัวอย่างเมื่อผู้ใช้กรอกตัวหารเป็น 0 โปรแกรมจะ throw exception ไปยังบล็อคของคำสั่ง catch และแสดงผลของ exception ในออบเจ็ค ex ออกมา ซึ่งเกิดจากการ Override ในเมธอด ToString ของออบเจ็ค คุณจะได้เรียนในต่อไป

Divider Program
Enter number a: 10
Enter number b: 0
Exception Divide by Zero occur: System.DivideByZeroException: Attempted to divide by zero...

จาก ตัวอย่างข้างบนคุณคิดว่ามันเพียงพอสำหรับการจัดการ Exception ที่น่าจะเกิดขึ้นแล้วใช่ไหม คำตอบคือไม่ใช่ ยังมีอย่างอื่นที่สามารถเกิดขึ้น นั้นคือในตอนที่ผู้ใช้กรอกข้อมูลประเภทอื่นเข้ามาที่ไม่ใช่ตัวเลข ใช่แล้วคุณควรจะจัดการกับมันเพื่อให้โปรแกรมของคุณทำงานได้ดีที่สุด โดยการใช้ Exception ออบเจ็ค FormatException

using System;

namespace Exception1
{
    class Program
    {
        static void Main(string[] args)
        {
            int a;
            int b;

            bool succeed;

            Console.WriteLine("Divider Program");

            try {
                Console.Write("Enter number a: ");
                a = Int16.Parse(Console.ReadLine());
                Console.Write("Enter number b: ");
                b = Int16.Parse(Console.ReadLine());

                try
                {
                    Console.WriteLine("The result of a / b is " + (a / b));
                }
                catch (DivideByZeroException ex)
                {
                    Console.WriteLine("Exception Divide by Zero occur: " + ex);
                }

            } catch (FormatException ex) {
                Console.WriteLine("You must enter numbers.");
            } finally {
                Console.WriteLine("The program always enter finally block.");
            }
          
            Console.ReadKey();
        }
    }
}

ใน ตอนนี้เราได้พัฒนาโปรแกรมของเราให้จัดการกับข้อมูลที่ไม่ถูกต้องได้แล้ว นั่นคือเมื่อผู้ใช้หรอกอย่างอื่นที่ไม่ใช้ในรูปแบบของตัวเลข เพราะการใช้เมธอด Int16.Parse() เป็นเมธอดในการแปลง string ไปเป็น Integer นั้นจะทำให้เกิด Exception ขึ้นในกรณีที่ข้อมูลที่นำมาแปลงไม่ใช่ตัวเลข คุณเห็นบางอย่างซับซ้อนขึ้น นั่นคือเราได้ทำการซ้อน Exception เพราะว่าแน่นอน มันสามารถซ้อนกันได้เหมือนกับคำสั่ง If อยู่แล้ว และคุณเห็นคำสั่งใหม่เพิ่มเข้ามาคือ finally

คำสั่ง Finally

ใน บล็อคของคำสั่ง Finally นั้นจะเป็นบล็อคที่โปรแกรมจะเข้ามาทำงานเสมอ หลังจากที่มันทำงานในบล็อคของ try เสร็จ หรืออาจจะเป็นในบล็อคของ catch ก็ตาม มันมักจะใช้กับการทำงานที่มีโอกาสเกิดข้อผิดพลาดขึ้นในคำสั่ง try แต่ไม่มีการ Throw Exception เช่นการทำงานกับไฟล์ การเปิดไฟล์นั้นไม่ว่าจะเปิดสำเร็จหรือไม่ ก็ไม่เกิด Exception ดังนั้นคำสั่ง Finally ใช้สำหรับจัดการเมื่อการทำงานเสร็จสิ้นหรือไม่เป็น สำหรับตัวอย่าง

System.IO.FileStream file = null;
System.IO.FileInfo fileinfo = new System.IO.FileInfo("D:\\marcus.txt");
try
{
    file = fileinfo.OpenWrite();
    file.WriteByte(1);
}
finally
{
    // Check if file is successfully opened
    if (file != null)
    {
        file.Close();
    }
}

Throwing Exceptions

เมื่อเกิด Exception ขึ้นโปรแกรม จะ Throw exception ไปยัง catch block และในภาษา C# นั้นคุณสามารถใช้คำสั่ง throw เพื่อ throw exception ไปยัง Exception Handle ที่คุณต้องการได้

using System;

namespace Exception1
{
    class Program
    {
        static void Main(string[] args)
        {
            int index = -1;
            string[] array = new string[] { "One", "Two", "Three" };
 
            try
            {
                if (index > array.Length - 1)
                    throw new IndexOutOfRangeException();
                else if (index < 0)
                    throw new ArgumentException();
                Console.WriteLine("Your number is " + array[index]);
            }
            catch (IndexOutOfRangeException ex)
            {
                Console.WriteLine("IndexOutOfRangeException is thrown.");
            }
            catch (ArgumentException ex)
            {
                Console.WriteLine("ArgumentException is thrown.");
            }

            Console.ReadKey();
        }
    }
}

จาก ตัวอย่างด้านบน เป็นการใช้คำสั่ง throw ในการ throw exception ไปยัง catch block ที่ต้องการ โดยปกตินั้นถ้าหาก index ของอาเรย์ไม่ถูกต้องโปรแกรมจะทำการ throw ไปยัง IndexOutOfRangeException อยู่แล้ว แต่ในตอนนี้เราได้ให้โปรแกรม throw ไปยัง ArgumentException ได้ถ้าหาก index เป็นค่าลบ

Creating Exceptions

บางครั้งคุณ อาจจะต้องการสร้าง Exception ของคุณเพื่อจัดการกับบางอย่างที่ในภาษา C# ไม่มีให้ แน่นอนคุณสามารถทำได้ โดยสร้าง Exception ของคุณขึ้นมาเพื่อจัดการกับปัญหา โดยการสร้างคลาสที่ inherit มาจากคลาส System.Exception

using System;
using System.Collections.Generic;

namespace Exception1
{
    class Program
    {
        static void Main(string[] args)
        {

            List<string> names = new List<string>();
            names.Add("Marcus");
            names.Add("James");
            names.Add("Daneil");

            string nameSearch = "Thomas";

            try {
                if (!names.Contains(nameSearch)) {
                    throw new NameNotFoundException(nameSearch);
                } else {
                    Console.WriteLine("Hello " + nameSearch + "!");
                }
            }
            catch (NameNotFoundException ex) {
                Console.WriteLine(ex);
            }

            Console.ReadKey();
        }
    }


    public class NameNotFoundException : Exception
    {
        string name;

        public NameNotFoundException()
        {
        }

        public NameNotFoundException(string message)
            : base(message)
        {
            this.name = message;
        }

        public NameNotFoundException(string message, Exception inner)
            : base(message, inner)
        {
        }

        public override string ToString()
        {
            return "A person named \"" + this.name + "\" is not found.";
        }
    }
}

จาก ตัวอย่างเป็นการสร้างคลาส exception ของคุณเอง เราเรียกว่า user-defined exception เป็น Exception ในการจัดการในกรณีที่ไม่มีชื่ออยู่ใน List เราใช้คำสั่ง if เพื่อตรวจสอบว่ามีคนที่ชือ Thomas มรลิสต์หรือไม่

if (!names.Contains(nameSearch)) {
     throw new NameNotFoundException(nameSearch);
}

ถ้ามีเราก็แสดงการทักทาย และถ้าไม่มีในตอนนี้เราจะทำการ Throw ไปยัง Exception ที่เราได้สร้างขึ้น ด้วยคำสั่ง throw new NameNotFoundException(nameSearch); และส่ง nameSeach เป็นพารามิเตอร์สำหรับ constructor ของคลาส ผลลัพธ์ก็คือโปรแกรมทำการ throw ไปยัง catch block ของ NameNotFoundException

User-Defined Exceptions

เราได้สร้างคลาส Exception ที่มีชื่อว่า NameNotFoundException โดย inherit จากคลาส Exception ที่อยู่ภายในเนมสเปซ system ของภาษา C# โดยมี constructor 3 แบบ โดย constructor เราใช้ในตัวอย่างคือ

public NameNotFoundException(string message)

โดยเก็บค่าของชื่อเก็บไว้ในตัวแปร name ของคลาส เพราะว่าใน catch block โปรแกรมหลักนั้น เราได้ใช้คำสั่ง Console.WriteLine(ex); ซึ่งเป็นการเรียกใช้ตัวแปรออบเจ็ค (object instance) โดยผลลัพธ์ที่ได้จากตัวแปรนั้นจะเป็นค่าที่ได้มากจากเมธอด ToString() ต่อไปเราได้ทำการ override เมธอด ToString() เพื่อให้มันแสดงข้อความตามที่ต้องการ (ถ้าคุณไม่ override มันจะแสดงจาก base คลาสโดย default)

        public override string ToString()
        {
            return "A person named \"" + this.name + "\" is not found.";
        }

และในผลลัพธ์โปรแกรมของเราจะแสดงข้อความ "A person named "Thomas" is not found." เพราะว่าเป็นผลจากเมธอด ToString
ใน บทนี้ คณได้เรียนรู้เกี่ยวกับการใช้งาน Exception ในภาษา C# นอกจากนี้คุณยังสามารถสร้าง Exception ของคุณได้เอง เพื่อจัดงานในงานที่คุณต้องการที่ในภาษา C# ไม่มีให้

Interfaces

ในบทนี้ เราจะแนะนำให้คุณรู้จักกับ Interface ในภาษา C# และวิธีใช้งานร่วมกับ Inheritance ของคลาส ซึ่งถือว่าเป็นคุณสมบัติหนึ่งของการเขียนโปรแกรมเชิงวัตถุ

Interfaces คืออะไร

Interfaces นั้นจะประกอบไปด้วยข้อกำหนดที่สร้างขึ้นเท่านั้น ซึ่งจะประกอบไปด้วยเมธอด properties events หรือ indexers มันถูกใช้สำหรับการ implement ของคลาส โดยในการนำ interfaces ไป implement นั้นจะต้องทำการ define เมธอด body ให้กับ interfaces เสมอ
รูปแบบของการสร้าง Interface ในภาษา C# เป็นดังนี้

interface InterfaceName
{
    void method1();
    // ...
}

ในการประกาศ interface นั้นคุณจะต้องใช้คำสั่ง interface และสมาชิกของมันเช่น method นั้นไม่ต้องมีส่วนของการทำงานอะไร เพราะว่ามันจะถูกนำไป implement โดยคลาสนั้นเอง ในการ implement interfaces นั้นจะใช้เครื่องหมาย : ซึ่งเป็นเรื่องหมายเดียวกับการ Inheritance ถ้ามีการ Inherit อยู่ก่อนแล้วจะใช้เครื่องหมาย , แทน
คุณสามารถทำการ implement ได้หลาย interfaces โดยการใช้เครอื่งหมาย comma เช่นกัน ต่อไปมาดูตัวอย่างการใช้าน Interface

using System;

interface Verchicle
{
    void move();
}


class Cars : Verchicle
{
    void Verchicle.move() {
        Console.WriteLine("Driving on the groud");
    }
}

class Boat : Verchicle
{
    void Verchicle.move()
    {
        Console.WriteLine("Sailing on the water");
    }
}

class Program {
    static void Main(string[] args) 
    {
        Cars car = new Cars();
        Boat boat = new Boat();

        car.move();
        boat.move();

        Console.ReadKey();
    }
}

ในตัวอย่างนั้น เราได้สร้าง Interfaces ที่ชื่อว่า Verchicle ขึ้นมา เพื่อกำหนดการทำงานให้กับยานพาหนะใดๆ เช่น เมธอด move นั้นการบอกการทำงานว่ามีอะไร แต่ไม่ประกาสการทำงานของมันใน Interfaces เพราะเราจะนำไป implement สำหรับยานพาหนะต่างๆ ซึ่งมันเคลื่อนที่ไม่เหมือนกันนั้นเอง
นอกจากนี้ Interfaces ยังสามารถใช้ในการสร้างตัวแปรได้ ซึ่งทำให้มันเป็นคุณสมบัติของ Polymorphism ในภาษา C# ด้วยนั้นเอง เช่นการเปลี่ยนในเมธอด Main เป็น

Verchicle car = new Cars();
Verchicle boat = new Boat();

car.move();
boat.move();

แต่อย่างไรก็ตามก็ยังต้อง instance จาก class ที่ implement มันเสมอ new Cars() หรือ new Boat() ซึ่งทั้งสองแบบนั้นจะได้ผลัพธ์เหมือนกันดังข้างล่าง

Driving on the ground
Sailing on the water

ใน บทนี้คุณได้เรียนรู้เกี่ยวกับ Interfaces ในภาษา C# และการใช้งานของมัน ซึ่งจะมีประโยชน์ในการประกาศบอกวาจะมีการทำงานนี้ไว้ล่วงหน้า แต่การทำงานของแต่ละคลาสนั่นจะไม่เหมือนกันซึ่งต้องนำไป implement โดยคลาส

Structs

ในบทนี้ คุณจะได้เรียนรู้เกี่ยวกับโครงสร้างข้อมูลในภาษา C#

โครงสร้างข้อมูล คืออะไร

โครง สร้างข้อมูล (Struct) เป็นตัวแปรที่ใช้สำหรับเก็บค่ามากกว่า 1 ค่าในตัวแปรเดียว โครงสร้างข้อมูลนั้นคล้ายคลึงกับคลาส แต่ว่ามันจะม่สามารถสืบทอดได้ รูปแบบการประกาศโครงสร้างข้อมูล มีดังนี้

struct Name {
    // struct members
}

ในการประกาศโครงสร้างข้อมูล นั้นจะใช้คำสั่ง struct และ Name คือชื่อของโครงสร้างข้อมูลที่ประกาศขึ้น สมาชิกของโครงสร้างข้อมูลนั้นจะมีสองแบบเช่นเดียวกันกับคลาสคือตัวแปรและเมธ อด ตัวแปรสามารถเป็นได้ทั้งตัวแปรแบบ Value และ Reference มาดูตัวอย่างในกรณีที่เราจะใช้โครงสร้างข้อมูล
ยกตัวอย่างเช่น เราต้องการเก็บข้อมูลของเมื่อง โดยเมื่อแต่ละเมืองก็จะมีข้อมูลที่แยกย่อยลงไปอีก เช่น ชื่อ ประเทศ และจำนวนประชากร ดังนั้นเราจะใช้โครงสร้างข้อมูลซึ่งจะง่ายในการเก็บ สำหรับ struct นั้นสมาชิกทุกตัวจะต้องมี access specifier เป็น public เสมอ

using System;

struct City {
    public string name;
    public string contry;
    public int population;
}

class StructsExample
{
    static void Main(string[] args)
    {
        City city1;
        City city2;

        city1.name = "New York City";;
        city1.contry = "United State";
        city1.population = 2636735;

        city2.name = "Kiev";
        city2.contry = "Ukraine";
        city2.population = 2900920;

        Console.WriteLine("Details of city 1");
        Console.WriteLine("Name = " + city1.name);
        Console.WriteLine("Contry = " + city1.contry);
        Console.WriteLine("Population = " + city1.population);

        Console.WriteLine("\nDetails of city 2");
        Console.WriteLine("City Name = " + city2.name);
        Console.WriteLine("Contry = " + city2.contry);
        Console.WriteLine("Population = " + city2.population);

        Console.ReadKey();
    }
}

จาก ตัวอย่างเราได้สร้างโครงสร้างข้อมูลที่มีชื่อว่า City ขึ้นมา และเก็บข้อมูลประเภทต่างๆ ของมัน ในการเข้าถึงสมาชิกของ struct นั้นจะใช้เครืองหมายจุด (.) ในการสร้างตัวแปรสำหรับโครงสร้างนี้นั้น ก็สร้างโดยใช้คำสั่งต่อไปนี้

City city1;
City city2;

คุณ จะสังเกตุว่ามันคล้ายๆ การสร้างตัวแปรตัวไป เพียงแค่ City นั้นเป็นตัวแปรชนิดออบเจ็คเท่านั้นเอง แต่มันไม่ได้เป็นออบเจ็คในรูปแบบ OOP นอกจากนี้โครงสร้างข้อมูลยังสามารถประกาศเป็นแบบอาเรย์ได้เช่นกัน

Array of structure

เรา สามารถสร้างตัวแปรอาเรย์ให้กับโครงสร้างข้อมูลได้เหมือนตัวแปรทั่วไป และสามารถสร้างได้ทั้งอาเรย์ทั่วไปหรือ Jagged อาเรย์ มาดูตัวอย่างการสร้างอาเรย์กับโครงสร้างข้อมูล

using System;

struct City {
    public string name;
    public string contry;
    public int population;
}

class StructsExample
{
    static void Main(string[] args)
    {
        City[] city = new City[2];

        city[0].name = "New York City";;
        city[0].contry = "United State";
        city[0].population = 2636735;

        city[1].name = "Kiev";
        city[1].contry = "Ukraine";
        city[1].population = 2900920;

        Console.WriteLine("Details of city 1");
        Console.WriteLine("Name = " + city[0].name);
        Console.WriteLine("Contry = " + city[0].contry);
        Console.WriteLine("Population = " + city[0].population);

        Console.WriteLine("\nDetails of city 2");
        Console.WriteLine("City Name = " + city[1].name);
        Console.WriteLine("Contry = " + city[1].contry);
        Console.WriteLine("Population = " + city[1].population);

        Console.ReadKey();
    }
}

เรา ได้ใช้ตัวอย่างก่อนหน้านำมาสร้างเป็นแบบอาเรย์ ที่มีขนาดเท่ากับสอง ซึ่งจากสองตัวอย่างก่อนหน้านั้นจะได้ผลลัพธ์ที่เหมือนกันคือดังข้างล่างนี้

Details of city 1
Name = New York City
Contry = United State
Population = 2636735

Details of city 2
City Name = Kiev
Contry = Ukraine
Population = 2900920

New keyword และเมธอด

เหมือน ที่ได้กล่าวไปแล้วก่อนหน้านี้ว่า struct สามารถมี constructor และเมธอดได้เช่นกัน ในการสร้าง struct ที่มี constructor นั้นจะใช้คำสั่ง new ในการประกาศตัวแปรให้กับ struct มาดูตัวอย่างของโครงสร้างข้อมูลต่อไปนี้

using System;

struct City {
    public string name;
    public string contry;
    public int population;
    public float area;

    public City(string name, string contry, int population, float area) {
        this.name = name;
        this.contry = contry;
        this.population = population;
        this.area = area;
    }

    public float getDensity () {
        return (float) population / area;
    }
}

class StructsExample
{
    static void Main(string[] args)
    {
        City city = new City("New York City", "United State", 2636735, 468.9F);

        Console.WriteLine("Name = " + city.name);
        Console.WriteLine("Contry = " + city.contry);
        Console.WriteLine("Population = " + city.population);
        Console.WriteLine("Area = " + city.area + "sq mi");
        Console.WriteLine("Density = " + city.getDensity() + " people/sq mi");
        Console.ReadKey();
    }
}

จาก ตัวอย่างเราได้ประกาศ Constructor สำหรับ struct โดยมันจะมีชื่อที่เหมือนกัน ใน Construct นั้นจะต้องกำหนดค่าให้กับสมาชิกทุกตัวเสมอ และเมื่อสร้างตัวแปรของ struct จะใช้คำสั่ง new และมีเมธอด getDensity ซึ่งการเรียกใช้งานก็จะเหมือนกับคลาส

Name = New York City
Contry = United State
Population = 2636735
Area = 468.9sq mi
Density = 5623.235 people/sq mi

และนี่คือผลลัพธ์ของโปรแกรม
ในบทนี้คุณได้เรียนรู้ในการสร้างและการใช้งานโครงสร้างข้อมูลในภาษา C# และการนำไปใช้กับอาเรย์ และเมธอดในโครงสร้างข้อมูล

Properties

Properties คืออะไร

Properties คือสมาชิกของคลาสที่ทำให้สามารถอ่านหรือเขียนข้อมูลให้กับตัวแปรในคลาสได้ ซับซ้อนขึ้น โดยปกติจะใช้กับตัวแปรที่เป็น private ที่จะใช้กับ property
ใน ภาษา C# นั้น ตัวแปรที่เรียกว่า property จะเป็นเมธอดพิเศษที่เรียกว่า accessors ซึ่งจะเป็นตัวช่วยให้การอ่านข้อมูลได้ง่ายขึ้น รวมถึงความหลอดภัยและความยืดหยุ่นของการใช้คลาสตัวแปรในคลาสจากภายนอก โดยมันมีรูปแบบในการกำหนดดังนี้

public returnType PropertyName
{
    get
    {
        return // data to return; 
    }
    set { 
        privateField = value;
    }
}

จาก รูปแบบของการประกาศ properties นั้นจะเห็นว่ามันคล้ายกับฟังก์ชัน แต่เพียงจะมีเมธอดย่อยแยกลงไปอีกคือ get และ set โดยในการส่งค่ากลับหรือกำหนดค่านั้น สามารถทในรูปแบบ expressions ได้ สำหรับตัวแปร value นั้นจะเป็นค่าคงที่ของค่าที่ส่งเข้ามา

สร้างและใช้งาน Properties ในภาษา C#

มาดูตัวอย่างการใช้งานของ property ที่เกี่ยวกับอุณหภูมิ เพื่อให้คุณได้เข้าใจเกี่ยวกับการใช้งานของ Property ได้มากขึ้น

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Properties
{
    class Location {

        public string name;
        private double celsius = 0;

        public double Celsius
        {
            get { return celsius; }
            set { celsius = value; }
        }

        public double Fahrenheit
        {
            get { return (celsius * 1.8) + 32; }
            set { celsius = (value - 32) * 5.0 / 9.0;}
        }

    }
    class Program
    {
        static void Main(string[] args)
        {
            Location a = new Location();
            Location b = new Location();
            Location c = new Location();

            a.name = "New York";
            a.Fahrenheit = 56;

            b.name = "Bangkok";
            b.Celsius = 32;

            c.name = "Kiev";
            c.Fahrenheit = 32;

            Console.WriteLine("Temperature in " + a.name + " is " + (int)a.Celsius + " C");
            Console.WriteLine("Temperature in " + b.name + " is " + b.Fahrenheit + " F");
            Console.WriteLine("Temperature in " + c.name + " is " + c.Fahrenheit + " F");

            Console.ReadKey();
        }
    }
}

จากตัวอย่างด้านบนเป็นการใช้ properties ในภาษา C# เราได้สร้างคลาส Location ขึ้นมาและมีตัวแปร celsius ซึ่งเป็นตัวแปรแบบ private โดยเราจะใช้ property ในการอ่านและเขียนข้อมูลสำหรับมัน เรามีสอง properties คือ Celsiusและ Fahrenheit โดยทั้งสองนี้จะมีฟัวก์ชันสำหรับการ set และ get แยกกัน นั่นหมายความว่า คุณสามารถแก้ไขหรือปรับปรุงค่าก่อนที่จะเก็บได้
เรา ได้สร้าง property เหล่านี้ขึ้นมาสำหรับอ่านและเขียนอุณหภูมิ โดยคุณสามารถกำหนดค่าอุณหภูมิในรูปแบบองศา Celsius แล้วดูเป็นแบบองศา Fahrenheit ได้ หรือในทางกลับกัน หรือจะใช้องศาเดียวกันทั้งสองก็ได้ ในการอ่านหรือเขียนค่าก็เข้าผ่าน property เหมือนกับตัวแปรได้เลย เช่นในคำสั่ง a.Fahrenheit

Temperature in New York is 13 C
Temperature in Bangkok is 89.6 F
Temperature in Kiev is 32 F

และนี่เป็นผลลัพธ์ของโปรแกรมดังกล่าว และในบทนี้คุณได้เรียนรู้และรู้จักวิธีการนำ property ไปประยุกต์ใช้ ซึ่งอำนวยความสะดวกได้มาก

Polymorphism

ในบทนี้คุณจะได้รู้จักกับคุณสมบัติ Polymorphism ในภาษา C# ซึ่งมันเป็นคุณสมบัติที่สำคัญอย่างหนึ่งในการเขียนโปรแกรมเชิงวัตถุที่รองลง มาจาก Inheritance และ Encapsulation

Polymorphism คืออะไร

Polymorphism นั้นคือการมีได้หลายรูปแบบ โดยมันเป็นคำที่ถูกใช้ในการเขียนโปรแกรมเชิงวัตถุ ที่จะใช้ในการสร้างคลาสลูก (Derived class) โดยทำการ Override กับ Virtual เมธอดของคลาสหลัก (Base class) และเราสามารถสั่งการทำงานเมธอดในคลาสหลักและได้ผลลัพธ์การทำงานของคลาสลูก แทน
มาดูตัวอย่างสำหรับ Polymorphism ในภาษา C# ยกตัวอย่างเช่น เรามีคลาสของสัตว์ ซึ่งสัตว์แต่ละชนิดนั้นสามารถที่จะเคลื่อนที่ได้ แต่วิธีการเคลื่อนของมันแตกต่างกัน

using System;

namespace Polymorphism
{
    class Animals
    {
        public string name;
        public int height;
        public int weight;

        public virtual void Move()
        {
            Console.WriteLine("Perform base class move");
        }
    }

    class Dog : Animals {
        public override void Move()
        {
            Console.WriteLine("Running on the ground");
        }

    }

    class Fish : Animals
    {
        public override void Move()
        {
            Console.WriteLine("Swimming in the water");
        }
    }

    class Bird : Animals
    {
        public override void Move()
        {
            Console.WriteLine("Frying in the air");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Animals dog = new Dog();
            Animals fish = new Fish();
            Animals bird = new Bird();

            dog.Move();
            fish.Move();
            bird.Move();

            Console.ReadKey();
        }
    }
}

ใน ตัวอย่างนั้น เป็นตัวอย่างหนึ่งของ Polymorphism นั่นคือสร้างตัวแปรคลาสโดยการใช้ Base class ของมัน สำหรับ Constructor นั้นจะเป็นของ Delivered class เอง เช่นในคำสั่ง Animals dog = new Dog() ซึ่งถ้าเป็นในคุณสมบัติของการสืบทอดนั้นจะเป็น Dog dog = new Dog() ซึ่งตรงนี้เองทำให้มันแตกต่างไป ซึ่งจะทำให้มันสามารถนำไปใช้ง่าย เช่น เก็บในข้อมูลชนิดเดียวกัน เช่น เก็บในอาเรย์ Generic หรือส่งไปยังเมธอด
ต่อไปมาดูตัวอย่างเพิ่มเกี่ยวกับการใช้ประโยชน์จาก Polymorphism

using System;
using System.Collections.Generic;

namespace Polymorphism
{
    class Animals
    {
        public string name;
        public int height;
        public int weight;

        public virtual void Move()
        {
            Console.WriteLine("Perform base class move");
        }
    }

    class Dog : Animals {
        public override void Move()
        {
            Console.WriteLine("Running on the ground");
        }

    }

    class Fish : Animals
    {
        public override void Move()
        {
            Console.WriteLine("Swimming in the water");
        }
    }

    class Bird : Animals
    {
        public override void Move()
        {
            Console.WriteLine("Frying in the air");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // arrays
            Animals[] arr = new Animals[3];
            arr[0] = new Dog();
            arr[1] = new Fish();
            arr[2] = new Bird();

            Console.WriteLine("C# Arrays:");
            foreach (Animals a in arr)
            {
                AnimalMove(a);
            }

            // Generic
            List<Animals> gener = new List<Animals>();
            gener.Add(new Dog());
            gener.Add(new Fish());
            gener.Add(new Bird());

            Console.WriteLine("\nC# Generic:");
            foreach (Animals a in gener)
            {
                AnimalMove(a);
            }

            Console.ReadKey();
        }

        public static void AnimalMove (Animals a) {
            a.Move();
        }
    }
}

ใน ตัวอย่าง เป็นการให้เห็นว่าเราสามารถเก็บข้อมูลได้แบบไดนามิกส์ โดยไม่ต้องสนใจว่าจะสร้างมาจากคลาสไหน โดยเราได้ใช้คลาสแม่ในการประกาศตัวแปร และในการใช้งานฟังก์ชันนั้น เราสามารถส่งตัวแปรจากคลาสใดๆ ที่สืบทอดมาจากคลาส Animal ได้

C# Arrays:
Running on the ground
Swimming in the water
Frying in the air

C# Generic:
Running on the ground
Swimming in the water
Frying in the air

และนี่เป็นผลลัพธ์ของตัวอย่างที่สอง
ใน บทนี้ คุณได้เรียนรู้และการใช้งานเกี่ยวกับ Polymorphism ในภาษา C# ซึ่งมันมีประโยชน์หลายอย่างและทำให้ง่ายขึ้น นอกจากนี้ ยังมี Polymorphism แบบอื่นอีก เช่น Method Overloading หรือ Operators Overloading เป็นต้น

Inheritance

ในบทนี้ คุณจะได้เรียนรู้เกี่ยวกับ Inheritance (การสืบทอด) ในภาษา C# ซึ่งเป็นคุณสมบัติที่สำคัญในการเขียนโปรแกรมเชิงวัตถุ

Inheritance คืออะไร

Inheritance (การสืบทอด) เป็นคุณสมบัติหนึ่งในการเขียนโปรแกรมที่ใช้กับการสร้างคลาส โดยการถ่ายทอดสมาชิกจากคลาสหนึ่งไปยังอีกคลาสหนึ่ง โดยสมาชิกที่ว่านี้ก็คือสมาชิกของคลาสนั้นเอง ซึ่งมีตัวแปรและเมธอด ในภาษา C# เราเรียกคลาสหลักว่าคลาสหลัก (Base class) หรือคลาสที่ถูกสืบทอด (Delivered class)
ในการสืบทอดในภาษา C# นั้นจะใช้เครื่องหมายโคลอน (colon) : โดยมีรูปแบบการสร้างคลาสเพื่อสืบทอดดังนี้

class ClassA: ClassB {
    // statemets
}

จาก รูปแบบด้านบนนั้นเป็นวิธีของการเขียนโปรแกรม โดยมีความหมายว่า ClassA สืบทอดคุณสมบัติทั้งหมดไปยัง ClassB ในตอนนี้ ClassB มีคุณสมบัติเท่ากับ ClassA และนอกจากนี้มันยังสามารถเพิ่มสมาชิกไม่ว่าจะเป็นตัวแปรหรือเมธอดได้ ดังนั้นคลาสลูกจะมีคุณสมบัติหรือประสิทธิภาพเท่ากับหรือมากกว่าคลาสแม่เสมอ แต่มีบางอย่างที่คลาสไม่สามารถสืบทอดได้นั้นคือ Constructor และ Destructor
ต่อไปมาดูตัวอย่างของการ Inheritance ในภาษา C#

สร้าง Inheritance คลาส

ในการแสดงตัวอย่างนี้ เราจะใช้ตัวอย่างคลาสของบทก่อนหน้า นั่นคือคลาส Square และเราได้เขียนโค้ดเพิ่มเติมสำหรับการสืบทอดดังนี้

using System;

class InheritanceExample
{
    static void Main(string[] args)
    {
        Cube a = new Cube(3, 4, 5);
        Cube b = new Cube(10, 10, 5);

        a.name = "Jupiter";
        b.name = "Mars";

        Console.WriteLine(a.name + " has area = " + a.CalculateArea());
        Console.WriteLine(a.name + " has volume = " + a.CalculateVolume());

        Console.WriteLine(b.name + " has area = " + b.CalculateArea());
        Console.WriteLine(b.name + " has volume = " + b.CalculateVolume());

        Console.ReadKey();
    }
}

class Square
{
    public string name;
    protected int width;
    protected int height;

    public void SetDimension(int w, int h)
    {
        width = w;
        height = h;
    }
    public int CalculateArea()
    {
        return width * height;
    }
}

class Cube : Square {

    protected int dept;
    
    public Cube (int w, int h, int d) {
        width = w;
        height = h;
        dept = d;
    }

    public int CalculateVolume()
    {
        return width * height * dept;
    }

}

จาก ตัวอย่างด้านบน เราได้สร้างคลาส Cube ซึ่งสืบทอดมาจากคลาส Square ในบทก่อนหน้า เราเพิ่มคุณสมบัติให้กับคลาส Cube เพื่อให้มันมีความสามารถเพิ่มมากขึ้น คือเก็บข้อมูลในสามมิติได้ และนอกจากนี้คลาส Cube ยังสามารถใช้คุณสมบัติอื่นๆ ที่คลาส Square มี เช่น การคำนวณหาขนาด
ในส่วนของฟังก์ชัน Main เราได้ทำการสร้างออบเจ็คจากคลาส Cube ขึ้นมาสองออบเจ็ค และจะสังเกตุว่าเรายังสามารถที่จะใช้ตัวแปร name และเมธอดได้

Note: คุณสมบัติที่เป็นแบบ private จะไม่สามารถถ่ายทอดได้ เราจำเป็นต้องเปลี่ยนตัวแปร width และ height เป็น protected ก่อน

จากโปรแกรมด้านบน จะได้ผลลัพธ์ดังข้างล่าง

Jupiter has area = 12
Jupiter has volume = 60
Mars has area = 100
Mars has volume = 500

Overriding Super Class

ใน การสืบทอดนั้น ยังมีความสามารถที่เราสามารถทำการ Override หรือเขียนทับได้ จากตัวอย่างด้านล่าง เราได้ทำการกำหนดการทำงานให้กับเมธอด CalculateArea ใหม่ เมื่อมีการเรียกใช้งาน การทำงานของคลาสแม่ก็จะถูกซ่อน และใช้จากคลาสใหม่แทน เรายังสามารถเรียกใช้ CalculateArea จากคลาส Square ได้เช่นเดิมโดยการเรียกผ่านคำสั่ง base ดังตัวอย่างข้างล่าง

class Cube : Square {

    protected int dept;
    
    public Cube (int w, int h, int d) {
        width = w;
        height = h;
        dept = d;
    }

    public int CalculateVolume()
    {
        return width * height * dept;
    }

    public int CalculateArea() // overriding 
    {
        return 0;
    }
    public int SuperCalculateArea()
    {
        return base.CalculateArea(); // call super class's method
    }

}

ใน บทนี้คุณได้เรียนรู้เกี่ยกวับคุณสมบัติ Inheritance (การสืบทอด) ในการเขียนโปรแกรมเชิงวัตถุที่มีในภาษา C# และการ Override และการใช้คำสั่ง base ในการเข้าถึง super class ของมัน

ออบเจ็ค

ในก่อนหน้านี้ คุณได้เรียนรู้วิธีการสร้างคลาสในภาษา C# ซึ่งเป็นพื้นฐานที่สำคัญในภาษา C# ในบทนี้คุณจะได้เรียนรู้เกี่ยวกับการนำคลาสมาสร้างออบเจ็ค คลาสจะสามารถทำงานได้ต้องนำมาสร้างออบเจ็ค

ออบเจ็ค คืออะไร

ออ บเจ็ค คือรูปแบบการเขียนโปรแกรมที่ได้เพิ่มเข้ามาในภาษาระดับสูง เช่น ภาษา C# ที่จะทำให้โปรแกรมมีความสามารถ และความยืดหยุ่นเพิ่มมากขึ้น โดยออบเจ็คนั้นจะสร้างขึ้นมาจากคลาสที่คุณได้เรียนรู้ไปแล้วในบทก่อนหน้า และออบเจ็คยังมีคุณสมบัติอื่นๆ อีกมากมาย เช่น การสืบทอด Polymorphism Interfaces ซึ่งคุณจะได้เรียนภายหลัง นอกจากนี้มันยังเป็นสิ่งที่ช่วยให้สามารถนำโค้ดเดิมมาใช้ได้
ออบเจ็ค นั้นถือว่าเป็นประเภทข้อมูลของมันเอง ขึ้นอยู่กับคลาสที่ใช้สร้างออบเจ็ค ดังนั้นในการสร้างออบเจ็คเราจะเรียกออบเจ็คที่ได้นั้นว่า ตัวแปรออบเจ็ค ซึ่งมันก็เหมือนตัวแปรทั่วไป ที่ต้องมีการประกาศและมีการเรียกใช้ แต่ตัวแปรออบเจ็คนั้นจะไม่สามารถนำมากระทำการทางคณิตศาสตร์โดยตรงได้
ต่อไปมาดูตัวอย่างการสร้างออบเจ็คจากคลาสในภาษา C#

ClassName indentifier = new ClassName();
ClassName2 indentifier2 = new ClassName2(param1, param, ...);

ClassName3 indentifier3;
indentifier3 = new ClassName3();

การสร้างออบเจ็คในภาษา C#

ในการที่จะสร้างออบเจ็ค เราจะขอยกตัวอย่างคลาสง่ายซึ่งจะเป็นคลาสของรูปสี่เหลี่ยมในสองมิติ โดยมีโค้ดดังนี้

class Square {
    public string name;
    private int width;
    private int height;

    public void SetDimension (int w, int h) {
        width = w;
        height = h;
    }
    public int CalculateArea () {
        return width * height;
    }
}

จาก ตัวอย่างของคลาด้านบนนั้น เป็นคลาสที่มีชื่อว่า Square โดยคลาสนี้จะมีสมาชิกที่เป็นตัวแปร 3 ตัว และเป็นเมธอด 3 อัน ต่อไปเราจะนำคลาสดังกล่าวมาสร้างออบเจ็ค เพื่อให้มันสามารถทำงานได้ มาดูตัวอย่างการใช้งาน

using System;

class ObjectExample
{
    static void Main(string[] args)
    {
        Square a = new Square();
        a.name = "Paper";
        a.SetDimension(8, 11);

        Square b = new Square();
        b.name = "Computer Screen";
        b.SetDimension(16, 9);

        Console.WriteLine("Object " + a.name + " has area = " + a.CalculateArea() + " in^2");
        Console.WriteLine("Object " + b.name + " has area = " + b.CalculateArea() + " in^2");
        Console.ReadKey();
    }
}

class Square {
    public string name;
    private int width;
    private int height;

    public void SetDimension (int w, int h) {
        width = w;
        height = h;
    }
    public int CalculateArea () {
        return width * height;
    }
}

จาก ตัวอย่างด้านบนเป็นการนำคลาส Square มาสร้างออบเจ็ค โดยออบเจ็คแต่ละอันนั้นจะเป็นอิสระต่อกัน แต่มีรูปแบบและคุณสมบัติเดียวกัน จากตัวอย่างเราได้สร้างออบเจ็คขึ้นมาสองอัน โดยการกำหนดค่าความกว้างและความยาวของมันผ่านเมธอด SetDimension เพราะว่าเราจะได้กำหนดการเข้าถึงของตัวแปรเป็นแบบ privateจึงไม่สามารถกำหนดโดยตรงเหมือนกับตัวแปร name ที่เป็นแบบ public ได้ และเราใช้เมธอด CalculateArea เพื่อคำนวณหาพื้นที่ของรูปสี่เหลี่ยมดังกล่าว
จากตัวอย่างด้านบนจะได้ผลการทำงานของโปรแกรมดังนี้

Object Paper has area = 88 in^2
Object Computer Screen has area = 144 in^2

การใช้คำสั่ง static

คำ สั่ง static เป็นคำสั่งที่ใช้กำหนดให้เมื่อมีการประกาศตัวแปรหรือฟังก็ชัน โดยจะสามารถเรียกใช้จากที่ใดก็ได้ ถ้าหากคลาสนั้นเป็น public คลาส สำหรับตัวแปรที่อยู่ในคลาสที่มีการสร้างออบเจ็คนั้น ทุกออบเจ็คจะใช้ค่านี้ร่วมกันหมด มาดูตัวอย่าง

public static string name;

จาก ตัวอย่างถ้าเราสร้างตีวแปร Name เป็นแบบ static เมื่อทำการกำหนดค่าให้กับตัวแปร Name จากออบเจ็คใดก็ตาม ค่าของทุกออบเจ็คจะเปลี่ยนเป็นค่าล่าสุดทันที

การใช้คำสั่ง this

คำสั่งที่สำคัญในการทำงานเกี่ยวกับออบเจ็ค ก็คือคำสั่ง this คำสั่งนี้ใช้สำหรับการอ้างถึงค่าของคลาสปัจจุบันที่กำลังเรียกใช้อยู่ใน มาดูตัวอย่าง

class Square {
    public string name;
    private int width;
    private int height;

    public void SetDimension (int width, int height) {
        this.width = width ;
        this.height = height;
    }
    public int CalculateArea () {
        return width * height;
    }
}

จากตัวอย่างให้สังเกตุชื่อตัวแปรในฟังก์ชัน SetDimension ซึ่งใช้ชื่อที่เหมือนกันกับสมาชิกของคลาส ดังนั้นการใช้คำสั่ง this เป็นการหมายถึงตัวแปรในคลาสปัจจุบันที่ถูกคำสั่งเรียกใช้อยู่ ประโยชน์ของมันคือใช้เมื่อคุณต้องการใช้ชื่อของตัวแปรที่เหมือนกัน เพื่อให้ง่ายต่อการจำ หรือในอีกกรณีหนึ่งจะใช้กับการทำงานของคลาสที่มีการสืบทอด
ในบทนี้ คุณได้เรียนรู้วิธีการนำคลาสมาสร้างออบเจ็คเบื้องต้น และรู้จักกับคำสั่งที่สำคัญเกี่ยวกับออบเจ็คในภาษา C#

คลาส

ในบทนี้ คุณจะได้เรียนรู้วิธีการสร้างคลาสและออบเจ็คในภาษา C# ซึ่งเป็นพื้นฐานที่สำคัญในภาษา C# เพราะว่ามันถูกออกแบบมาให้เป็นภาษาสำหรับการเขียนโปรแกรมเชิงวัตถุอย่างเต็ม รูปแบบ (object oriented programming) ดังนั้น คุณจะเข้าใจอย่างละเอียดในบทนี้

C# Classes

คลาส คือแม่แบบ (template) ของโปรแกรมเพื่อนำมาสร้างออบเจ็คในโปรแกรม ในการสร้างคลาสนั้นจะเป็นเหมือนแม่แบบของสิ่ง ๆ หนึ่งที่มีอยู่จริง เช่น คลาสของคน ใช้อธิบายส่วนประกอบ ลักษณะ และการกระทำ เราใช้คลาสเพื่อที่จะนำไปสร้างออบเจ็คได้อย่างไม่จำกัด
คุณได้เห็นคลา สมาในบทก่อนหน้าแล้วในบทเรียนนี้ เราจะแสดงให้คุณเห็นและเข้าใจอย่างละเอียดในบทนี้ และการสร้างคลาสในภาษา C# นั้นจะมีรูปแบบดังนี้

class identifier {
    // class members and specifications
}

ในการสร้างคลาสนั้น เราจะใช้คำสั่ง class และ identifier นั้นเป็นชื่อของคลาสที่จะสร้างขึ้น หลักการในการตั้งชื่อคลาสนั้นเหมือนกับหลักในการตั้งชื่อตัวแปร แต่ในการประบัติที่ดี คุณควรจะเริ่มต้นชื่อของคลาสด้วยตัวพิมพ์ใหญ่เสมอ และเริ่มต้นคำใหม่ด้วยตัวพิมพ์ใหญ่ เช่น Person Car Country เป็นต้น
ใน ส่วนบลอคคำสังของคลาส จะเป็นส่วนในการประกาศสมาชิกของคลาส โดยคลาสจะมีสมาชิกได้สองแบบคือ ตัวแปร และเมธอด ตัวแปรสามารถเป็นได้ทั้งและตัวแปรแบบ static นอกจากนี้ สมาชิกในคลาสยังสามารถกำหนดระดับความเข้าถึงได้
ต่อไปมาดูตัวอย่างการสร้างคลาสในภาษา C#

class Car {

    public static int enegyUserPerRun = 3;
    String color;

    private float enegy = 10;
    public int speed = 0;
    private int distant = 0;

    public void AddEnegy () {
        enegy += 10;
    }

    public void Run () {
        if (enegy < speed * enegyUserPerRun) {
            Console.WriteLine("No enough enegy to run.");
        } else {
            distant += (speed * enegyUserPerRun);
            enegy -= enegyUserPerRun;
        }
    }

    public void ShowDistance () {
        Console.WriteLine("Distance runned " + distant);
    }
}

ในตัวอย่างเราได้สร้างคลาสที่มีชื่อว่า Car ซึ่งเป็นคลาสเกี่ยวกับรถ โดยคลาสนั้นจะมีสมาชิกที่เป็นตัวแปร 5 ตัว และเป็นเมธอด 3 เมธอด
ตัวแปร enegyUserPerRun นั้นเป็นตัวแปรประเภท integer เก็บสำหรับเป็นข้อมูลถึงการใช้พลังงานในการวิ่งและละครั้งของรถ ตัวแปรนี้เป็น static นั่นหมายความว่ารถทุกคันที่สร้างจากคลาสนี้จะใช่ตัวแปรนี้ร่วมกัน และถ้ามีการเปลี่ยนแปลงค่าของตัวแปรนี้ก็จะเปลี่ยนสำหรับทุกออบเจ็คที่สร้าง จากคลาสนี้ ตัวแปร color ใช้ในการเก็บสีของรถ ว่ารถคันนี้มีสีอะไร และตัวแปร enegy เป็นตัวแปรในการเก็บพลังงานคงเหลือปัจจุบันของรถ ตัวแปร speed เป็นความเร็วของรถ และตัวแปร distant บอกว่ารถคันนี้วิ่งไปได้ระยะทางเท่าไหร่แล้ว

Class constructor

คอน สตรัคเตอร์ (Constructor) เป็นเมธอดพิเศษในคลาสที่ใช้สำหรับในการกำหนดค่าเริ่มต้นเมื่อได้ทำการสร้าง ออบเจ็ค คอนสตคัคเตอร์นั้นจะมีชื่อที่เหมือนกับคลาส มีการเข้าถึงเป็นแบบ public และไม่มีส่วนของการ return ค่ากลับ ต่อไปมาดูตัวอย่างการสร้างคอนสตัคเตอร์กับคลาสในภาษา C#

class Car {

    public static int enegyUserPerRun = 3;
    String color;

    private float enegy = 10;
    public int speed = 0;
    private int distant = 0;

    public Car(String c, float e, int s, int d)
    {
        color = c;
        enegy = e;
        speed = s;
        distant = d;
    }

    public void AddEnegy () {
        enegy += 10;
    }

    public void Run () {
        if (enegy < speed * enegyUserPerRun) {
            Console.WriteLine("No enough enegy to run.");
        } else {
            distant += (speed * enegyUserPerRun);
            enegy -= enegyUserPerRun;
        }
    }

    public void ShowDistance () {
        Console.WriteLine("Distance runned " + distant);
    }
}

จากตัวอย่างนั้นเป็นคลาสเดียวกันกับที่เราสร้างก่อนหน้า โดยคุณจะสังเกตุุเห็นว่า public Car(...) นั้นก็คือคอนสตรัคเตอร์ของคลาสนี้ เพื่อที่จะกำหนดค่าเริ่มต้นให้กับออบเจ็คเมื่อมันถูกสร้าง นอกจากนี้คุณยังสามารถมีได้หลายคอนสตรัคเตอร์ได้ ถ้าหากว่ามันมีพารามิเตอร์ และประเภทของข้อมุลที่แตกต่างกัน เช่น

public Car(String c, int s)
{
    color = c;
    speed = s;
}

จาก ตัวอย่างข้างบนเป็นคอนสตรัคเตอร์อันที่สองของคลาสนี้ โดยมีรับพารามิเตอร์เข้ามาเพียงแค่สองตัว เนื่องจากว่าตัวแปร enegy ของเรานั้นมีค่าเริ่มต้นแล้ว และตัวแปร distant ก็ต้องเริ่มต้นจากศูนย์อยู่แล้ว ดังนั้นในตอนสร้างออบเจ็คคุณจะสามารถเลือกใช้คอนสตรัคเตอร์อันไหนก็ได้
ใน บทนี้ คุณได้เรียนรู้เกี่ยวกับคลาสและการสร้างคลาสในภาษา C# และนอกจากนี้ยังได้รู้จักคอนสตรัคเตอร์ที่จะช่วยให้กำหนดค่าเริ่มต้นของออบ เจ็คได้ ในบทต่อไปคุณจได้เรียนรู้เกี่ยวกับออบเจ็ค ที่จะสร้างโดยการนำคลาสเหล่านี้ไปสร้าง

Namespaces

namespace คืออะไร

ในภาษา C# เนมสเปซ (namespace) นั้นเป็นเซตของเมธอดและคลาส ที่ใช้ในการจัดการสิ่งเหล่านี้ให้เป็นกลุ่ม หรือเป็นการรวบรวมของออบเจ็ค มันเป็นแนวคิดแบบนามธรรมที่ใช้ในการกำหนดขอบเขตของออบเจ็คภายในโปรแกรม
Namespaces นั้นจะมีประโยชน์ในการป้องกันชื่อของคลาสที่ซ้ำกัน หรือว่าการนำคลาสนั้นกลับมาใช้โดยมีชื่อเดียวกันกับโปรเจ็คของเรา ยกตัวอย่างเช่น บริษัท A มีคลาสที่ชื่อว่า User และเมื่อคุณนำโค้ดจากบริษัท B มาใช้ ก็มีคลาสที่ชื่อว่า User เช่นเดียวกัน นี่เรียกว่าการชนกันของชื่อและเราสามารถใช้ namespace ในการแก้ไขปัญหานี้ได้ มันมีต้นกำเนิดแนวคิดมาจากพาธไฟล์ของคอมพิวเตอร์ ดังนั้น namespace จึงสามารถที่จะซ้อนกันเป็นลำดับเหมือนกับโฟล์เดอร์นั่นเอง

การสร้าง namespaces

ในการประกาศ namespace ในภาษา C# คุณต้องทำตามรูปแบบของการสร้างข้างล่างนี้

namespace Indentifier {
    // namespace members
}

และอีกรูปแบบหนึ่งในกรณีที่ namespace นั้นซ้อนกัน

namespace Indentifier {
    namespace SubIndentifier1 {
        // namespace members
    }
    // namespace members
}

โดยคำสั่ง namespace จะใช้เพื่อสร้าง namespace และ Identifier นั้นสำหรับเป็นชื่อให้กับ namespace ที่สร้างขึ้น การตั้งชื่อให้กับ namespace มีกฏเหมือนกันกับการตั้งชื่อตัวแปรและเมธอด และมักจะเริ่มต้นด้วยตัวพิมพ์ใหญ่ในบล็อคคำสั่งของ namespace นั้นเป็นที่ที่จะประกาศสมาชิกของมัน โดยสมาชิกสามารถเป็นคลาสหรือ namespace อื่น
มาดูตัวอย่างของการสร้าง namespace ในภาษา C#

namespace CompanyA {
    class User
    {
        string firstName;
        string lastName;
        public User(string fn, string ln)
        {
            firstName = fn;
            lastName = ln;
        }
        public string GetName() {
            return firstName + " " + lastName;
        }
    }
}

ในตัวอย่างด้านบน เราได้สร้าง namespace CompanyA โดยมีคลาส User เป็นสมาชิก ถ้าคุณยังไม่เข้าใจเกี่ยวกับคล่าในตอนนี้ ไม่ต้องกังวลเพราะคุณจะได้เรียนในบทต่อไป

การใช้และการเข้าถึง namespaces

เมื่อ namespace ได้ถูกสร้างขึ้น คุณสามารถที่จะใช้งานมันได้ 2 วิธีในภาษา C# แบบแรกเป็นการใช้โดยตรงโดยการเติม prefix ซึ่งเป็นชื่อของ namespace ข้างหน้าออบเจ็ค แบบที่สอง คือใช้คำสั่ง using เพื่อนำเข้า namespace มายังพื้นที่การเขียนโปรแกรมปัจจุบัน

การใช้ namespace โดยตรง

นี่เป็นวิธีที่ง่ายและตรงไปตรงมาในการใช้ Namespace ที่สร้างขึ้น โปรแกรมข้างล่างนี้เป็นตัวอย่างของการเรียกใช้ namespace

using System;

namespace Namespaces
{
    class Program
    {
        static void Main(string[] args)
        {
            CompanyA.User a = new CompanyA.User("Mateo", "Marcus");
            Console.WriteLine(a.GetName());

            Console.ReadLine();
        }
    }
}

namespace CompanyA {
    class User
    {
        string firstName;
        string lastName;
        public User(string fn, string ln)
        {
            firstName = fn;
            lastName = ln;
        }
        public string GetName() {
            return firstName + " " + lastName;
        }
    }
}

เราได้ใช้ namespace CompanyA ที่เราได้สร้างขึ้นในตัวอย่างก่อนหน้า โดยการเข้าถึงคลาส User ภายใน namespace นี้เราจะใช้ CompanyA.User ที่เข้าถึงคลาสที่เราต้องการโดยตรง

การใช้คำสั่ง using

ใน บางครั้งมันอาจจะไม่สะดวกที่จะใช้วิธี prefix ถ้าเรามีออบเจ็คเป็นจำนวนมากที่ต้องการเข้าถึงใน namespace หรือมันเป็น namespace ที่ซ้อนกันหลายชั้น คำสั่ง using สามารถออำนวยความสะดวกให้กับเราสำหรับเรื่องนี้

using System;
using CompanyA;

namespace Namespaces
{
    class Program
    {
        static void Main(string[] args)
        {
            User a = new User("Mateo", "Marcus");
            Console.WriteLine(a.GetName());

            Console.ReadLine();
        }
    }
}

namespace CompanyA {
    class User
    {
        string firstName;
        string lastName;
        public User(string fn, string ln)
        {
            firstName = fn;
            lastName = ln;
        }
        public string GetName() {
            return firstName + " " + lastName;
        }
    }
}

ในตัวอย่างด้านบน เราได้ใช้คำสั่ง using CompanyA เพื่อนำเข้า namespace เข้ามายังพื้นที่การเขียนโปรแกรมปัจจุบันของเรา ดังนั้น เราสามารถใช้ User โดยไม่จำเป็นต้องมี prefix ด้วย CompanyA อีกต่อไป

Namespace Aliases

มัน เป็นไปได้ที่บางออบเจ็คใน namespace อาจจะมีชื่อที่เหมือนกัน ในการที่จะป้องกันปัญหาเมื่อตอนนำมาใช้งานกับโปรแกรม วิธีแรกที่เราสามารถทำได้คือการใช้ prefix อย่างที่ได้กล่าวไปก่อนนี้แล้ว แต่ในตอนนี้ เราจะใช้ namespace aliases ซึ่งก็คือการตั้งชื่อเสมือนให้กับ namespace โดยการเปลี่ยนชื่อของ namespace ที่ต้องการให้เป็นอย่างอื่นเพื่อใช้ในโปรแกรม มาดูตัวอย่างของการใช้งาน namespace aliases

using System;
using NX = CompanyA.User;
using NY = CompanyB.User;

namespace Namespaces
{
    class Program
    {
        static void Main(string[] args)
        {
            NX a = new NX("Mateo", "Marcus");
            NY b = new NY("Mateo", "Marcus");

            Console.WriteLine(a.GetName());
            Console.WriteLine(b.GetName());

            Console.ReadLine();
        }
    }
}

namespace CompanyA {
    class User
    {
        string firstName;
        string lastName;
        public User(string fn, string ln)
        {
            firstName = fn;
            lastName = ln;
        }
        public string GetName() {
            return firstName + " " + lastName;
        }
    }
}

namespace CompanyB {
    class User
    {
        string firstName;
        string lastName;
        public User(string fn, string ln) {
            firstName = fn;
            lastName = ln;
        }
        public string GetName()
        {
            return lastName + " " + firstName;
        }
    }
}

ใน ตัวอย่างเรามี namespace CompanyA และ CompanyB ซึ่ง namespace ทั้งสองนั้นต่างก็มีคล่าที่ชื่อ User เป็นสมาชิกเหมือนกัน ดังนั้น คำสั่ง using NX = CompanyA.User นั้นเพื่อทำการเปลี่ยน CompanyA.User ให้เป็น NX และคำสั่ง using NY = CompanyB.User เปลี่ยนให้เป็น NY ตามลำดับ ตอนนี้คุณลองพิจารณาโค้ดข้างล่างนี้

NX a = new NX("Mateo", "Marcus");
NY b = new NY("Mateo", "Marcus");

// are equivalent to
CompanyA.User a = new CompanyA.User("Mateo", "Marcus");
CompanyB.User b = new CompanyB.User("Mateo", "Marcus");

ทั้ง สองวิธีการนั้นจะให้ผลลัพธ์ที่เท่ากัน ผลลัพธ์ของการใช้ namespace alias สามารถทำให้เราเขียนโค้ดที่สั้นลงและเรียกใช้ namespace ได้รวดเร็วขึ้นโดยการตั้งชื่อใหม่ให้กับมัน
และนี่เป็นผลลัพธ์เมื่อเราได้ทำการรันโปรแกรม

Mateo Marcus
Marcus Mateo

จากผลัพธ์ ถึงแม้ว่าจะเป็นคล่าเดียวกันและเรียกใช้เมธอดเหมือนกัน แต่ว่า GetName ในแต่ละคลาสนั้นทำงานแตกต่างกัน

Nested namespaces

Namespace สามารถที่จะซ้อนกันกี่ระดับก็ได้ตามที่คุณต้องการ จากตัวอย่างโค้ดข้างล่างนี้

namespace A {
    namespace B {
        namespace C {
            // ...
        }
    }
    namespace B1 {
        // ...
    }
}

ใน บทนี้ คุณได้เรียนเกี่ยวกับ namespace และรู้วิธีการสร้างและใช้มันเมื่อต้องการ และในบทนี้ คุณได้เห็นเกี่ยวกับคลาสและออบเจ็ค ซึ่งเป็นเรื่องสำคัญที่คุณจะได้เรียนในบทต่อไป

เมธอด

ในบทนี้ เราจะพูดเกี่ยวกับเมธอดในภาษา C# คุณจะได้เรียนวิธีการสร้างเมธอดและการเรียกใช้มัน

เมธอด คืออะไร

ใน ภาษา C# เมธอดนั้นเป็นส่วนหนึ่งของโปรแกรมเพื่อให้ดำเนินการบางอย่าง กล่าวอีกนัยหนึ่ง มันคือส่วนย่อยของโปรแกรมที่ถูกเรียกโดยโปรแกรมหลักและมันสามารถนำกลับมาใช้ ซ้ำได้ การสร้างเมธอดช่วยให้ลดจำนวนของซอสโค้ดที่เขียนขึ้นได้ การนำกลับมาใช้ใหม่ และทำให้ง่ายในการแก้ไขโปรแกรมในภายหลัง
เมธอด ในอีกคำหนึ่งที่รู้จักกันก็คือ ฟังก์ชัน ดังนั้นอย่างสับสนระหว่างสองคำนี้ แต่คำว่าเมธอดใช้สำหรับฟังก์ชันที่อยู่ในคลาส (การเขียนโปรแกรมเชิงวัตถุ) อย่างไรก็ตามในบทเรียนนี้เราอาจจะใช้ทั้งสอง

เมธอดในภาษา C#

ในภาษา C# จะมีเมธอดอยู่สองประเภท แบบแรกคือ predefined method มันคือเมธอดที่สร้างมากับไลบรารี่มาตรฐานของภาษา C# ซึ่งมันจะอยู่ในคลาส ยกตัวอย่างเช่น System.WriteLine() นี่บ่งบอกว่าเมธอด WriteLine นั้นอยู่ในคลาส System และเมธอดประเภทที่สองคือ user-defined method เป็นเมธอดที่เขียนขึ้นเองโดยโปรแกรมเมอร์ ในบทเรียนนี้ เราจะพูดเน้นในแบบที่สอง

User-defined method

User-defined method (เมธอดที่สร้างโดยผู้ใช้ ) นั้นเป็นเมธอดที่ถูกสร้างขึ้นเพื่อทำงานบางอย่างโดยผู้ใช้ เพราะว่าภาษา C# นั้นเป็นภาษาในการเขียนโปรแกรมเชิงอ็อบเจ็ค เมธอดนั้นจะต้องอยู่ในคลาส คุณจะได้เรียนรู้เกี่ยวกับคลาสภายหลังในบทเรียนนี้
ในการสร้างเมธอด มันมีรูปแบบดังนี้:

access_modifier type identifier (parameter1, parameter2, ... ) {
    // statements
    return result;
}

รูปแบบนี้ถูกใช้เมื่อคุณต้องการสร้างเมธอดที่มีการส่งค่ากลับ (return) ไปยังส่วนของโปรแกรมที่เรียกใช้มัน มาดูอีกรูปแบบหนึ่ง

access_modifier void identifier (parameter1, parameter2, ... ) {
    // statements
}

รูปแบบนี้จะถูกใช้เมื่อไม่มีค่าที่จะส่งหลับไป คุณสังเกตุในคำสั่งvoidนั้นจะถูกใช้แทน return type
ต่อไป เราจะอธิบายส่วนต่างๆ ของการประกาศเมธอด

• access_modifier:บ่งบอกถึงระดับการเข้าถึงได้ของเมธอดมรคลาส โดยจะมีอยู่ 4 แบบคือ public protected private และ internal ถ้าหากคุณปล่อยให้มันว่างปล่าวนั้นจะเป็นแบบ protected
• type : เป็นประเภทของข้อมูลที่คุณอยากจะส่งค่ากลับ มันสามารถเป้นชนิดข้อมูลพื้นฐานในภาษา C# หรือเป็นอ็อบเจ็ค เช่น int float String Class_Name เป็นต้น เมื่อเมธอดไม่มีค่าอะไรที่จะส่งกลับเราจะใช้คำสั่ง void แทนเหมือนที่คุณเห็นในรูปแบบที่สอง
• parameters: เป็นค่าของตัวแปรที่ส่งเข้ามาในเมธอด และเป็นทางเลือก
• return เป็นคำสั่งที่ใช้ส่งค่าข้อมูลกลับ ยกตัวอย่างเช่น เมธอดที่มี return เป็น int นั้นค่าที่ส่งกลับจะต้องเป็นตัวเลขจำนวนเต็ม
• static: คำสั่ง static ถูกใช้ประกาศหลังจาก access modifier ถ้าเมธอดที่ถูกสร้างขึ้นนั้นจำเป็นที่จะต้องแชร์บางอย่างที่เหมือนกันสำหรับ ทุกๆ อ็อบเจ็คที่สร้างจากคลาส

สร้างเมธอด

ในการที่จะสร้างเมธอด คุณจะเป็นต้องทำตามรูปแบบข้างบน มาดูตัวอย่างวิธีการสร้างเมธอดในภาษา C#

using System;

class CreatingMethod
{
    static void Main(string[] args)
    {
        String name = "Marcus";
        int sex = 0;
        String sport= "hockey";

        displayBio(name, sex, sport);

        displayBio("Janifer", 1, "swimming");
        displayBio("Carl", 0, "football");

        Console.ReadKey();
    }

    static void displayBio(String n, int s, String sp) {
        if (s == 0) {
            Console.WriteLine(n + " has " + sp + " as his favorite sport.");
        } else {
            Console.WriteLine(n + " has " + sp + " as her favorite sport.");
        }
    }
}

ในตัวอย่าง เราได้สร้างเมธอดเพื่อแสดงกีฬาโปรดของบุคคล สังเกตุว่าเมธอด main นั้นสร้างจากคำสั่ง static ดังนั้นเมธอดที่เรียกใช้จากเมธอด Main ก็จะต้องสร้างจากคำสั่ง static ด้วยเช่นกัน
เราได้ตั้งชื่อให้กับเมธอดของเราว่า displayBio และมันมี 3 พารามิเตอร์ที่ส่งเข้าในเมธอดนี้ เราเรียกใช้เมธอดนี้ในเมธอด Main และเราจะส่งอากิวเมนต์ให้สอดคล้องกันกับลำดับพารามิเตอร์ของมัน คำสัง void นั้นหมายความว่าเมธอดนี้จะไม่มีการส่งค่ากลับไป เนื่องจากว่าเราต้องการแค้นำค่ามาแสดงผลในเมธอดเท่านั้น

Marcus has hockey as his favorite hobbie.
Janifer has swimming as her favorite hobbie.
Carl has football as his favorite hobbie.

และนี่เป็นผลลัพธ์ของโปรแกรมที่แสดงชื่อ เพศ และกีฬาโปรดในเมธอด
ต่อไปมาดูตัวอย่างการสร้างเมธอดที่มีการส่งค่ากลับ

การสร้างเมธอดที่มีการส่งค่ากลับ

โดย ทั่วไปแล้ว เมธอดนั้นจะต้องมีค่าที่จะส่งกลับไปนำไปใช้ในส่วนที่ถูกเรียกของโปรแกรม คิดว่าเมธอดเป็นเหมือนที่สำหรับการทำงานบางอย่างและส่งแค่ผลลัพธ์กลับไป เมื่อมันทำงานเสร็จสิ้น

using System;

class CreatingMethod2
{
    static void Main(string[] args)
    {
        int a = 10;
        int b = 25;
        Console.WriteLine(getText(a) + getSum(a));
        Console.WriteLine(getText(b) + getSum(b));
        Console.WriteLine(getEndText());
        Console.ReadKey();
    }

    static String getText(int n) {
        return "Sum bewteen 1-" + n + " is ";
    }

    static int getSum(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }

    static String getEndText() {
        return "Program ended.";
    }
}

จากตัวอย่าง นี่เป็นโปรแกรมในการหาผลลรวมของตัวเลขระหว่าง 1 - n เมื่อ n คืออากวิเมนต์ที่ส่งเข้ามายังเมธอด และส่งค่ากลับไปหลังจากที่คำนวณเสร็จแล้ว

int x = getSum(10); // 55
boolean y = (getSum(10) == 55);

จากโค้ดคำสั่งด้านบน มันจะมีค่าเท่ากับ 55 และมีประเภทข้อมูลเป็น Integer ซึ่งตรงกับในตอนที่สร้างเมธอด ดังนั้น expression (getSum(10) == 55) จะมีค่าเป็นจริง

Sum bewteen 1-10 is 55
Sum bewteen 1-25 is 325
Program ended.

และนี่เป็นผลลัพธ์ของโปรแกรมเมื่อเราได้ส่งตัวเลขต่างๆ เข้าไปยังเมธอด และผลลัพธ์ของมัน
ในบทนี้ คุณได้เรียนสิ่งที่จำเป็นที่จะต้องรู้เกี่ยวกับเมธอด และได้เรียนรู้ทั้งเมธอดที่มีการส่งค่ากลับและไม่มีการส่งค่ากลับ

อาเรย์

อาเรย์ใน C#

อาเรย์เป็นประเภทข้อมูลชนิดหนึ่ง ที่คุณสามารถเก็บค่าตัวแปรประเภทเดียวกันได้หลายๆ ค่าไว้ในตัวแปรเดียวที่เรียกว่า ตัวแปรอาเรย์ ในการสร้างอาเรย์ในภาษา C# มีรูปแบบดังนี้:

type[] arrayName;

โดย type สามารถเป็นได้ทั้งตัวแปรพื้นฐานในภาษา C# และตัวแปรประเภทอ็อบเจ็ค และ arrayName เป็นชื่อของอาเรย์ index ของอาเรย์นั้นจะเริ่มจาก 0 ดังนั้น index ของอาเรย์จะมีตั้งแต่ 0 ถึง n - 1 เมือ n เป็นจำนวนขนาดของค่าในอาเรย์ มีอาเรย์ 3 ประเภทในภาษา C# นั่นคือ อาเรย์หนึ่งมิติ (Single-Dimensional array) อาเรย์หลายมิติ (Multidimensional array) และ อาเรย์ของอาเรย์ (Array of Array)

อาเรย์ 1 มิติ

อาเรย์หนึ่งมิติ เป็นรูปแบบพื้นฐานของอาเรย์ที่จะเก็บค่าของข้อมูลที่มีประเภทเดียวกันเป็น ซึ่งแบบลำดับไว้ในตัวแปรอาเรย์ และเราสามารถเข้าถึงข้อมูลเหล่านี้ได้ผ่าน index ของมัน

int[] array1 = new int[5];
int[] array2 = new int[] { 1, 3, 5, 7, 9};

ในตัวอย่างเราได้ประกาศตัวแปรอาเรย์สองตัว เราประกาศตัวแปรที่มีชื่อว่าarray1 โดยมีประเภทข้อมูลเป็น int นั่นหมายความว่าตัวแปรนี้จะใช้กับข้อมูลเป็นตัวเลขจำนวนเต็ม ซึ่งมีขนาดเป็น 5 แต่เรายังไม่ได้กำหนดค่าใดๆ ให้กับอาเรย์ ดังนั้นมันจะเป็นค่าว่างเปล่าหรือ null สำหรับอาเรย์อันที่สองมีชื่อว่า array2 เราได้กำหนดค่าให้กับมันด้วย

// updating array values
int[] array1 = new int[5];
array1[0] = 2;
array1[1] = 43;
array1[2] = 54;

// reading array value
float[] array2 = new float[] {1,2f, 3.4f, 5.0f, 8.8f, 10.5f};
Console.WriteLine(array2[0]); // 1.2
Console.WriteLine(array2[4]); // 10.5

คุณ สามารถเข้าถึงตำแหน่งของอาเรย์เพื่ออ่านหรืออัพเดทค่า โดยอาเรย์นั้นจะมี Index เริ่มที่ 0 เสมอ ในตัวอย่างในการเข้าถึงค่าแรกของอาเรย์ array2 เราต้องใช้คำสั่ง array2[0] และค่าสุดท้ายคือ array2[4] เพราะว่าอาเรย์ array2 นั้นมีขนาดเป็น 5

การใช้คำสั่ง For loop กับอาเรย์

เพราะ ว่าอาเรย์นั้นเก็บข้อมูลเป็นแบบลำดับและสามารถเข้าถึงข้อมูลได้โดยผ่าน index ของมัน การใช้ for loop กับอาเรย์นั้นจึงเป็นสิ่งที่สะดวกมากกว่า หรือเมื่อเรามีตัวแปรอาเรย์ที่มีขนาดใหญ่

using System;

class SingleArrayRead
{
    static void Main(string[] args)
    {
        int[] array1 = new int[10];
        for (int i = 0; i < 10; i++)
            array1[i] = (i + 1) * 5;

        for (int i = 0; i < 10; i++)
            Console.Write(array1[i] + ", ");

        Console.ReadKey();
    }
}

ในตัวอย่าง เราได้ใช้คำสั่ง for loop ในการกำหนดค่าให้กับอาเรย์ โดยใช้ index ของอาเรย์ผ่านตัวแปร i หลังจากกำหนดค่าให้เสร็จแล้ว เราก็ได้สร้างอีก loop หนึ่งเพื่ออ่านจากมาแสดงผลที่หน้าจอ

5, 10, 15, 20, 25, 30, 35, 40, 45, 50,

และนี่เป็นผลลัพธ์ของโปรแกรมในอาเรย์หนึ่งมิติ

อาเรย์หลายมิติ

อา เรย์หลายมิตินั้นจะสามารถเก็บข้อมูลได้หลายมิติมากขึ้น อาเรย์สองมิตินั้นเหมือนตาราง ซึ่งจะไปกอบไปด้วยแถวและหลัก อาเรย์ 3 มิตินั้นจะเหมือนลูกบาศก์ และอาเรย์สามารถมีได้ทั้ง 4 มิติ 5 มิติ และไปเรื่อยๆ แต่โดยปกติในการเขียนโปรแกรมแล้ว ส่วนมากที่สุดที่เราจะใช้คือถึงแค่ 3 มิติเท่านั้น

อาเรย์ 2 มิติ

การสร้างอาเรย์สองมิตินั้นคล้ายกับอาเรย์หนึ่งมิติ แต่มันแค่ต้องการเครื่องหมาย , คั่นระหว่างมิติสำหรับการสร้าง โดยมีรูปแบบดังนี้:

int[,] array1 = new int[2, 3];
int[,] array2 = new int[,] { {1, 2, 3}, {4, 5, 6}};

ในตัวอย่างเราได้ประกาศอาเรย์สองมิติ โดยใช้เครื่องหมายคอมม่า , เป็นตัวคั่นระหว่างมิติ โดยมันจะเก็บข้อมูลในแบบแถวและหลัก พูดง่ายๆ ก็คือแบบต่างรางนั่นเอง คุณสามารถเข้าถึงค่าของอาเรย์สองมิติได้โดยคู่ของ index แบบนี้ [row, column] มาดูตัวอย่าง

int[,] array2 = new int[,] { {1, 2, 3}, {4, 5, 6} };
Console.WriteLine(array2[0, 0]);  // read 1
Console.WriteLine(array2[0, 1]);  // read 2
Console.WriteLine(array2[0, 2]);  // read 3
Console.WriteLine(array2[1, 0]);  // read 4
Console.WriteLine(array2[1, 1]);  // read 5
Console.WriteLine(array2[1, 2]);  // read 6
Console.WriteLine(array2[2, 2]); // you can't do this

ในตัวอย่าง เราได้เข้าถึงค่าของอาเรย์ array2 สำหรับคำสั่งสุดท้าย array2[2, 2] นั้นจะเกิดข้อผิดพลาดเพราะว่า Index ของอาเรย์นั้นเกินขอบเขต เช่นเดียวกันกับอาเรย์หนึ่งมิติ index ของมันก็เริ่มจาก 0 เนื่องจากขนาดอาเรย์ของเรานั้นเป็น 2x3 ดังนั้นค่าแรกในอาเรย์จะเป็น index [0, 0] และค่าสุดท้ายคือ [1, 2]

การใช้ For loop กับอาเรย์สองมิติ

อีกครั้ง เราสามารถใช้คำสั่ง for loop กับอาเรย์สองมิติหรืออาเรย์หลายมิติ แต่มันจะเป็น loop ที่ซ้อนกัน มาดูตัวอย่าง

using System;

class TwoArrayRead
{
    static void Main(string[] args)
    {
        int[,] myArray = new int[,] { {10, 43, -23, 5 }, {-5, 9, 15, 3 }, {0, 41, -30, -7} };

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                Console.Write("[{0},{1}] = {2}\t", i, j, myArray[i, j]);
            }
            Console.WriteLine();
        }

        Console.ReadKey();
    }
}

ใน ตัวอย่างเราได้ใช้ for loop เพื่ออ่านค่าจากอาเรย์สองมิติ ในการอ่านค่าจากอาเรย์สองมิติ เราจำเป็นต้องใช้สอง loop และเป็น loop ที่ซ้อนกัน (nested loops) โดย loop ด้านนอกจะใช้เป็น index ของแถว และข้างในจะใช้เป็น Index ของคอลัมน์ เช่น myArray[0, 2] นั้นจะเป็นแถวที่ 1 คอลัมน์ที่ 3
คุณสามารถสร้างอาเรย์ได้หลายมิติกว่านี้ถ้าหากคุณต้องการที่จะทำแบบนั้น โดยมันมีหลักการเหมือนกับอาเรย์สองมิติ มาดูตัวอย่าง

int threeArray[, , ,] = new int [3, 4, 5];
int fourArray[, , , ,] = new int [3, 4, 5, 6];
...

ในตัวอย่างเป็นการสร้างอาเรย์มิติที่มากกว่า 2 ในภาษา C# โดยคั่นด้วยเครื่องหมายคอมม่าสำหรับจำนวนมิติ ในการเข้าถึงค่าก็จะเป็น threeArray[i, j, k, ...]

อาเรย์ของอาเรย์ (Jagged)

คุณ สามารถเก็บข้อมูลแบบอาเรย์ไว้ในอาเรย์ เช่นเดียวกันกับเก็บตัวแปรปกติไว้ในอารเย์ มันคล้ายๆ กับอาเรย์หลายติมิแต่ไม่ทั้งหมด มันเรียกว่าอาเรย์ของอาเรย์หรืออาเรย์ jagged

int[][] jaggedArray = new int[6][];

อาเรย์ของอา เรย์นั้นแตกต่างจากอเรย์หลายมิติในภาษา C# แต่มันเหมือนกับอาเรย์หลายมิติในภาษา C และ C++ ในการอ่านค่าและเข้าถึงค่าก็เช่นเดียวกัน

using System;


class JaggedArray
{
    static void Main(string[] args)
    {
        int[][] jaggedArray = new int[4][];

        for (int i = 0; i < jaggedArray.Length; i ++) {
            jaggedArray[i] = new int[] { (i * 3) + 1, (i * 3) + 2, (i * 3) + 3 };
        }

        for (int i = 0; i < jaggedArray.Length; i++) {
            for (int j = 0; j < jaggedArray[i].Length; j++) {
                Console.WriteLine("array[{0}][{1}] = {2}", i, j, jaggedArray[i][j]);
            }
        }
        Console.ReadKey();
    }
}

ใน ตัวอย่าง เราได้สร้างอาเรย์ของอาเรย์ โดยมีขนาดคือ 4x3 นั่นหมายความว่าอาเรย์จะประกอบไปด้วย 4 แถวและ 3 คอลัมน์ เราได้ใช้คำสั่ง for loop ในการกำหนดค่าให้กับอาเรย์ในแต่ละแถว โดยค่า Length นั้นเป็นการอ่านขนาดของอาเรย์ เรายังอ่านค่าจากอาเรย์และแสดงผลทางหน้าจอโดยใช้ nested loop
เหมือนกับตัวแปร เราสามารถกำหนดค่าให้กับตัวแปรอาเรย์ได้ทันทีเมื่อมันถูกสร้างเหมือนตัวอย่างข้างล่างนี้

using System;

class JaggedArray2
{
    static void Main(string[] args)
    {
        int[][] jaggedArray = new int[][] {  
            new int[] { 1, 2, 3}, 
            new int[] { 4, 5, 6 }, 
            new int[] { 7, 8, 9 }, 
            new int[] { 10, 11, 12 }
        };

        /*
        another method
        jaggedArray[0] = new int[] { 1, 2, 3};
        jaggedArray[1] = new int[] { 4, 5, 6};
        jaggedArray[2] = new int[] { 7, 8, 9};
        jaggedArray[3] = new int[] { 10, 11, 12};
        */

        for (int i = 0; i < jaggedArray.Length; i++) {
            for (int j = 0; j < jaggedArray[i].Length; j++) {
                Console.WriteLine("array[{0}][{1}] = {2}", i, j, jaggedArray[i][j]);
            }
        }
        Console.ReadKey();
    }
}

ใน ตัวอย่างเป็นการกำหนดค่าให้กับตัวแปรอาเรย์ในทันทีหลังจากที่มันถูกสร้าง หรือสามารถกำหนดให้ภายหลังเหมือนในส่วนทีคอมเม้นต์ไว้ได้เช่นกัน

array[0][0] = 1
array[0][1] = 2
array[0][2] = 3
array[1][0] = 4
array[1][1] = 5
array[1][2] = 6
array[2][0] = 7
array[2][1] = 8
array[2][2] = 9
array[3][0] = 10
array[3][1] = 11
array[3][2] = 12

และนี่เป็นลัพธ์เมื่อรันโปรแกรม
ในบทนี้ คุณได้เรียนรู้เกี่ยวกับอาเรย์ในภาษา C# ในแบบต่างๆ ทั้งอาเรย์หนึ่งมิติ อาเรย์หลายมิติ และอาเรย์ของอาเรย์

คำสั่งวนซ้ำ

ในบทนี้ คุณจะได้เรียนรู้เกี่ยวกับการใช้คำสั่งวนซ้ำเพื่อควบคุมโปรแกรม เช่น คำสั่ง while loop, do-while loop, for loop และ foreach loop
คำ สั่งวนซ้ำ (loop statements) ถูกใช้เพื่อควบคุมโปรแกรมเพื่อให้โปรแกรมทำบางส่วนของโค้ดซ้ำๆ มีลูปหลายประเภทที่เราสามารถใช้ได้ในภาษา C# และคุณจะได้เรียนรู้มันทั้งหมด เราจะเริ่มต้นกับลูปที่ง่ายที่สุดคือ while loop

คำสั่ง While loop

คำสั่ง while loop นั้นเป็นคำสั่งวนซ้ำที่ง่ายที่สุดในภาษา C# โดยมีรูปแบบการใช้งานดังนี้

while (expression) {
    statements
}

while loop นั้นจะใช้ในการทำซ้ำส่วนของโปรแกรมในขณะที่ expression เป็น true จนกว่า expression เป็น false โปรแกรมจะออกจาก while loop และทำงานต่อไปหลังจากลูป
ตัวอย่างการใช้ while loop ในภาษา C#

using System;

class WhileLoop
{
    static void Main(string[] args)
    {
        int n = 1;
        while (n <= 10)
        {
            Console.WriteLine("Loop " + n);
            n++;
        }
        Console.WriteLine("Loop ended");
        Console.ReadKey();
    }
}

ใน ตัวอย่าง เป็นตัวอย่างในการใช้ while loop เพื่อนับเลข โดยโปรแกรมจะนับเริ่มจาก 1 ถึง 10 เราได้กำหนดค่าเริ่มต้นให้กับตัวนับเป็น 1 และ expression ของเราคือ n <= 10 นั่นหมายความว่าโปรแกรมจะทำงานในลูปของ while ตราบใดที่ค่าของตัวแปร n ยังน้อยกว่าหรือเท่ากับ 10 หลังจากนั้นมันจะออกจากลูป และแสดงข้อความ "Loop ended" บรรทัดสุดท้าย ในลูปก็จะแสดงค่าของ n และเพิ่มค่าขึ้นในแต่ละรอบโดยคำสั่ง n++ เพื่อไม่ให้โปรแกรมอยู่ในลูปตลอดไป

Loop 1
Loop 2
Loop 3
Loop 4
Loop 5
Loop 6
Loop 7
Loop 8
Loop 9
Loop 10
Loop ended

และนี่เป็นผลลัพธ์จากตัวอย่างการใช้ while loop เพื่อนับตัวเลข

คำสั่ง Do-while loop

do-while loop นั้นคล้ายกับ while loop ซึ่งมันสามารถใช้ทดแทนกันได้ โดยมีรูปแบบการใช้งานดังนี้

do {
    statements
} while (expression) ;

สิ่ง ที่แตกต่างของ do-while loop คือการตรวจสอบ expression หลังจากการทำงานรอบแรกเสร็จสิ้น นั่นหมายความว่า do-while loop จะต้องทำงานอย่างน้อย 1 รอบ สังเกตุว่า expression จะอยู่ที่ตอน้ทายของลูป มาดูตัวอย่าง

using System;

class DoWhileLoop
{
    static void Main(string[] args)
    {
        int n;

        Console.WriteLine("Enter 0 to exit the loop");
        do
        {
            Console.Write("Your number: ");
            int.TryParse(Console.ReadLine(), out n);
            Console.WriteLine("Number you entered is " + n);
        } while (n != 0);

        Console.WriteLine("Loop ended");
        Console.ReadKey();
    }
}

ใน ตัวอย่าง เป็นการใช้ do-while loop เพื่อถามให้ผู้ใช้ป้อนตัวเลข (0) เพื่อออกจากลูป ถ้าตัวเลขที่ใส่เข้ามานั้นไม่ใช่ศูนย์ โปรแกรมก็จะถามให้ใส่ใหม่เรื่อยไป และเมื่อใส่เลขศูนย์ มันทำให้ expression ของเราเป็น false และทำให้โปรแกรมออกจากลูป

Enter 0 to exit the loop
Your number: 2
Number you entered is 2
Your number: 3
Number you entered is 3
Your number: 5
Number you entered is 5
Your number: 10
Number you entered is 10
Your number: 0
Number you entered is 0
Loop ended

นี่เป็นผลลัพธ์ของตัวอย่างการใช้ do while loop เมื่อทดสอบรันโปรแกรมและป้อนตัวเลข

คำสั่ง For loop

for loop นั้นเป็นลูปที่ใช้ทำซ้ำคำสั่งหรือชุดของคำสั่งเป็นจำนวนรอบที่แน่นอน โดยมันมีรูปแบบในการใช้งานดังนี้

for (initialize; condition; iterator) {
    statements
}

ใน การใช้ for loop เราสามารถกำหนดค่าเริ่มต้น สร้างเงื่อนไข (expression) และทำการกำหนดการเพิ่มค่าหรือลดค่าของตัวทำซ้ำได้ก่อนที่ลูปจะเริ่มทำงาน มันจะมีประโยชน์ที่จะให้สะดวกเมื่อเรารู้จำนวนรอบที่แน่นอนในการวนซ้ำของ โปรแกรม

using System;

class ForLoop
{
    static void Main(string[] args)
    {
        for (int i = 1; i <= 10; i++)
        {
            Console.WriteLine(i);
        }
        Console.ReadKey();
    }
}

ใน ตัวอย่างเป็นการใช้ for loop เพื่อแสดงตัวเลข 1 ถึง 10 เช่นกัน สังเกตุว่าการกำหนดค่าเริ่มต้น การสร้างเงื่อนไขและการเพิ่มค่าจะถูกใส่ไว้ที่ส่วนหัวของโปรแกรมที่เดียว อย่างไรก็ตาม มันก็เป็นแค่ทางเลือก และเราสามารถนำไปใส่ที่ใหม่ได้ถ้าหากต้องการ เหมือนตัวอย่างข้างล่างนี้

using System;

class ForLoop
{
    static void Main(string[] args)
    {
        int i = 1;
        for (; i <= 10; )
        {
            Console.WriteLine(i);
            i++;
        }
        Console.ReadKey();
    }
}

และ ข้างล่างนี่เป็นผลลัพธ์ของโปรแกรมทั้งสองที่ใช้ for loop จะเห็นว่ามันได้ผลลัพธ์เหมือน while loop ซึ่งลูปทั้งสองประเภทนี้ก็สามารถใช้ทดแทนกันได้เช่นกัน แต่อาจจะเขียนแตกต่างกันเล็กน้อย

1
2
3
4
5
6
7
8
9
10

คำสั่ง foreach loop

foreach loop นั้นจะใช้สำหรับวนซ้ำค่าในอาเรย์ ที่ทราบหรือไม่ทราบขนาด โดยลูปจะเริ่มอ่านค่าจากสมาชิกตัวแรกในอาเรย์ ไปจนถึงตัวสุดท้าย

using System;

class ForeachLoop
{
    static void Main(string[] args)
    {
        int[] numbers = { 2, 4, -1, 5, 0, 8, 9 };
        foreach (int i in numbers)
        {
            Console.WriteLine(i);
        }
        Console.ReadKey();
    }
}

ในตัวอย่างเราได้สร้างอาเรย์ของตัวเลขแบบ integer ซึ่งมีสมาชิกทั้งหมด 8 ตัว ในการวนซ้ำแต่ละรอบ ค่าะเก็บไว้ที่ตัวแปร i แล้วก็แสดงผลออกทาง console

2
4
-1
5
0
8
9

และนี่เป็นตัวอย่างผลลัพธ์ของการใช้ foreach loop

คำสั่ง break

คำ สั่ง break เพื่อบังคับให้ลูปสิ้นสุดการทำงานในทันที การหยุดการทำงานของลูปโดยการใช้คำสั่ง break มักจะสร้างให้กับเงื่อนไขบางอย่าง condition เพื่อทำให้โปรแกรมออกจากลูป มันสามารถใช้ได้กับลูปทุกประเภททั้ง while, do-while, for และ foreach loop
มาดูตัวอย่างการใช้คำสั่ง break

using System;

class ForLoop
{
    static void Main(string[] args)
    {
        for (int i = 1; i <= 10; i++)
        {
            Console.WriteLine(i);
            if (i == 5) break;
        }
        Console.ReadKey();
    }
}

ในตัวอย่างโปรแกรมจะออกจากลูปเมื่อ i มีค่าเท่ากับ 5 มันไม่สำคัญว่าเงื่อนไขในลูปที่ i <= 10 จะเป็นจริงหรือไม่

1
2
3
4
5

และข้างบนเป็นผลลัพธ์ของตัวอย่างการใช้คำสัง break

คำสั่ง continue

คำ สั่ง continue ใช้เพื่อข้ามการวนซ้ำรอบปัจจุบัน มันจะข้ามการทำงานคำสั่งทั้งหมดภายในลูปหลังจากคำสั่ง continue และไปเริ่มต้นรอบใหม่ มันสามารถใช้ได้กับลูปทุกประเภท

using System;

namespace ContinueStatement
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 1; i <= 10; i++)
            {
                if (i % 2 == 0) continue;
                Console.WriteLine(i);
                
            }
            Console.ReadKey();
        }
    }
}

ในตัวอย่างเราได้ใช้คำสั่ง continue เพื่อข้ามการแสดงผลของตัวเลขคู่ โดยคำสั่งจะทำงานเมื่อ i % 2 == 0 นั่นหมายความว่า i จะข้ามการแสดงผลไป

1
3
5
7
9

นี่เป็นฟลลัพธ์ตัวอย่างการใช้คำสั่ง continue
ใน บทนี้ คุณได้เรียนรู้เกี่ยวกับลูปประเภทต่างๆ ที่ใช้ในการควบคุมโปรแกรมในสถานะการต่างกัน และรู้ว่าเมื่อไหร่ที่ควรจะใช้คำสั่ง break และคำสัง continue

คำสั่งเลือกเงื่อนไข

ในเรียนนี้ คุณจะได้เรียนรู้เกี่ยวกับคำสั่งเงื่อนไขในภาษา C#
คำสั่งเงื่อนไข (selection statement) เป็นคำสั่งที่ให้คุณสามารถควบคุมโปรแกรมให้ทำงานตามต้องการ ตามเงื่อนไขที่กำหนดให้

คำสั่ง If

คำสั่ง if เป็นคำสั่งเลือกพื้นฐานในการเขียนโปรแกรมในทุกๆ ภาษา มันถูกใช้เพื่อควบคุมโปรแกรมเพื่อให้คำงานในบล็อกของ if ถ้าตรงกับเงื่อนไขที่กำหนดไว้ โดยคำสั่ง if มีรูปแบบการใช้งานดังนี้

if (expression) {
    // statements
}

expression คือเงื่อนไขที่คุณจะต้องกำหนดเพื่อที่จะให้โปรแกรมทำงาน ถ้า expression เป็น true โปรแกรมจะทำงานในบล็อกคำสั่งของ If ที่ล้อมรอบด้วย { และ } ถ้า expression เป็น false มันจะถูกเพิกเฉยและไปทำงานบรรทัดต่อไปหลังบล็อคของ If

string name = "Mateo";
if (name == "Mateo") {
    Console.WriteLine("Welcome, Mateo!");
}

จากตัวอย่างด้านบน เราได้ใช้คำสั่ง if เพื่อตรวจสอบชื่อในตัวแปร name ว่าถ้ามันเท่ากับ "Mateo" จะทำให้ expression เป็น true และจะแสดงคำว่า "Welcome, Mateo!" ออกทางหน้าจอคอมพิวเตอร์ของคุณ คุณสามารถลองใช้กับชื่ออื่นๆ ได้
Note: การเปรียบเทียบสตริงในภาษา C# นั้นเป็นแบบ case-sensitive นั่นหมายความว่า "Mateo" และ "mateo" นั้นเป็นคนละค่ากัน

คำสั่ง If-else if

คุณสามารถใช้คำสั่ง else if สำหรับเงื่อนไขที่สองและใช้คำสั่ง else สำหรับเงื่อนไขในกรณีที่ไม่ตรงกับเงื่อนไขใดๆ ก่อนหน้าเลย
มาดูตัวอย่างกับโปรแกรมตรวจสอบเกรดโดยการใช้คำสั่ง if-else

using System;

class SelectionStatement
{
    static void Main(string[] args)
    {
        int score;

        Console.Write("Enter your score: ");
        int.TryParse(Console.ReadLine(), out score);

        if(score >= 80) {
            Console.WriteLine("Your grade is A");
        }
        else if(score >= 70) {
            Console.WriteLine("Your grade is B");
        }
        else if (score >= 60)
        {
            Console.WriteLine("Your grade is C");
        }
        else if (score >= 50)
        {
            Console.WriteLine("Your grade is D");
        }
        else {
            Console.WriteLine("You fall");
        }
        Console.ReadKey();

    }
}

ในตัวอย่าง เป็นตัวแปรสำหรับการตรวจสอบเกรดโดยการใส่คำแนนลองไปในตัวแปร score และโปรแกรจะนำไปคำนวณเกรดที่ได้ คือถ้าคะแนนตั้งแต่ 80 ขึ้นไปจะได้เกรด A, 70 จะได้เกรด b, 60 เกรดจะได้ C ไปเรื่อยๆ และในคำสั่ง else ไม่ตรงกับเงื่อนไขใดๆ ก่อนหน้าเลย และคุณจะสอบตก
และนี่เป็นผลลัพธ์เมื่อเราได้ลองใส่ค่าคะแนนต่างๆ ลงบนโปรแกรม

Enter your score: 82
Your grade is A

Enter your score: 70
Your grade is B

Enter your score: 49
You fall

มาดูตัวอย่างเพิ่มเติม กับโปรแกรมแปลงอุณหภูมิโดยการใช้คำสั่ง if else

using System;

class SelectionStatement
{
    static void Main(string[] args)
    {
        int mode;
        float temperature;

        Console.Write("1: convert F to C\n2: convert C to F\n");
        Console.Write("Enter 1 or 2: ");
        int.TryParse(Console.ReadLine(), out mode);

        Console.Write("Enter temperature to be converted: ");
        float.TryParse(Console.ReadLine(), out temperature);

        if (mode == 1) {
            float c = (temperature - 32) * (5.0f / 9.0f);
            Console.WriteLine("Converted {0} Fahrenheit degree to {1} Celsius degree", temperature, c);
        } 
        else if (mode == 2) {
            float f = temperature * 1.8f + 32;
            Console.WriteLine("Converted {0} Celsius degree to {1} Fahrenheit degree", temperature, f);
        } 
        else {
            Console.WriteLine("You've entered wrong mode.");
        }
        Console.ReadKey();

    }
}

ในตัวอย่างข้างบนเป็นโปรแกรมสำหรับแปลงอุณภูมิจากองศาเซลเซียสเป็นองศาฟาเรนไฮต์ และในทางกลับกัน มันมีสองตัวแปรในโปรแกรม ตัวแปร mode เพื่อบ่งบอกว่าคุณต้องการแปลงไปเป็นแบบไหน ยกตัวอย่างเช่น: ถ้าคุณใส่ค่า 1 มันหมายความว่าแปลงจาก องศาฟาเรนไฮต์ ไปเป็น องศาเซลเซียส ใส่ 2 เป็นการแปลงจาก องศาเซลเซียส ไปเป็นองศาฟาเรนไฮต์ และถ้าเป็นค่าอื่นโปรแกรมจะไม่ทำงาน ตัวแปร temperature เป็นค่านำเข้าของอุณหภูมิที่ต้องการแปลง

คำสั่ง Switch case

คำ สั่งการเลือกอีกแบบหนึ่งคือคำสั่ง switch case ซึ่งมันทำงานคล้ายกับคำสั่ง if แต่มันใช้สำหรับเปรียบเทียบกับค่าคงที่เท่านั้น ซึ่งมีรูปแบบการใช้งานดังนี้:

switch(inputValue) {
    case constant1:
        // statement for case 1
        break;
    case constant2:
        // statement for case 1
        break;
    default:
        //statement for default case
        break;
}

โดย inputValue เป็นค่าที่ต้องการนำไปเปรียบเทียบกับค่าคงที่ในแต่ละกรณี (case) ในบล็อกของ switch ที่เรียงลำดับกัน เมื่อเงื่อนไขตรงกับ case ใดๆ โปรแกรมจะทำงานข้างของคำสั่ง case จนกว่ามันจะพบคำสั่ง break เพื่อที่จะออกจากบล็อกของ switch
ข้างล่างนี้เป็นตัวอย่างการใช้งาน switch-case

using System;

class SwitchCase
{
    static void Main(string[] args)
    {
        int n = 1;
        switch(n) {
            case 1:
                Console.WriteLine("Case 1");
                break;
            case 2:
                Console.WriteLine("Case 2");
                break;
            default:
                Console.WriteLine("Default case");
                break;
        }
        Console.ReadKey();
    }
}

ในตัวอย่าง เราได้ส่งตัวแปร n เป็นอากิวเมนต์สำหรับ switch และมันมีประเภทข้อมูลเป็นแบบ Integer สังเกตุกว่าเงื่อนใน case ต่างๆ ก็ต้องเป็น Integer ด้วยเช่นกัน
ในบทนี้ คุณได้เรียนรู้เกี่ยวกับการควบคุมโปรแกรมโดยใช้คำสั่งเลือกจากเงื่อนไขในภาษา C#

อินพุต เอาต์พุต พื้นฐาน

ในการเขียนโปรแกรม สิ่งที่สำคัญอบ่างหนึ่งคือโปรแกรมต้องมีการติดต่อกับผู้ใช้ โดยพื้นฐานแล้ว เป็นการแสดงผลลัพธ์ของโปรแกรม เราเรียกสิ่งนี้ว่า output โดยทั่วไปมักจะเป็นหน้าจอของคอมพิวเตอร์ และอีกอย่างหนึ่งคือหารให้ข้อมูลกับโปรแกรมเราเรียกว่า input ซึ่งโดยปกติจะเป็นทางคีย์บอร์ด อย่างไรก็ตาม มันสามารถเกิดขึ้นได้โดยวิธีอื่นๆ เช่น โหลดจากไฟล์ เสียง หรือนำเข้าจากกล้องถ่ายภาพ เป็นต้น สำหรับบทเรียนนี้เราจะพูดบนพื้นฐานการทำงานกับคอมพิวเตอร์เท่านั้น

ในบทเรียนนี้ เราจะแนะนำให้คุณได้รู้จักกับสองสามวิธีที่ใช้กันบ่อยๆ กับ console โปรแกรม

การแสดงข้อความกับฟังก์ชัน Write และ WriteLine

คุณได้เห็นว่าเราได้ใช้เมทธิดนี้ไปแล้วในบทก่อนหน้า ฟังก์ชัน Write และ WriteLine นั้นมาจากไลบรารี่มาตฐานของภาษา C# ซึ่งอยู่ในคลาส Console ข้อแตกต่างของมันคือ เมธอด WriteLine นั้นจะเพิ่มการขึ้นบรรทัดใหม่เข้าไปเพื่อคุณใส่ตัวอักษรเข้าไปในฟังก์ชัน ในขณะที่ฟังก์ชัน Write นั้นจะไม่ทำ มาดูตัวอย่าง

using System;

class BasicInputOutput1
{
    static void Main(string[] args)
    {
        Console.Write("Hello Java");
        Console.WriteLine("Hello C#");
        Console.Write("Hello C++");
        Console.ReadKey();
    }
}

มาดูตัวอย่าง เมื่อโปรแกรมได้ถูกรัน

Hello JavaHello C#
Hello C++

จากตัวอย่างด้านบนนั้น คุณจะสังเกตุเห็นว่าหลังจากคำว่า Hello C# โปรแกรมจะขึ้นบรรทัดใหม่ นั่นเป็นผลลัพธ์ของฟังก์ชัน WriteLine นั่นเอง ในภาษา C# คุณสามารถใช้ตัวอักษรพิเศษ \n เพื่อแสดงผลลัพธ์ของการขึ้นบรรทัดใหม่

Console.Write("Hello C#\n");
Console.WriteLine("Hello C#");

จากตัวอย่างด้านบน ทั้งของบรรทัดของโปรแกรมนั้นให้ผลลัพธ์ที่เหมือนกัน

ฟังก์ชัน Write และ WriteLine กับตัวแปร

เหมือน ในภาษาอื่นๆ ภาษา C# สามารถแสดงตัวอักษรร่วมกับตัวแปรและค่าคงที่ได้ สำหรับฟังก์ชัน Write และ WriteLine นั้นจะเป็นการใส่พารามิเตอร์มากกว่า 2 ตัวขึ้นไป จะจัดรูปแบบการแสดงผลในพารามิเตอร์ตัวแรก มาดูตัวอย่างการใช้งานของฟังก์ชัน Write และ WriteLine

using System;

class BasicInputOutput2
{
    static void Main(string[] args)
    {
        String name = "Marcus";
        String music = "Trip hop";
        String movie = "science";
        Console.WriteLine("My name is {0}.", name);
        Console.WriteLine("{0} is my favorite music style and {1} is movie style.", music, movie);
        Console.ReadKey();
    }
}

ในตัวอย่าง เราได้แสดงผลชื่อจากตัวแปร name นั่นหมายความว่าข้อความจะเปลี่ยนไปตามค่าของตัวแปร โดยเราได้ใส่อากิวเมนต์ตัวที่สองในฟังก์ชัน WriteLine คือตัวแปร name และหลังจากนั้นเราจะต้องทำการจัดรูปแบบการแสดงผลที่อากิวเมนต์แรกที่คุณจะเห็น { and } เพื่อให้สอดคล้องกับลำดับของตัวแปรที่ใส่เข้ามาในฟังก์ชัน
และนี่เป็นผลลัพธ์ของโปรแกรม

My name is Marcus.
Trip hop is my favorite music style and science is movie style.

และในภาษา C# ยังมีอีกวิธีหนึ่งที่คุณสามารถใช้ได้คือการต่อ string หรือเราเรียกว่า concatenating โดยการใช้เครื่องหมาย + เพื่อต่อข้อความเข้าด้วยกัน และคุณได้เห็นเราได้ใช้ในบทก่อนหน้านี้แล้ว

using System;

class BasicInputOutput3
{
    static void Main(string[] args)
    {
        String name = "Marcus";
        String music = "Trip hop";
        String movie = "science";
        Console.WriteLine("My name is " + name + ".");
        Console.WriteLine(music + " is my favorite music style and " + movie+ " is movie style.");
        Console.ReadKey();
    }
}

ทั้ง สองวิธีนั้นให้ผลลัพธ์ที่เหมือนกัน แต่จะมีข้อควรระวังคือการใช้เครื่องหมาย concatenating นั้นจะทำให้เกิดการแปลงตัวเลขเป็น string และให้คุณเลือกใช้มันอย่างเหมาะสม

Console.WriteLine("Number is " + 3 + 4); // Number is 34
Console.WriteLine("Number is " + (3 + 4)); // Number is 7

จาก ตัวอย่างนั้นจะได้ผลลัพธ์ที่แตกต่างกัน เพราะว่าการใช้เครื่องหมาย concatenate กับ string นั้นจะทำให้ตัวเลขถูกแปลงไปเป็นสตริงอัตโนมัติ คุณต้องกำหนดความสำคัญให้กับตัวเลขก่อนโดยการใส่วงเล็บดังตัวอย่างด้านบน

การอ่านค่าด้วยฟังก์ชัน Read และ ReadLine

ในภาษา C# ได้มีฟังก์ชันอำนวยความสะดวกสำหรับการอ่านค่านำเข้าจาก input steam เช่น คีย์บอร์ด โดยส่วนมากเรามักจะใช้ฟังก์ชัน ReadLine

ฟังก์ชัน Read

ฟังก์ชัน Read ใช้เพื่อผ่านตัวอักษรตัวต่อไปจาก input steam โดยฟังก์ชันจะส่งค่า integer ของตัวอักษรกลับมา โดยมันมีรูปแบบการใช้งานดังนี้

int variable = Console.Read();

Note: ฟังก์ชันนี้ใช้เพื่อรับค่าเพียงแค่หนึ่งตัวอักษรจากคีย์บอร์ดเท่านั้น ถ้าค่าอินพุตท์ของคุณมากกว่า มันจะตัดทิ้งไปเก็บไว้ใน input buffer

Console.WriteLine(Console.Read());
Console.WriteLine(Console.Read());
Console.WriteLine(Console.Read());

จาก ตัวอย่างด้านบน ให้อินพุตท์จากคีย์บอร์ดเป็น "abcd" ผลลัพธ์คือฟังก์ชันจะส่งค่าเป็น integer กลับมาและแสดงบนแต่ละบรรทัด และตัวอักษรตัวสุดท้ายนั้นจะไม่ถูกแสดงเพราะเราได้เรียกฟังก์ชัน Read เพียง 3 ครั้ง และมันจะนำไปเก็บตัวอักษร d ไว้ใน input buffer เมื่อมันเจอฟังก์ชัน Read อีกครั้ง มันจะนำตัวอักษรที่ถูกเก็บออกมาให้กับฟังก์ชันอัตโนมัติ

abcd
97
98
99

ฟังก์ชัน ReadLine

วิธี การรับค่าในภาษา C# ที่สะดวกที่สุดคือการใช้ฟังก์ชัน ReadLine เพื่ออ่านค่าจากคีย์บอร์ด มันสามารถใช้อ่าน string, integer, float, double เป็นต้น โดยฟังก์ชันจะ return ค่ากลับมาเป็นสตริง ในการที่คุณต้องการอ่านค่าที่เป็นตัวเลข เราจำเป็นต้องใช้ฟังก์ชันในการแปลงสตริงให้เป็นตัวเลขก่อน

using System;

class BasicInputOutput
{
    static void Main(string[] args)
    {
        String name;
        int age;
        double height;

        name = Console.ReadLine();
        int.TryParse(Console.ReadLine(), out age);
        double.TryParse(Console.ReadLine(), out height);

        Console.WriteLine("Name: {0}", name);
        Console.WriteLine("Age: {0}", age);
        Console.WriteLine("Height: {0}", height);
        Console.ReadKey();
    }
}

ใน ตัวอย่าง เรามีตัวแปร 3 ตัวและได้รับค่าให้กับมันโดยการเรียกใช้ฟังก์ชัน ReadLine เนื่องจากฟังก์ชันนั้น return ค่าเป็น string สำหรับตัวเลขนั้นเราจำเป็นต้องใช้ฟังก์ชัน TryParse เพื่อแปลงไปเป็นประเภทข้อมูลที่ต้องการ เช่น int.TryParse() จะแปลงข้อมูลไปเป็น integer

James
25
7.1
Name: James
Age: 25
Height: 7.1

และนี่เป็นตัวอย่างทั้งการรับค่าและแสดงผลออกทางหน้าจอ
ในบทนี้ คุณได้เรียนรู้ในการรับและการแสดงค่าในภาษา C# ในพื้นฐาน โดยการใช้ฟังก์ชันจากไลบรารี่มาตรฐาน

ตัวดำเนินการ

ตัวดำเนินการ คือเครื่องหมายที่ใช้เพื่อให้ทำงานกับตัวแปรและค่าคงที่เพื่อสร้าง expression ในการเขียนโปรแกรม ในภาษา C#มีตัวดำเนินการประเภทต่างๆ ที่คุณจะต้องรู้จักก่อนที่จะเขียนโปรแกรม ข้างล่างนี้เป็นรายการของประเภทตัวดำเนินการที่คุณจะได้เรียนในบทเรียนนี้

• Assignment operator
• Arithmetic operators
• Compound assignment
• Increment and decrement
• Relational and comparison operators
• Logical operators
• Conditional ternary operator
• Bitwise operators
• Explicit type casting operator

Assignment operator

assignment operator หรือตัวดำเนินการกำหนดค่าใช้เคื่องหมายเท่ากับ = มันใช้สำหรับกำหนดค่าให้กับตัวแปรในภาษา C# ยกตัวอย่างเช่น:

float weight = 58.3f;
int y = -3;
int x = y;
string name = "Marcus";

ในตัวอย่างด้านบน เราได้ใช้ตัวดำเนินการกำหนดค่าเพื่อกับหนดค่าให้กับตัวแปรซึ่งมีประเภทข้อมูลแบบต่างๆ

Arithmetic operators

ใน ภาษา C# มีตัวดำเนินการทางคณิตศาสตร์เพื่อใช้ในการดำเนินการในคณิตศาสตร์ต่างๆ เช่น การบวก การลบ การคูณ การหาร และอื่นๆ ในการเขียนโปรแกรม เราเรียกตัวดำเนินการเหล่านี้ว่า operand เพื่อใช่จัดการกับข้อมูลที่เรามี
ข้างล่างนี้เป็นตารางของตัวดำเนินการทางคณิตศาสตร์ในภาษา C#

Symbol	Name	Example
+	Addition	c = a + b
-	Subtraction	c = a - b
*	Multiplication	c = a * b
/	Division	c = a / b
%	Modulo	c = a % b

มาดูตัวอย่างในการใช้ตัวดำเนินการทางคณิตศาสตร์เบื้องต้นในภาษา C#

using System;

class ArithmeticOperators
{
    static void Main(string[] args)
    {
        int a = 10;
        int b = 3;

        float c = 2.0f;

        Console.WriteLine("a + b = " + (a + b));
        Console.WriteLine("a - b = " + (a - b));
        Console.WriteLine("a * c = " + (a * c));
        Console.WriteLine("a / c = " + (a / c));
        Console.WriteLine("a % c = " + (a % c));
        Console.ReadKey();
    }
}

ใน ตัวอย่าง เราได้สร้างตัวแปรสองตัวสำหรับเห็นค่าตัวเลขจำนวนเต็ม (integer) และอีกหนึ่งตัวเพื่อเก็บจำนวนจริง (floating point) เราได้ใช้ตัวดำเนินการทางคณิตศาสตร์ สำหรับการบวก การลบ การคูณ การหาร และมอดดูโล (การหารเอาเศษ)
และนี่เป็นผลลัพธ์เมื่อโปรแกรมได้รัน

a + b = 13
a - b = 7
a * c = 20
a / c = 5
a % c = 0

Compound assignment

Compound assignment operators เป็นตัวดำเนินการใช้สำหรับปรับปรุงหรืออัพเดทค่าของตัวแปร โดยมีข้อกำหนดว่าข้อมูลใหม่นั้นต้องมีความสัมพันธ์กับข้อมูลเดิม เช่น เพิ่มค่าของ x ไปอีก 10 กล่าวอีกนัยหนึ่งมันเป็นรูปแบบสั้นของ arithmetic operators
ข้างล่างนี้เป็นรายการของ compound assignment operators ในภาษา C# ที่คุณต้องทราบ

Operator	Example	Equivalent to
+=	a += 2;	a = a + 2
-=	a -= 2;	a = a - 2
*=	a *= 2;	a = a * 2
/=	a /= 2;	a= a / 2
%=	a %= 2;	a = a % 2
>>=	a >>= 2;	a = a >> 2
<<=	a <<= 2	a = a << 2
&=	a & = 2;	a = a & 2
^=	a ^= 2;	a= a ^ 2
|=	a |= 2;	a = a | 2

มาดูตัวอย่างการใช้งาน

int money = 100;
money += 30;    // equivalent to money = money + 30
money += 50;    // equivalent to money = money + 50

ในตัวอย่าง เป็นการเพิ่มค่าให้กับตัวแปร money มันมีค่าเหมือนกับคอมเม้นต์ทางด้านขวา

Increment และ decrement

Increment และ decrement เป็นตัวดำเนินการที่ใช้สำหรับเพิ่มค่าและลดค่าตามลำดับ ผลลัพธ์คือค่าของตัวแปรจะเพิ่มขึ้นหรือลดลง 1 เท่านั้น ซึ่งในตัวดำเนินการ increment และ decrement ก็จะแบ่งออกเป็น 2 แบบคือ prefix และ postfix และเครื่องหมายที่ใช้ในตัวดำเนินการนี้คือ ++ และ --

Type	Operator	Example	Equivalent to
Prefix	++	++a	a = a + 1
Postfix	++	a++	a = a + 1
Prefix	--	--a	a = a - 1
Postfix	--	a--	a = a - 1

Prefix เป็นการใส่เครื่องหมายไว้หน้าของตัวแปร การทำงานค่าของตัวแปรจะเพิ่มก่อนที่จะทำงานคำสั่งปัจจุบัน ในขณะที่ postfix เป็นการใส่เครื่องหมายทางด้านหลัง การทำงานค่าของตัวแปรจะถูกเพิ่มขึ้นหลังจากที่คำสั่งปัจจุบันทำงานเสร็จสิ้น แล้ว
มาดูตัวอย่างเพื่อให้คุณเข้าใจมันได้มากขึ้น

using System;

class IncrementDecrement 
{
    static void Main(string[] args)
    {
        int a = 5;
        int b = 5;

        Console.WriteLine("a =  {0}", ++a);
        Console.WriteLine("b =  {0}", b++);
        // now b is 6
        Console.ReadKey();
    }
}

และนี่เป็นผลลัพธ์ชองโปรแกรม

a = 6
b = 5

จาก ตัวอย่างข้างบน เรามีตัวแปรสองตัวคือ a และ b และได้กำหนดค่าเริ่มต้นให้กับทั้งสองเป็น 5 ตัวแปร a นั้นจะแสดงผลออกมาเป็น 6 เพราะว่าการทำงานของ increment แบบ postfix จะเพิ่มค่าก่อน ส่วน b นั้นยังคงเป็น 5 เพราะจะต้องเพิ่มค่าหลังจากการทำงานของบรรทัดนั้นเสร็จสิ้น

Relational และ comparison operators

ตัว ดำเนินการเปรียบเทียบ (comparison) และความสัมพันธ์ (relational) ถูกใช้ในการสร้าง expression กับตัวแปรและค่าคงที่ โดยผลลัพธ์ของ expression จะมีแค่เพียง true หรือ falseเท่านั้น มันมักจะใช้เพื่อสร้างเงื่อนไขเพื่อใช้กับคำสั่งในการเปรียบเทีบล เช่น if else, switch, while, do-while, for เป็นต้น

ตารางของ relational และ comparison operators ในภาษา C#

Operater	Example	Result
==	a == b	true if a equal to b, otherwise false
!=	a != b	true if a not equal to b, otherwise false
<	a < b	true if a less than b, otherwise false
>	a > b	true if a greater than b, otherwise false
<=	a <= b	true if a less than or equal to b, otherwise false
>=	a >= b	true if a greater than or equal to b, otherwise false

ต่อไปมาดูตัวอย่างในการใช้ตัวดำเนินการเปรียบเทียบ

int n = 10;
if (n % 2 == 0) {
    Console.WriteLine("n is even number.");
}

int x = 6, y = 2;
if (x < y) {
    Console.WriteLine("x is less than y");
}

และนี่เป็นผลลัพธ์เมื่อได้รันโปรแกรม

n is even number.

จากตัวอย่างข้างบน เราได้ใช้ตัวดำเนินการเปรียบเทียบ == เพื่อตรวจสอบถ้า n นั้นเป็นจำนวนคู่ แล้วโปรแกรมก็จะทำงานในบล็อคคำสั่งของ IF ต่อมา เราได้ใช้ตัวดำเนินการเปรียบเทียบน้อยกว่า < เพื่อตรวจสอบว่าถ้า x น้อยกว่า y เนื่องจาก x ไม่ได้น้อยกว่า y ดังนั้นโปรแกรมจึงไม่ทำงานในบล็อคคำสั่งของ IF

Logical operators

ตัว ดำเนินการเชิงตรรกะ (logical operators) มักจะใช้ในการตรวจสอบกับค่าของ boolean โดยปกติตัวดำเนินการเปรียบเทียบจะให้ผลลัพธ์เป็น boolean อยู่แล้ว ในภาษา C# มีตัวดำเนินการเชิงตรรกะอยู่ 3 แบบ

ตารางของ logical operators

Symbol	Name	Example
!	Not	! (n==1)
&&	And	a == 1 && b == 1
||	Or	a == 1 || b == 1

มาดูตัวอย่างการใช้ตัวดำเนินการเชิงตรรกะ

using System;

class LogicalOperators
{
    static void Main(string[] args)
    {
        bool a = (3 == 4);
        bool b = (3 != 4);
        bool c = (3 < 4);
        bool d = a && c;
        bool e = !d;

        Console.WriteLine("a = " + a);
        Console.WriteLine("b = " + b);
        Console.WriteLine("c = " + c);
        Console.WriteLine("d = " + d);
        Console.WriteLine("e = " + e);
        Console.ReadKey();
    }
}

จาก ตัวอย่างด้านบนเราได้สร้างตัวแปร boolean สำหรับเก็บค่าจาก expression ที่ถูกประเมินผลกับโอเปอแรน ตัวดำเนินการเปรียบเทียบและตัวดำเนินการตรรกะ ที่มันจะ return ค่าสุดท้ายคือ True หรือ False

a = False
b = True
c = True
d = False
e = True

และนี่เป็นผลลัพธ์ของโปรแกรม
ตัวดำเนินการตรรกะโดยปกติมักจะใช้กับคำสั่งเงื่อนไขหรือคำสั่งวนซ้ำ ดังตัวอย่างข้างล่างนี้

using System;

class LogicalOperators
{
    static void Main(string[] args)
    {
        int age = 20;
        int money = 100;

        if(age >= 18 && money >= 120) {
            Console.WriteLine("You can buy a game.");
        }

        if(age >= 18 || money >= 500) {
            Console.WriteLine("You can buy a movie.");
        }
        Console.ReadKey();
    }
}

ในตัวอย่าง เราได้สร้างเงื่อนไขเพิ่มเติมโดยการใช้ตัวดำเนินการตรรกะ เราใช้ตัวดำเนินการ "and" && นั่นหมายความว่าแต่ละ expression ย่อยต้องมีค่าเป็นจริง สำหรับการซื้อเกมผู้ใช้ต้องมีอายุตั้งแต่ 18 ปีขึนไปและต้องมีเงินตั้งแต่ 120 ขึ้นไป สำหรับการซื้อภาพยนตร์ เราได้ใช้ตัวดำเนินการ "or" || โดยเราต้องการเพียงแค่เงื่อนไขใดเงื่อนไขหนึ่งเท่านั้นที่เป็นจริง หรือทั้งสอง

Conditional ternary operator (?)

ternary operator นั้นจะใช้เครื่องหมาย ? มันถูกใช้ในการประเมินค่าของ expression และจะให้ผลลัพธ์เป็นค่าแรกถ้าหาก expression เป็น true และค่าที่สองถ้า expression เป็น false โดยค่าทั้งสองต้องเป้นประเภทหรือชนิดข้อมูลชนิดเดียวกัน โดยมันมีรูปแบบการใช้งานดังนี้

expression ? value1 : value2;

String cc = "NY";
Console.WriteLine(cc == "NY" ? "New York" : "Other states");

ในตัวอย่าง จากคำสั่ง cc == "NY" นั้นคือ expression ที่เราสร้างขึ้นจาก ternary operator และ "New York" นั้นจะผลเป็รผลลัพธ์เมื่อ expression นี้เป็น true และค่าที่สองคือ "Other states" จะเป็นผลลัพธ์เมื่อ expression เป็น false โปรดจำไว้ว่าค่าทั้งสองจะต้องเป็นประเภทข้อมูลเดียวกันเสมอ

New York

และนี่เป็นผลลัพธ์ของโปรแกรม มันจะแสดง "New York" เพราะว่า expression ของเราเป็น true

Bitwise operators

ในภาษา C# จะมีตัวดำเนินการระดับบิท (bitwise operators) โดยจะทำงานกับค่าของบิท ในรูปแบบต่างๆ ของข้อมูลที่เก็บไว้ในตัวแปร
และนี่เป็นตารางของ Bitwise operators ในภาษา C#

Symbol	Description
&	Bitwise AND
|	Bitwise inclusive OR
^	Bitwise exclusive OR
~	bit inversion
<<	Shift bits left
>>	Shift bits right

Explicit type casting operator

Explicit type casting ในภาษา C# นั้นหมายความว่าเป็นการแปลงจากประเภทข้อมูลชนิดหนึ่งไปเป็นประเภทข้อมูลอีก ชนิดหนึ่ง Explicit type casting จะเกิดขึ้นอัตโนมติเมื่อ literals ให้กับตัวแปรหรือค่าคงที่ หรือสามารถเกิดขึ้นโดยการใช้วิธีการของ c-like ซึ่งสืบทอดมาจาดภาษา C

int a = 10.5; // ตัวเลขนี้จะแปลงไปเป็น Integer อัตโนมัติ
int b = (int) 89.23; // c-like
float c = (int) b;

ในบทเรียนนี้ คุณได้เรียนรู้และทำความรู้จักกับภาษา C#และได้ดูวิธีการใช้งานในเบื้องต้น