วันพุธที่ 21 สิงหาคม พ.ศ. 2556

ใบความรู้ที่ 1.1 การสร้างแอพลิเคชันด้วย MS Visual C#

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

1. เลือกรายการเมนู New Project จากเมนู File ดังแสดงในรูปที่ 1.1
2. ในไดอะล็อกซ์ New Project เลือกชนิดของโปรเจ็กต์เป็น Console Application และตั้งชื่อให้กับ
โปรเจ็กต์ในกล่องข้อความด้านล่าง ดังแสดงตัวอย่างในรูปที่ 1.2 จากนั้นกดปุ่ม OK
3. โปรเจ็กต์ใหม่จะถูกสร้างขึ้นมาพร้อมทั้งไฟล์ชื่อ Program.cs ซึ่งมีโปรแกรมภาษา C# มาให้
บางส่วนเพื่อให้ง่ายต่อการเริ่มต้น ดังแสดงในรูปที่ 1.3 ในที่นี้เราอาจลบโปรแกรมที่ให้มาทั้งหมด
ทิ้งไปแล้วเริ่มเขียนโปรแกรมของเราเองก็ได้ เมื่อต้องการทดสอบการทำงานของโปรแกรมให้คลิก
ที่ปุ่ม
Run (  > ) เพื่อสั่งให้ MS Visual C# คอมไพล์โปรแกรมและให้โปรแกรมเริ่มทำงาน


รูปที่ 1.1 รายการเมนูสำหรับสร้างโปรเจ็กต์ใหม่


รูปที่ 1.2 ไดอะล็อกซ์ในสร้างโปรเจ็กต์ใหม่และการตั้งค่าสำหรับคอนโซลแอพลิเคชัน


รูปที่ 1.3 หน้าจอโดยรวมของ MS Visual C# หลังกระบวนการสร้างโปรเจ็กต์



ใบความรู้ที่ 1.2 ภาษา C# และเครื่องมือพัฒนาโปรแกรม

ใบความรู้ที่ 1.2
ภาษา C# และเครื่องมือพัฒนาโปรแกรม
          ภาษา C# เป็นภาษาโปรแกรมเชิงวัตถุ (object-oriented programming language) ที่ถูกพัฒนาขึ้นมา
โดยบริษัทไมโครซอฟต์ การพัฒนาโปรแกรมคอมพิวเตอร์ด้วยภาษา C# นั้นจะประกอบด้วยขั้นตอนดังนี้
• วิเคราะห์ปัญหาและความต้องการในการพัฒนาโปรแกรม เช่น โปรแกรมจะติดต่อกับผู้ใช้อย่างไร
ข้อมูลที่ผู้ใช้จะป้อนให้กับโปรแกรมเป็นอย่างไร และผลลัพธ์จะถูกแสดงผลอย่างไร
• ออกแบบขั้นตอนวิธี โดยแสดงการทำงานของโปรแกรมในภาพรวมออกมาเป็นลำดับขั้นตอน แต่
ละขั้นตอนมีความชัดเจนและสามารถเปลี่ยนให้อยู่ในรูปคำสั่งภาษา C# ได้โดยง่าย
• นำขั้นตอนวิธีที่ออกแบบไว้มาสร้างเป็นไฟล์โปรแกรมรหัสต้นฉบับ (source code) ที่ถูกต้อง
ตามโครงสร้างและไวยกรณ์ของตัวภาษา C# ทั้งนี้ไฟล์รหัสต้นฉบับต้องมีนามสกุล .cs เสมอ
เช่น prog1.cs
• แปลงรหัสต้นฉบับให้อยู่ในรูปรหัสภาษาเครื่องที่คอมพิวเตอร์เข้าใจและทำงานตามคำสั่งได้
ขั้นตอนนี้ต้องใช้โปรแกรมที่เรียกว่า คอมไพเลอร์ (compiler) ไฟล์รหัสภาษาเครื่องที่ถูกสร้างขึ้น
จากคอมไพเลอร์จะมีนามสกุล .exe ซึ่งย่อมาจาก executable หมายถึงไฟล์ที่ถูกเรียกทำงานได้
• ทดสอบการทำงานของโปรแกรม หากพบข้อผิดพลาดให้ตรวจสอบความถูกต้องในขั้นตอนที่ผ่าน
มา ซึ่งอาจหมายถึงการแก้ไขโปรแกรม ขั้นตอนวิธี หรือแม้กระทั่งวิเคราะห์ปัญหาและความต้องการ
ใหม่
ขั้นตอนการพัฒนาโปรแกรมดังกล่าวนี้นอกจากจะสามารถจะใช้กับภาษา C# แล้วยังสามารถนำไป
ประยุกต์ใช้กับภาษาอื่น ๆ ได้ด้วย
เครื่องมือสำหรับพัฒนาโปรแกรมด้วย C#
ขั้นตอนในการพัฒนาโปรแกรมที่กล่าวไปแล้วในข้างต้นอาจดูซับซ้อนสำหรับผู้ที่ยังไม่มี
ประสบการณ์ อย่างไรก็ตาม ในปัจจุบันได้มีซอฟต์แวร์สำหรับช่วยพัฒนาโปรแกรมภาษา C# อยู่มากมาย
ให้เลือกใช้ซึ่งเพิ่มความสะดวกและลดข้อผิดพลาดลงได้เป็นอย่างมาก ซอฟต์แวร์หลายตัวถูกแจกจ่าย
ให้นำไปใช้งานได้โดยไม่ต้องเสียค่าใช้จ่าย หนึ่งในซอฟต์แวร์เหล่านั้นคือ Microsoft Visual C# 2008
Express Edition (ในที่นี้ขอเรียกย่อ ๆ ว่า MS Visual C#)
MS Visual C# มีคุณสมบัติคร่าว ๆ ดังต่อไปนี้
• สร้าง/แก้ไข/บันทึก โปรแกรมที่เขียนด้วยภาษา C# ได้
• คอมไพล์และทดสอบโปรแกรมที่เขียนขึ้นได้ทันที
• เพิ่มความง่ายในการเขียนโปรแกรมด้วยคุณสมบัติการเติมเต็มคำสั่ง (Code Completion)
• สนับสนุนการพัฒนาโปรแกรมทั้งประเภทที่ติดต่อกับผู้ใช้ผ่านคอนโซล (Console Application) ซึ่ง
รับข้อมูลผ่านแป้นพิมพ์และแสดงผลข้อมูลในรูปตัวอักษรเพียงอย่างเดียว ดังตัวอย่างในรูปที่ 1.4
และประเภทที่ใช้คุณสมบัติของวินโดวส์เต็มรูปแบบ (Windows Application) ซึ่งอนุญาตให้ผู้ใช้งาน
ควบคุมโปรแกรมโดยใช้เมาส์และแสดงผลในแบบกราฟิกได้ ดังตัวอย่างในรูปที่ 1.5

รูปที่ 1.4 ตัวอย่างคอนโซลแอพลิเคชัน (Console Application)


รูปที่ 1.5 ตัวอย่างวินโดวส์แอพลิเคชัน (Windows Application)

ใบความรู้ที่ 1.3 โครงสร้างโปรแกรมภาษา C# และข้อมูลพื้นฐานและตัวดำเนินการ

ใบความรู้ที่ 1.3
โครงสร้างโปรแกรมภาษา C# และข้อมูลพื้นฐานและตัวดำเนินการ
การโปรแกรมภาษา C# ขั้นพื้นฐานที่มีเฉพาะส่วนของโปรแกรมหลักและไม่มีโปรแกรมย่อย(subroutine) จะมีส่วนประกอบดังนี้
namespace ___(A)___
{
     class ___(B)___
    {
          static void Main()
         {
              ___(C)___
          }
     }
}

         ตามโครงสร้างข้างต้น ณ ตำแหน่ง (A), (B), and (C) มีความหมายดังต่อไปนี้
• ตำแหน่ง (A) ระบุชื่อของเนมสเปซ (namespace) ซึ่งใช้ในการกำหนดขอบเขตให้กับคลาสต่าง ๆ
รวมถึงใช้ในการจัดโครงสร้างของโปรแกรมขนาดใหญ่ให้เป็นสัดส่วนอีกด้วย โดยเฉพาะอย่างยิ่ง
ในการพัฒนาแอพลิเคชันที่ซับซ้อนโดยผู้พัฒนาหลายคน การกำหนดเนมสเปซของตนเองสามารถ
ป้องกันปัญหาการตั้งชื่อคลาสหรือค่าคงที่อื่น ๆ ซ้ำกันได้ ส่วนไลบรารีของภาษา C# ที่มีให้เรา
เรียกใช้งานได้ ก็ถูกเตรียมเอาไว้ในเนมสเปซชื่อต่าง ๆ เช่นเดียวกัน
• ตำแหน่ง (B) ระบุชื่อของคลาส (class)
• ตำแหน่ง (C) เป็นพื้นที่สำหรับคำสั่งต่าง ๆ ที่ผู้เขียนโปรแกรมต้องการให้คอมพิวเตอร์ปฏิบัติตาม
        นอกจากนี้โปรแกรมที่ไม่ซับซ้อนมากยังสามารถละส่วนที่ระบุเนมสเปซทิ้งไปได้ คลาสที่ถูกสร้าง
ขึ้นมาโดยไม่อยู่ในขอบเขตของเนมสเปซใดจะถือว่าอยู่ในเนมสเปซกลาง (global namespace)
class ___(B)___
{
      static void Main()
     {
          ___(C)___
     }
}

โปรแกรมภาษา C# ซึ่งแสดงข้อความ Hello World! ออกทางจอภาพ จากนั้นรอจนกว่าผู้ใช้จะกด Enter และจบการทำงาน โปรแกรมนี้อยู่ในเนมสเปซชื่อ HelloApp และคลาสชื่อ HelloClass
namespace HelloApp
{
      class HelloClass
      {
            static void Main()
            {
                  System.Console.WriteLine("Hello World!");
                 System.Console.ReadLine();
            }
      }
}

โปรแกรมภาษา C# ซึ่งให้ผลลัพธ์เช่นเดียวกับโปรแกรมข้างต้น แต่เขียนโดยไม่ระบุเนมสเปซ
class HelloClass
{
      static void Main()
      {
             System.Console.WriteLine("Hello World!");
             System.Console.ReadLine();
      }

}

กฎการตั้งชื่อตัวระบุในภาษา C#
            โปรแกรมภาษา C# ที่นำไปใช้งานจริงมักจะมีการใช้งานตัวระบุ (identifier) อยู่ทั่วไปภายในโปรแกรม เช่นชื่อของเนมสเปซและคลาสที่ได้กล่าวไปข้างต้น ภาษา C# ได้จำกัดกฎเกณฑ์การตั้งชื่อให้ตัวระบุเอาไว้ดังต่อไปนี้
• ชื่อตัวระบุต้องประกอบด้วยตัวอักษรภาษาอังกฤษ (A-Z,a-z) ตัวเลข (0-9) หรือเครื่องหมายขีดเส้น
ใต้ (_) เท่านั้น
• ตัวอักษรตัวแรกของชื่อต้องเป็นตัวอักษรภาษาอังกฤษ หรือตัวขีดเส้นใต้
• ชื่อตัวระบุจะมีความยาวได้ไม่เกิน 63 ตัวอักษร
• ชื่อตัวระบุต้องไม่ซ้ำกับคำสงวน (reserved word) เช่น class, namespace, int, void,

  static

ชนิดข้อมูล (Data Types) ใน C#
           C# กำหนดชนิดของข้อมูลไว้หลากหลายชนิดเพื่อรองรับการจัดเก็บข้อมูลหลาย ๆ ประเภท
ตารางที่ 1 แสดงชนิดข้อมูลหลัก ๆ ที่พบบ่อยในโปรแกรมทั่วไป
ตารางที่ 1 ชนิดข้อมูลหลัก ๆ ของภาษา C#
ชนิดข้อมูล           คำอธิบาย
char                     อักขระเดี่ยว เช่น a
bool                     ค่าความจริง เป็นไปได้สองค่าคือ true หรือ false
byte                     จำนวนเต็มไม่มีเครื่องหมาย ตั้งแต่ 0 ถึง 255
int                       จำนวนเต็มมีเครื่องหมาย ตั้งแต- 2,147,483,648 ถึง 2,147,483,647
uint                     จำนวนเต็มไม่มีเครื่องหมาย ตั้งแต่ 0 ถึง 4,294,967,295
long                     จำนวนเต็มมีเครื่องหมาย ตั้งแต- 9,223,372,036,854,775,808 ถึง                                                    9,223,372,036,854,775,807
ulong                   จำนวนเต็มไม่มีเครื่องหมาย ตั้งแต่ 0 and 18,446,744,073,709,551,615
float                    จำนวนจริง (มีทศนิยมได้) เช่น 3.14159
double                 จำนวนจริงที่เก็บความละเอียดมากเป็นสองเท่า

string                   ข้อความ (สายอักขระ) เช่น Hello

ตัวแปร (Variables)
           ตัวแปร (variable) เป็นตัวระบุประเภทหนึ่งที่นำมาใช้ในการอ้างถึงข้อมูล โดยค่าของมันสามารถถูกเปลี่ยนแปลงได้ตลอดเวลาที่โปรแกรมกำลังทำงานอยู่ ในภาษา C# ตัวแปรทุกตัวต้องถูกประกาศก่อนที่จะถูกนำมาใช้งาน โดยมีการระบุชนิดข้อมูลที่จะใช้กับตัวแปรนั้น ๆ ไว้ด้วยตามรูปแบบดังนี้
DataType variableName;

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

           จะเห็นว่าส่วนที่เพิ่มขึ้นมาคือเครื่องหมาย = และ initialValue ซึ่งระบุค่าเริ่มต้นให้กับตัว
แปรชื่อvariableName

คำสั่งด้านล่างประกาศตัวแปรชื่อ distance ที่มีชนิดข้อมูลเป็น uint และไม่มีการกำหนดค่าเริ่มต้น
uint distance;

คำสั่งด้านล่างประกาศตัวแปรชื่อ salary ที่มีชนิดข้อมูลเป็น long และค่าเริ่มต้นเป็น 30000
long salary = 30000;

ค่าคงที่ (Constants)
            ค่าคงที่เป็นตัวระบุอีกประเภทหนึ่งที่นำมาใช้ในการอ้างถึงข้อมูลเช่นเดียวกับตัวแปร สิ่งที่แตกต่างจากตัวแปรก็คือค่าของมันไม่สามารถเปลี่ยนแปลงได้อีกหลังจากการประกาศในภาษา C# ค่าคงที่ต้องถูกประกาศโดยระบุชนิดข้อมูลและค่าตั้งต้นก่อนถูกนำมาใช้งานเสมอการประกาศค่าคงที่จะคล้ายคลึงกับการประกาศตัวแปร แตกต่างกันตรงที่ต้องมีการระบุด้วยคีย์เวิร์ดconst ดังแสดง
const DataType constantName = value;

            ในที่นี้ constantName คือชื่อของค่าคงที่ ส่วน DataType คือชื่อชนิดข้อมูลที่ค่าคงที่นี้ใช้
อ้างถึง และ value ระบุค่าที่ค่าคงที่นี้ถูกใช้เป็นตัวแทน

คำสั่งด้านล่างประกาศค่าคงที่ชื่อ myconst โดยมีชนิดข้อมูลเป็นแบบ double และใช้แทนค่า 2.71828

const double myconst = 2.71828;

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

1:    using System;
2:
3:    class Intro {
4:         static void Main() {
5:               const string MY_NAME = "Harry";
6:
7:               Console.WriteLine("Hello {0}, how are you?", MY_NAME);
8:               Console.WriteLine("And how can I help you, {0}?",
9:                        MY_NAME);
10:              Console.ReadLine();
11:       }

12:   }

           ตัวแปร)รวมถึงค่าคงที่ (ที่มีชนิดข้อมูลแบบเดียวกันสามารถถูกประกาศร่วมกันภายในคำสั่งเดียวกันได้โดยคั่นด้วยเครื่องหมายคอมม่า
const int FreezingPoint = 32;
int x, y;
int wd = 5, ht = 8;
const double PI = 3.1424;
char ch = 'A';
string mynote = "Hello, Kitty";

int j = 5;


นิพจน์ทางคณิตศาสตร์ (Arithmetic Expressions)
          นิพจน์ (expression) ภายในโปรแกรมภาษา C# หมายถึงส่วนของโปรแกรมที่สามารถถูกตีความเป็นค่าต่าง ๆ ได้ โดยนิพจน์อาจประกอบด้วยเทอมเพียงเทอมเดียว หรือเกิดจากการผสมกันของนิพจน์อื่นที่เล็กกว่า ด้านล่างเป็นตัวอย่างของนิพจน์ที่ประกอบด้วยเทอมเพียงเทอมเดียว
• ตัวเลขโดด เช่น 3000, 1.414
• ข้อความ เช่น "Hello, World"
• ค่าความจริง ได้แก่ true และ false
• ตัวแปรหรือค่าคงที่เดี่ยว ๆ ที่ผ่านการกำหนดค่าให้แล้ว เช่น myName, salary
         ในที่นี้จะเน้นการศึกษาเกี่ยวกับนิพจน์ที่ให้ค่าเป็นตัวเลข เรียกว่า นิพจน์ทางคณิตศาสตร์ (arithmeticexpression) โดยเราสามารถผสมนิพจน์ต่าง ๆ ให้เป็นนิพจน์ที่ซับซ้อนขึ้นโดยอาศัยตัวดำเนินการทางคณิตศาสตร์ที่มีให้ในภาษา C# ดังตารางที่2

ตารางที่ 2 ตัวดำเนินการทางคณิตศาสตร์

ตัวดำเนินการ     สัญลักษณ์    จำนวนนิพจน์ที่นำมาผสม    ตัวอย่าง  ค่าของนิพจน์เมื่อ x = 20
บวก (add)               +                           2                          x+4                        24
ลบ (subtract)           -                            2                         32-x                       12
คูณ (multiply)          *                           2                          x*2                        40
หาร (divide)            /                            2                           x/2                        10
หารเอาเศษ

(modulo)               %                            2                         x%6                         2


ตัวดำเนินการ    สัญลักษณ์    จำนวนนิพจน์ที่นำมาผสม    ตัวอย่าง   ค่าของนิพจน์เมื่อ x = 20
กลับเครื่องหมาย
(negate)                    -                               1                            -x                        -20
จัดกลุ่ม                   (    )                         N/A                       (x+2)*3                    66

        หากนิพจน์ที่สร้างขึ้นมาใหม่ประกอบด้วยตัวดำเนินการมากกว่าหนึ่งตัว C# จะคำนวณค่าเรียง
ตามลำดับก่อนหลังดังนี้
•   (   )
•    *, / และ %
•    + และ -
•    หากตัวดำเนินการมีลำดับเท่าเทียมกัน คำนวณจากซ้ายไปขวา

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

การเรียกใช้งานคำสั่ง Write และ WriteLine โดยระบุเนมสเปสเต็มรูปแบบ
class Hello
{
      static void Main()
      {
          System.Console.Write("Hello, ");
          System.Console.WriteLine("everybody");
      }
}

            สังเกตว่าการเรียกใช้คำสั่ง Write และ WriteLine นั้นต้องระบุถึงคลาส Console ซึ่งเป็น
คลาสที่นิยามคำสั่งนี้เอาไว้ และเนื่องจากคลาส Console เป็นคลาสที่อยู่ในเนมสเปส System จึงต้อง
ระบุชื่อเนมสเปสไว้ด้วยตามตัวอย่าง อย่างไรก็ตามเราสามารถทำโปรแกรมให้สั้นลงได้โดยใช้คำสั่ง
using ซึ่งเป็นการสั่งให้คอมไพเลอร์ค้นหาคลาสที่เรียกใช้งานในเนมสเปสที่ระบุ ดังตัวอย่างต่อไปนี้

การเรียกใช้งานคำสั่ง Write และ WriteLine โดยใช้คำสั่ง using

using System;
class Hello
{
       static void Main()
      {
            Console.Write("Hello, ");
            Console.WriteLine("everybody");
      }

}

           คำสั่ง Write และ WriteLine นั้นยังสามารถเรียกใช้งานในรูปแบบที่ซับซ้อนกว่านี้อีกมาก ดังแสดงในตัวอย่างต่อไปนี้

การเรียกใช้งานคำสั่ง Write และ WriteLine โดยใช้สตริงกำหนดรูปแบบ (formatting string)
using System;
class Hello
{
       static void Main()
       {
             int width = 80, height = 30;
             Console.WriteLine("Area of {0}x{1} rectangle = {2}",
             width, height, width*height);
       }
}
             จะเห็นว่าสตริงที่เป็นพารามิเตอร์ตัวแรกของคำสั่ง WriteLine นั้นเป็นสตริงที่ใช้สำหรับ
กำหนดรูปแบบในการแสดงผลของนิพจน์ที่ตามมาอีกสามตัว สัญลักษณ์ {0} {1} และ {2} คือตำแหน่งที่ C# จะนำค่าของนิพจน์ width, height และ width*height มาแทนที่




ใบความรู้ที่ 1.4 การขอความช่วยเหลือ

ใบความรู้ที่ 1.4
การขอความช่วยเหลือ

          โปรแกรม MS Visual C# 2008 Express (รวมถึงโปรแกรมอื่น ๆ ในชุด MS Visual Studio 2008
Express) มีการเชื่อมต่อกับระบบไลบรารีของ Microsoft Developer Network (MSDN Library) ซึ่งรวบรวมเอกสารเชิงเทคนิคสำหรับการพัฒนาซอฟต์แวร์บนไมโครซอฟต์วินโดวส์ไว้โดยละเอียด หาก MSDN Library ได้ถูกติดตั้งไว้พร้อมกับการติดตั้ง MS Visual C# ผู้พัฒนาโปรแกรมก็สามารถเรียก MSDN Library จากเมนู Help เพื่อเปิดเอกสารเพื่ออ่านรายละเอียดคุณสมบัติและการใช้งานคลาสต่าง ๆ ที่ถูกเตรียมไว้ใน .NET Framework ได้ รูปที่ 1.6 แสดงการเรียกใช้งาน MSDN Library จากหน้าจอหลักของ MS Visual C# ซึ่งจะได้หน้าจอคล้ายคลึงกับรูปที่ 1.7
รูปที่ 1.6 การเรียกใช้งาน MSDN Library จากหน้าจอหลักของ MS Visual C#

             การค้นเอกสารจาก MSDN Library นั้นสามารถทำได้หลายรูปแบบ ผู้พัฒนาโปรแกรมอาจเลือก
หัวข้อจากสารบัญทางด้านซ้ายมือ หรือป้อนคำค้นในกล่อง Search เพื่อค้นหาหัวข้อที่เกี่ยวข้อง รูปที่ 1.8
แสดงผลลัพธ์จากการค้นหาด้วยคำค้น Math
รูปที่ 1.7 หน้าจอของ MSDN Library ในส่วนของการค้นหา

รูปที่ 1.8 ผลลัพธ์จากการป้อนคำค้น Math

            นอกจากการเข้าสู่ MSDN Library ผ่านทางเมนู Help แล้ว ผู้พัฒนาโปรแกรมยังสามารถค้นหา
รายละเอียดของชื่อเนมสเปส คลาส คีย์เวิร์ด หรือเมท็อดที่ต้องการได้จากพื้นที่การเขียนโปรแกรมโดยตรง โดยเลื่อนเคอร์เซอร์มาวางไว้ในคำที่ต้องการสืบค้น แล้วกดปุ่ม F1 ดังแสดงตัวอย่างในรูปที่ 1.9 ซึ่งจะได้ผลลัพธ์เป็นรายการของคลาสที่อยู่ในเนมสเปส System ดังรูปที่ 1.10


รูปที่ 1.9 การขอความช่วยเหลือโดยใช้ปุ่ม F1

รูปที่ 1.10 รายชื่อคลาสในเนมสเปซ System หลังใช้คำสั่งค้นหาผ่าน MSDN Library






ใบความรู้ที่ 2.1 ฟังก์ชันทางคณิตศาสตร์

ใบความรู้ที่ 2.1
ฟังก์ชันทางคณิตศาสตร์

          นอกเหนือจากตัวดำเนินการทางคณิตศาสตร์ (+ - * / ฯลฯ) ภาษา C# ได้เตรียมคลาส Math ที่รวบรวมเมท็อด1 และค่าคงที่ทางคณิตศาสตร์ที่สำคัญเอาไว้ใช้งาน ตารางด้านล่างแสดงตัวอย่างของฟังก์ชันและค่าคงที่ที่เราสามารถเรียกใช้งานได้ผ่านคลาส Math คลาสนี้ถูกจัดไว้ภายใต้เนมสเปส System เช่นเดียวกันกับคลาส Console





ใบความรู้ที่ 2.2 คำสั่งสำหรับรับข้อมูลจากผู้ใช้

ใบความรู้ที่ 2.2
คำสั่งสำหรับรับข้อมูลจากผู้ใช้

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

ตัวอย่างที่ 2.1 โปรแกรมด้านล่างจะถามชื่อจากผู้ใช้ และกล่าวคำทักทายตามชื่อนั้น ๆ
using System;
class SayHello
{
   static void Main()
   {
      string name;
      Console.Write("What is your name? ");
      name = Console.ReadLine();
      Console.WriteLine("Hello {0}, how are you?", name);
      Console.ReadLine();
   }
}

            นอกจากการรับข้อมูลแบบข้อความแล้วโปรแกรมส่วนใหญ่ยังต้องการรับข้อมูลที่เป็นตัวเลขเพื่อ
นำมาคำนวณอีกด้วย อย่างไรก็ตาม ภาษา C# ไม่มีคำสั่งที่รับข้อมูลชนิดตัวเลขโดยตรง แต่ได้เตรียมเมท็อด Parse สำหรับแต่ละชนิดข้อมูลแบบตัวเลขเพื่อแปลงข้อมูลชนิดข้อความให้เป็นชนิดตัวเลขได้ การใช้งานเมท็อด Parse เป็นดังนี้
<numeric_datatype>.Parse(<string_expression>)

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

ตัวอย่างที่ 2.2 เขียนโปรแกรมเพื่ออ่านเวคเตอร์แบบสองมิติ (x,y) จากผู้ใช้แล้วคำนวณขนาดของเวคเตอร์ และแสดงผลลัพธ์ออกทางหน้าจอโดยมีทศนิยมสองตำแหน่ง (ใช้ตัวกำหนดรูปแบบ {2:f2} แทนที่จะเป็น {2} เพียงอย่างเดียว)
using System;
class Vector2D
{
   static void Main()
   {
      double x, y, size;
      Console.Write("Enter x: ");
      x = double.Parse(Console.ReadLine());
      Console.Write("Enter y: ");
      y = double.Parse(Console.ReadLine());
      size = Math.Sqrt(x*x + y*y);
      Console.WriteLine("Size of the vector ({0},{1}) is {2:f2}.",
         x, y, size);
      Console.ReadLine();
   }
}




ใบความรู้ที่ 3.1 นิพจน์ทางตรรกศาสตร์

ใบความรู้ที่ 3.1
นิพจน์ทางตรรกศาสตร์

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

             นอกจากนี้เรายังสามารถนำเอานิพจน์ทางตรรกศาสตร์ตั้งแต่หนึ่งนิพจน์หรือมากกว่ามาผสมกันเพื่อสร้างนิพจน์ทางตรรกศาสตร์ที่ซับซ้อนขึ้นอีกโดยอาศัยตัวเชื่อมดังต่อไปนี้

• && เชื่อมนิพจน์ทางตรรกศาสตร์สองนิพจน์เข้าด้วยกันโดยใช้ตรรกแบบ "และ" (AND)
   ตัวอย่างเช่น (x>1) && (x<10) จะให้ค่าจริงเมื่อตัวแปร x มีค่าอยู่ระหว่าง 1 ถึง 10
• || เชื่อมนิพจน์ทางตรรกศาสตร์สองนิพจน์เข้าด้วยกันโดยใช้ตรรกแบบ "หรือ" (OR) ตัวอย่างเช่น
   (x<1) || (x>10) จะให้ค่าจริงเมื่อตัวแปร x มีค่าน้อยกว่า 1 หรือมากกว่า 10
• ! กลับค่าความจริงของนิพจน์ทางตรรกศาสตร์ ตัวอย่างเช่น !(x==1) จะเป็นจริงเมื่อตัวแปร x มี
   ค่าไม่เท่ากับ 1



ใบความรู้ที่ 3.2 โครงสร้าง if และ if...else

ใบความรู้ที่ 3.2
โครงสร้าง if และ if...else

            โครงสร้าง if เป็นโครงสร้างที่ใช้ควบคุมการทำงานของคำสั่งอื่น ๆ ภายใต้เงื่อนไข (condition) ที่

กำหนด การใช้งานนั้นมีสองรูปแบบคร่าว ๆ ได้แก่

• รูปแบบที่ 1: โครงสร้าง if
จากการใช้งานด้านล่าง คำสั่ง statement จะถูกเรียกทำงานก็ต่อเมื่อนิพจน์ทางตรรกศาสตร์ที่
กำหนดเป็น condition มีค่าเป็นจริง
if (condition)
   statement; // executed if the condition is true

เนื่องจากโครงสร้างข้างต้นอนุญาตให้เรากำหนดเงื่อนไขให้กับคำสั่งเพียงคำสั่งเดียวเท่านั้น อย่างไร
ก็ตาม หากมีคำสั่งมากกว่าหนึ่งภายใต้เงื่อนไขเดียวกัน คำสั่งเหล่านี้สามารถถูกจัดกลุ่มให้เป็น
เสมือนคำสั่งเดียวได้โดยการครอบคำสั่งทั้งหมดด้วยวงเล็บปีกกา ({...})
if (condition) {
   statement1; // executed if the condition is true
   statement2; // executed if the condition is true
   statement3; // executed if the condition is true
   :
}

• รูปแบบที่ 2: โครงสร้าง if...else
คำสั่ง statement1 จะถูกเรียกทำงานเมื่อนิพจน์ในตำแหน่ง condition มีค่าเป็นจริง หาก
นิพจน์ดังกล่าวมีค่าเป็นเท็จ คำสั่ง statement2 จะถูกเรียกทำงานแทน

if (condition)
   statement1; //executed if the condition is true
else
   statement2; //executed if the condition is false

และเช่นเคย เราสามารถใช้งานโครงสร้าง if...else ร่วมกับวงเล็บปีกกาหากมีคำสั่งที่ต้องการ
ให้ทำงานภายใต้เงื่อนไขมากกว่าหนึ่ง

if (condition) {
   statementT1; //executed if the condition is true
   statementT2; //executed if the condition is true
}
else {
   statementF1; //executed if the condition is false
   statementF2; //executed if the condition is false
}
ตัวอย่างที่ 3.1 รหัสจำลอง (pseudo-code) ด้านล่างอธิบายขั้นตอนวิธีสำหรับให้โปรแกรมพิมพ์คำว่า
Passed หากคะแนนของนักเรียนมีค่ามากกว่าหรือเท่ากับ 60 ไม่เช่นนั้นให้พิมพ์คำว่า Failed

if student's score is greater than or equal to 60
   Print "Passed"
otherwise
   Print "Failed"
เราสามารถนำรหัสจำลองข้างต้นมาเขียนเป็นโปรแกรมภาษา C# ได้ดังนี้ (แสดงเพียงส่วนสำคัญเท่านั้น)

if (score >= 60)
  Console.WriteLine("Passed");
else
  Console.WriteLine("Failed");

เนื่องจากคีย์เวิร์ด else เป็นตัวกำหนดให้การพิมพ์คำว่า Failed ทำงานเมื่อเงื่อนไข score >= 60
เป็นเท็จ ดังนั้นหากเราแทนที่ else ด้วยคำสั่ง if และใช้เงื่อนไขที่ตรงข้ามกันคือ score < 60
โปรแกรมก็จะมีการทำงานเหมือนกับโปรแกรมข้างบนทุกประการ

if (score >= 60)
  Console.WriteLine("Passed");
if (score < 60)
  Console.WriteLine("Failed");

ตัวอย่างที่ 3.2 โปรแกรมต่อไปนี้จะรอรับตัวเลขจากผู้ใช้และให้คำตอบว่าตัวเลขนั้น ๆ เป็นเลขคู่ (even) หรือ เลขคี่ (odd)

• ใช้รูปแบบ if
using System;
class OddOrEven {
  static void Main() {
     int N;
     Console.Write("Please input N: ");
     N = int.Parse(Console.ReadLine());
     if (N%2 == 0)
       Console.WriteLine("{0} is even", N); //true
     if (N%2 != 0)
       Console.WriteLine("{0} is odd", N); //true
  }
}

• ใช้รูปแบบ if...else

using System;
class OddOrEven {
  static void Main() {
    int N;
    Console.Write("Please input N: ");
    N = int.Parse(Console.ReadLine());
    if (N%2 == 0)
      Console.WriteLine("{0} is even", N); //true
    else
      Console.WriteLine("{0} is odd", N); //false
  }
}

ตัวอย่างที่ 3.3 บริษัทโทรศัพท์มือถือแห่งหนึ่งเสนอโปรโมชั่นให้กับลูกค้าโดยมีการคำนวณค่าธรรมเนียม
การใช้งานดังนี้
       • สองนาทีแรก คิดนาทีละห้าบาท
       • นาทีถัดมาคิดนาทีละสองบาท

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

using System;
class Cellphone {
   static void Main() {
      // Step 1: Take the number of minutes input
      Console.Write("Enter the number of minutes: ");
      int minutes = int.Parse(Console.ReadLine());

      // Step 2: Split the number of minutes into two parts,
      // the first two and the remaining
      int first, remaining;
      if (minutes > 2) {
         // Step 2.1: If the call takes more than two minutes,
         // then the first two minutes is used entirely and the
         // remaining is minutes subtracted by two
         first = 2;
         remaining = minutes - 2;
      }
      else {
         // Step 2.2: If the call takes less than 2 minutes,
         // these minutes are considered part of the first two
         first = minutes;
         remaining = 0;
      }
      // Step 3: Compute the fee based on the number of minutes
      // during the first two minutes, and the number of minutes
      // after the first two minutes
      int fee = (first*5) + (remaining*2);
      Console.WriteLine("The air time fee is {0} baht.", fee);
  }
}

ตัวอย่างผลการทำงาน

Enter the number of minutes: 1
The air time fee is 5 baht.
Enter the number of minutes: 5
The air time fee is 16 baht.



ใบความรู้ที่ 3.3 โครงสร้าง if หลายชั้น

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

if (condition1)
  statement1;
else if (condition2)
  statement2;
else if (condition3)
  statement3;
:
else
  statementN;

         จากรูปแบบด้านบน statement1 จะถูกเรียกทำงานเมื่อเงื่อนไข condition1 เป็นจริง ลอง
พิจารณา statement2 จะเห็นว่ามันถูกควบคุมด้วยเงื่อนไข condition2 และยังอยู่ภายใต้ else
ของโครงสร้าง if อันบนสุด จึงทำให้ statement2 นี้ถูกเรียกทำงานเมื่อเงื่อนไข condition2 เป็น
จริงและเงื่อนไข condition1 เป็นเท็จเท่านั้น ในทำนองเดียวกัน คำสั่ง condition3 จะถูกเรียก
ทำงานเมื่อเงื่อนไข condition1 และ condition2 ทั้งคู่เป็นเท็จ และเงื่อนไข condition3 เป็น
จริงเท่านั้น และสุดท้ายคือ statementN ซึ่งจะถูกเรียกทำงานเมื่อเงื่อนไขทั้งหมดข้างต้นเป็นเท็จ

ตัวอย่างที่ 3.4 พิจารณากระบวนการตัดเกรดนักเรียนโดยพิจารณาจากคะแนนสอบไล่ที่ได้ตามตาราง

เงื่อนไข
ระดับคะแนน
ได้คะแนนน้อยกว่า 50
F
ได้คะแนนตั้งแต่ 50 แต่น้อยกว่า 60
D
ได้คะแนนตั้งแต่ 60 แต่น้อยกว่า 70
C
ได้คะแนนตั้งแต่ 70 แต่น้อยกว่า 80
B
ได้คะแนนตั้งแต่ 80 ขึ้นไป
A

เราสามารถเขียนโปรแกรมเพื่อทำงานดังกล่าวโดยใช้โครงสร้าง if หลายชั้นดังนี้

if (point < 50)
    Console.WriteLine("Grade F");
else if (point < 60)
    Console.WriteLine("Grade D");
else if (point < 70)
    Console.WriteLine("Grade C");
else if (point < 80)
    Console.WriteLine("Grade B");
else
    Console.WriteLine("Grade A");


ใบความรู้ที่ 3.4 โครงสร้าง switch...case

ใบความรู้ที่ 3.4
โครงสร้าง switch...case

         ถึงแม้ว่าการจัดการเงื่อนไขหลาย ๆ เงื่อนไขในคราวเดียวกันจะสามารถทำได้โดยอาศัยโครงสร้าง
if แบบหลายชั้น ภาษา C# ยังได้เตรียมโครงสร้าง switch...case เพื่อใช้ในการจัดการเงื่อนไขหลาย

เงื่อนไขโดยเฉพาะ การใช้งานโครงสร้าง switch...case อยู่ในรูปแบบดังนี้

switch (expression)
{
   case constant-expression-1:
      statements;
      break;
   case constant-expression-2:
      statements;
      break;
   case constant-expression-3:
      statements;
      break;
   :
   default:
      statements;
      break;
}

            ภาษา C# ยอมให้นิพจน์ที่ใช้ในตำแหน่ง expression เป็นนิพจน์แบบจำนวนเต็ม (integer)
แบบอักขระ (char) หรือแบบข้อความ (string) เท่านั้น หลังจากที่ค่าของ expression ถูกตรวจสอบ
โปรแกรมจะกระโดดไปทำงาน ณ คำสั่ง case ที่ระบุค่าของ constant-expression ไว้ตรงกับค่า
ของ expression ที่ประเมินได้ คำสั่งต่าง ๆ ที่อยู่ถัดจากคำสั่ง case นั้น ๆ จะถูกเรียกใช้งานตามลำดับ
ไปเรื่อย ๆ จนกว่าโปรแกรมจะพบคำสั่ง break ซึ่งมีผลทำให้โปรแกรมหยุดการทำงานภายในโครงสร้าง
switch...case นั้นและกระโดดไปยังคำสั่งที่ต่อไปนอกโครงสร้าง หากไม่พบ constantexpression
ใดที่มีค่าตรงกับ expression โปรแกรมจะกระโดดไปยังจุดที่มีการระบุด้วยคำสั่ง default

ตัวอย่างที่ 3.5 โปรแกรมต่อไปนี้แสดงแต้มคะแนนตามระดับคะแนน (A,B,C,D,F) ที่ป้อนโดยผู้ใช้

ระดับคะแนน (grade)
แต้มระดับคะแนน (grade point)
A
4.0
B
3.0
C
2.0
D
1.0
F
0.0

using System;
class GradePoint {
  static void Main() {
    string grade;
    Console.Write("Please input your grade: ");
    grade = Console.ReadLine();
    switch (grade) {
      case "A" : Console.WriteLine("Your point is 4.0."); break;
      case "a" : Console.WriteLine("Your point is 4.0."); break;
      case "B" : Console.WriteLine("Your point is 3.0."); break;
      case "b" : Console.WriteLine("Your point is 3.0."); break;
      case "C" : Console.WriteLine("Your point is 2.0."); break;
      case "c" : Console.WriteLine("Your point is 2.0."); break;
      case "D" : Console.WriteLine("Your point is 1.0."); break;
      case "d" : Console.WriteLine("Your point is 1.0."); break;
      case "F" : Console.WriteLine("Your point is 0.0."); break;
      case "f" : Console.WriteLine("Your point is 0.0."); break;
      default: Console.WriteLine("Invalid input!!"); break;
    }
  }
}

ตัวอย่างผลการทำงาน

Please input your grade: A
Your point is 4.0.

Please input your grade: B
Your point is 3.0.


Please input your grade: e
Invalid input!!

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

using System;
class GradePoint {
  static void Main() {
    string grade;
    Console.Write("Please input your grade: ");
    grade = Console.ReadLine();
    switch (grade) {
      case "A" :
      case "a" : Console.WriteLine("Your point is 4.0."); break;
      case "B" :
      case "b" : Console.WriteLine("Your point is 3.0."); break;
      case "C" :
      case "c" : Console.WriteLine("Your point is 2.0."); break;
      case "D" :
      case "d" : Console.WriteLine("Your point is 1.0."); break;
      case "F" :
      case "f" : Console.WriteLine("Your point is 0.0."); break;
      default: Console.WriteLine("Invalid input!!"); break;
    }
  }
}

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

using System;
class GradePoint {
  static void Main() {
    string grade;
    double point = -1;
    Console.Write("Please input your grade: ");
    grade = Console.ReadLine();
    switch (grade) {
      case "A" : case "a" : point = 4.0; break;
      case "B" : case "b" : point = 3.0; break;
      case "C" : case "c" : point = 2.0; break;
      case "D" : case "d" : point = 1.0; break;
      case "F" : case "f" : point = 0.0; break;
      default: Console.WriteLine("Invalid input!!"); break;
    }
    if (point >= 0)
       Console.WriteLine("Your point is {0:f1}.", point);
  }
}

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

1:  using System;
2:  class Calculator {
3:     static void Main() {
4:        double n1, n2, ans = 0;
5:        char op;
6:        Console.Write("Enter the first number: ");
7:        n1 = double.Parse(Console.ReadLine());
8:        Console.Write("Enter the second number: ");
9:        n2 = double.Parse(Console.ReadLine());
10:       Console.Write("Enter the operator: ");
11:       op = char.Parse(Console.ReadLine());
12:       switch(op) {
13:         case '+': ans = n1+n2; break;
14:         case '-': ans = n1-n2; break;
15:         default: op = ' '; break;
16:       } 
17:       if (op == ' ')
18:         Console.WriteLine("Invalid operator!");
19:       else
20:         Console.WriteLine("{0}{1}{2} = {3}", n1, op, n2, ans);
21:     }
22:  }

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

ตัวอย่างผลการทำงาน

Enter the first number: 8
Enter the second number: 10
Enter the operator: +
8+10 = 18