การเขียนโปรแกรมและการใช้ C# เบื้องต้น

อัลกอริธึม (Algorithm)

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

     ที่มาของคำว่าอัลกอริธึม (Algorithm) คือ คำที่ตั้งให้เป็นเกียรติแก่ อแลน เดอะ กอริทึม ทิวริง (Alan The Gorithm Turing) ผู้ค้นพบว่าการพิสูจน์ทางคณิตศาสตร์หรือปัญหาทางตรรกะ สามารถหาคำตอบได้ด้วยชุดของขั้นตอนวิธีที่ถูกต้อง

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

     คำว่า Algorithm มีที่มาจากชื่อของนักคณิตศาสตร์ชาวเปอร์เซียในยุคศตวรรษที่ 9 อะบู อับดิลลาหฺ บิน มูซา อัลคอวาริซมีย์ (Abu Abdillah Muhammad bin Musa al-Khawarizmi) คำว่า al-Khawarizmi ได้เพี้ยนเป็น Algoritmi เมื่องานเขียนของเขาได้รับการแปลเป็นภาษาละติน แล้วกลายเป็น Algorithm อัลกอริทึม ซึ่งใช้หมายถึงกฎที่ใช้ในการคิดคำนวณเลขคณิต และได้กลายมาเป็นคำ ขั้นตอนวิธี ในช่วงศตวรรษที่ 18.

     ในปัจจุบัน คำนี้ได้มีความหมายที่กว้างขึ้น หมายรวมถึง ขั้นตอนวิธีการในการแก้ปัญหาต่างๆ ขั้นตอนวิธีแรกสำหรับคอมพิวเตอร์นั้น เขียนขึ้นในปี ค.ศ. 1842 โดย เอดา ไบรอน ใน notes on the analytical engine ทำให้ถือกันว่า เอดาเป็นนักพัฒนาโปรแกรมหรือโปรแกรมเมอร์คนแรกของโลก แต่เนื่องจาก ชาร์ลส แบบเบจ ไม่ได้สร้าง analytical engine จนเสร็จ ขั้นตอนวิธีของเอดานั้นจึงไม่ได้มีการใช้จริง      ถึงแม้ว่าขั้นตอนวิธีนั้นเป็น ขั้นตอนวิธี การแก้ปัญหา ที่ถูกระบุไว้อย่างชัดเจน แต่ก็ขาดรูปแบบการวิเคราะห์ในรูปแบบจำลองทางคณิตศาสตร์ที่ชัดเจน ปัญหาในทางขั้นตอนวิธีนี้โดยส่วนมากจึงมักจะถูกวิเคราะห์โดยใช้ เครื่องจักรทัวริง ซึ่งเป็นแบบจำลองนามธรรมของคอมพิวเตอร์ คิดค้นขึ้นโดย แอลัน ทัวริง ซึ่งเป็นเครื่องจักรที่ใช้ในการจำลองการทำงานของขั้นตอนวิธีใดๆ

     อัลกอริธึม (Algorithm) หรือขั้นตอนวิธีทางคอมพิวเตอร์ต้องมีการวัดประสิทธิภาพโดยนำความรู้ทางคณิตศาสตร์มาใช้ ดังนี้
     1. การพิสูจน์โดยการเหนี่ยวนำเชิงคณิตศาสตร์ มีหลักการคือ กล่าวถึงว่าทฤษฎีนั้นถูกต้องสำหรับค่าตัวแรกเริ่มต้นหรือค่าต่ำสุด โดยแทนค่าดังกล่าวลงในทฤษฎีเพื่อแสดงให้เห็นว่า ทฤษฎีนั้นถูกต้อง จากนั้นสมมติให้ทฤษฎีนั้นยังถูกต้องเมื่อเพิ่มค่าตัวแปรจนถึงค่าที่ n-1 แล้วจึงนำสมมติฐานนั้นมาพิสูจน์ทฤษฎี โดยการทำให้ค่าของตัวแปรเพิ่มขึ้นอีกหนึ่งจำนวน
     2. การหาผลบวกและผลคูณ
     3. ทฤษฎีตัวเลข
     4. การประมาณค่า
     5. การหาสัมประสิทธิแบบ Binomial
     ุ6. การสรุปโดยการประมาณขอบเขตบนสุด

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

      Algorithm คือ กระบวนการแก้ปัญหาที่สามารถอธิบายออกมาเป็นขั้นตอนที่ชัดเจน เมื่อนำเข้าอะไร แล้วจะต้องได้ผลลัพธ์เช่นไร กระบวนการนี้ประกอบด้วยจะประกอบด้วย วิธีการเป็นขั้นๆ และมีส่วนที่ต้องทำแบบวนซำอีก จนกระทั่งเสร็จสิ้นการทำงาน Algorithm ไม่ใช่คำตอบแต่เป็นชุดคำสั่งที่ทำให้ได้คำตอบ วิธีการในการอธิบาย Algorithm ได้แก่
     1. Natural Language อธิบายแบบใช้ภาษาที่เราสื่อสารกันทั่วไป
     2. Pseudocode อธิบายด้วยรหัสจำลองหรือรหัสเทียม
     3. Flowchart อธิบายด้วยแผนผัง การนำขั้นตอนวิธีไปใช้แก้ปัญหา ไม่จำกัดเฉพาะการเขียนโปรแกรมคอมพิวเตอร์ แต่สามารถใช้กับปัญหาอื่น ๆ ได้เช่นเดียวกัน ตัวอย่างเช่น
     ในการวางแผนการใช้ทรัพยากรทางธุรกิจขององค์กร หรือ Enterprise Resource Planning ( ERP ) เพื่อให้เกิดการใช้ทรัพยากรอย่างมีประโยชน์สูงสุด ซึ่งจำเป็นต้องวางแผนอย่างเป็นระบบ เป็นขั้นตอน จึงจำเป็นต้องอาศัย Algorithm ด้วย เพื่อให้ทราบถึงขั้นตอนต่างๆ และสามารถตัดทอนขั้นตอนที่เกินความจำเป็น อีกทั้งยังสามารถปรับปรุง และเพิ่มเติมขั้นตอนใหม่ เข้าไปได้ ช่วยลดความสับสนขณะทำงานด้วย 

ผังงาน (Flow Chart)

     ความหมายของผังงาน ผังงาน (Flowchart) คือ รูปภาพ (Image) หรือสัญลักษณ์(Symbol) ที่ใช้เขียนแทนขั้นตอน คำอธิบาย ข้อความ หรือคำพูด ที่ใช้ในอัลกอริทึม (Algorithm) เพราะการนำเสนอขั้นตอนของงานให้เข้าใจตรงกัน ระหว่างผู้เกี่ยวข้อง ด้วยคำพูด หรือข้อความ ทำได้ยากกว่าเมื่อใช้รูปภาพ หรือสัญลักษณ์

     ผังงานแบ่งได้ 2 ประเภท 
     1. ผังงานระบบ (System Flowchart) คือ ผังงานที่แสดงขั้นตอนการทำงานในระบบอย่างกว้าง ๆ แต่ไม่เจาะลงในระบบงานย่อย
     2. ผังงานโปรแกรม (Program Flowchart) คือ ผังงานที่แสดงถึงขั้นตอนในการทำงานของโปรแกรม ตั้งแต่รับข้อมูล คำนวณ จนถึงแสดงผลลัพธ์

     ประโยชน์ของผังงาน 
     1. ทำให้เข้าใจ และแยกแยะปัญหาได้ง่าย (Problem Define)
     2. แสดงลำดับการทำงาน (Step Flowing)
     3. หาข้อผิดพลาดได้ง่าย (Easy to Debug)
     4. ทำความเข้าใจโปรแกรมได้ง่าย (Easy to Read)
     5. ไม่ขึ้นกับภาษาใดภาษาหนึ่ง (Flexible Language)

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

     การโปรแกรมแบบมีโครงสร้าง หรือ การโปรแกรมโครงสร้าง ประกอบด้วย 3 อย่างนี้คือ
     - การทำงานแบบตามลำดับ(Sequence)
     - การเลือกกระทำตามเงื่อนไข(Decision) และ
     - การทำซ้ำ(Loop)

      แม้ตำราหลาย ๆ เล่มจะบอกว่า decision แยกเป็น if กับ case หรือ loop นั้นยังแยกเป็น while และ until ซึ่งแตกต่างกัน แต่ผมก็ยังนับว่าการเขียนโปรแกรม แบบมีโครงสร้างนั้น มองให้ออกแค่ 3 อย่างก็พอแล้ว และหลายท่านอาจเถียงผมว่าบางภาษาไม่จำเป็นต้องใช้ Structure Programming

     แต่เท่าที่ศึกษามา ยังไม่มีภาษาใด เลิกใช้หลักการทั้ง 3 นี้อย่างสิ้นเชิง เช่น MS Access ที่หลายคนบอกว่าง่าย ซึ่งก็อาจจะง่ายจริง ถ้าจะศึกษาเพื่อสั่งให้ทำงานตาม wizard หรือตามที่เขาออกแบบมาให้ใช้ แต่ถ้าจะนำมาใช้งานจริง ตามความต้องการของผู้ใช้แล้ว ต้องใช้ประสบการณ์ในการเขียน Structure Programming เพื่อสร้าง Module สำหรับควบคุม Object ทั้งหมดให้ทำงานประสานกัน
     1. การทำงานแบบตามลำดับ(Sequence)

     2. การเลือกกระทำตามเงื่อนไข(Decision or Selection)

     3. การทำซ้ำ(Repeation or Loop) 1. ความหมายของผังงาน

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

     ผังงาน แบ่งออกเป็น 2 ประเภท  คือ
     - ผังงานระบบ (System flowchart) และ
     - ผังงานโปรแกรม (Program flowchart)

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

     ผังงานโปรแกรม (Program flowchart) หมายถึง ผังงานที่แสดงขั้นตอนของคำสั่งการทำงานอย่างละเอียด โดยใช้สัญลักษณ์ในการเขียนผังงานเช่นเดียวกับการเขียนผังงานระบบ เป็นการวางแผนการเขียนโปรแกรมโดยผังงานโปรแกรมจะแสดงลำดับคำสั่งเป็นขั้นตอนในการปฏิบัติงานอย่างละเอียด การเขียนผังงานโปรแกรมก่อน จึงเขียนโปรแกรมตามผังงาน จะช่วยลดข้อผิดพลาดในการเขียนโปรแกรมลง ทำให้การเขียนโปรแกรมทำได้ง่ายและถูกต้องกว่าการเขียนโปรแกรมโดยไม่มีผังงาน

     สัญลักษณ์ในการเขียนผังงาน เป็นสัญลักษณ์ตามมาตรฐานของ ANSI (the ANSI flowchart symbols) ยังมีสัญลักษณ์ของผังงานอีกหลายแบบที่ช่วยในการเขียนโปรแกรมให้สะดวกขึ้น โดยเฉพาะอย่างยิ่งในระบบคอมพิวเตอร์ที่มีการเชื่อมระบบคอมพิวเตอร์เป็นเครือข่าย

     สรุป 
     • การเขียนผังงาน ( Flowchart )
     • ผังงานกับชีวิตประจำวัน
     • โครงสร้างการทำงานแบบมีการเลือก ( Selection )
     • โครงสร้างการทำงานแบบมีการทำงานซ้ำ

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

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

ภาษา Visual C# เบื้องต้น  

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

     สิ่งที่ต้องมีเพื่อที่จะให้บรรลุการเป็นโปรแกรมเมอร์ ? 
     1. ทำใจให้รักการโปรแกรม ผมพูดได้เลยว่าไม่เพียงเฉพาะการเขียนโปรแกรมเท่านั้น ถ้าคุณทำใจให้รักสิ่งใดสิ่งหนึ่งซักอย่างได้ คุณก็จะทำมันได้ดีแน่นอน
     2. อดทนอดกลั้น การโปรแกรมไม่ใช่เรื่องง่าย แต่ก็ไม่ยากเสมอไป โดยให้นึกอย่างผมว่าคนสมัยก่อนยังสร้างภาษามาให้เขียนโปรแกรมแบบนี้ได้ แล้วทำไมเราจะไม่พยายามทำให้ได้อย่างเค้าบ้างล่ะ
     3. เพียรพยายาม ขยัน แน่นอนทุกสิ่งทุกอย่างต้องหมั่นฝึกฝน ใช้มันให้บ่อยที่สุดแล้วคุณจะชำนาณไปเอง
     4. แสวงหาความรู้จากแหล่งความรู้อื่น เพื่อให้เข้าใจการโปรแกรมอย่างลึกซึ้งควรแสวงหาเพิ่มเติม เพราะไม่มีใครทุกคนหรอกที่จะเข้าใจคำพูดของคนคนเดียวไปเสียหมด ต้องออกไปแสวงหาทำความเข้าใจเอาเองเสียบ้าง แต่ก็เข้าใจ

     สำหรับมือใหม่บางคนที่ไม่มีพื้นฐาน  ก็มีเทคนิคให้
     1. ในตอนเริ่มต้นยังไม่ต้องทำความเข้าใจเกี่ยวกับที่มาของโค้ดมากนัก ให้พยายามจำรูปแบบของโค้ดเอาไว้พอ
     2. มือใหม่ห้ามยุ่งกับส่วนอื่น ให้สนใจเฉพาะ Method Main เป็นหลัก เพราะโปรแกรมจะเริ่มทำงานในส่วนนี้
     3. ขยายความจากข้อ 1 จำคำสั่งเป็นรูปแบบ เช่น
          - Console.Write() เป็นคำสั่ง
          - output Console.ReadLine() เป็นคำสั่งรับ input โดยยังไม่ต้องสนใจที่มา
     4. นำความรู้ความจำได้ในบางส่วนมาลองเขียนโปรแกรมเล่นๆดู โดยลองนึกโจทย์เอง
     5. ฝึกทำความเข้าใจจนคุ้นเคยแล้วจึงมาศึกษาที่มาจะช่วยให้เข้าใจได้เร็วยิ่งขึ้นครับ
     6. หลังเครื่องหมาย ** จะเป็นสิ่งที่สำคัญและควรจำเสมอ

     ภาษา C# (C# Programming Language) จะเขียนว่า C Sharp (ซี-ชาร์พ) ก็ได้ไม่ผิด เราๆอาจจะเคยได้ยินภาษาอื่นๆที่คล้าย C# เช่น ภาษา C, Java, C++ ซึ่งแน่นอนมันเป็นที่มาของ C# นั่นเอง (ตัว C เป็นตัวบ่งบอกให้รู้ว่า C# มีต้นกำเนิดมาจาก C นั่นเอง) เครื่องหมาย # ดังที่เคยพูดคือ เป็นสิ่งที่แสดงถึงความก้าวหน้ากว่า C++ ไปอีกระดับนึง (มอง # ให้เป็นเครื่องหมาย + ซ้อนกันสี่มุมสิครับ อาจมองแบบ C++++ ก็ได้ไม่ผิด)

     ถ้าจะให้พูดกันเข้าใจง่ายๆอีกก็คือ C# ได้รวบรวมข้อดีของภาษาต่างๆเช่น Java, Delphi, C++ เข้าไว้ด้วยกัน อีกทั้งยังมีความเรียบง่ายกว่า (ใครเคยใช้ Java จะรู้ว่ามีความคล้ายกับ C# มากที่สุด) อีกทั้งยังมีเครื่องมือดีๆ อย่าง Visual C# 2008 ของทางไมโครซอฟท์อีกด้วย จึงลดความยุ่งยากในการโปรแกรมได้มาก สามารถพัฒนาโปรแกรมระดับสูงได้ด้วย **

     ภาษา C , C++, C# จัดเป็นภาษาระดับกลาง กล่าวคือ ได้รวมเอาข้อดีจาก ภาษาระดับต่ำ และสูงเข้าไว้ด้วยกัน

 

      บิดาของภาษา C# (C# เวอร์ชั่นต่างๆทั้งหลายที่ Microsoft พัฒนา ก็มีท่านคนนี้แหละครับเป็นต้นแบบที่มั่นคงของภาษาที่ได้รับความนิยมนี้) คือ Anders Hejlsberg (แอนเดรส ฮาเยสเบิร์ก)

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

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

     อีกประการที่ควรเลือก C# ของไมโครซอร์ฟเพราะ เราสามารถมั่นใจได้ว่า ถ้าเราศึกษาตรงนี้ไปจะไม่เสียเปล่า เพราะจะมีการพัฒนาต่อไปเรื่อยๆ (ไม่ตกยุคนั่นเอง ไม่ต้องกลัวว่าไมโครซอร์ฟจะทิ้งเรา) ฟรีครับฟรี ไมโครซอร์ฟเค้าใจดีปล่อย Visual C# 2008 Express Edition ซึ่งเป็นเวอร์ชั่นสำหรับการศึกษา แม้จะขาด component และคำสั่งบางส่วนไป แต่ในระดับเริ่มต้นก็ยังไม่ต้องใช้ครับ (นอกจาก C# แล้วภาษาอื่นก็มีเช่น Basic, C++)

Variable (ตัวแปร)

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

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

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

กฏการตั้งชื่อตัวแปร
     1. ห้ามนำคำสงวน (reserved word) มาตั้งเป็นชื่อตัวแปร
     2. ต้องขึ้นต้นด้วย ตัวอักษรภาษาอังกฤษ อักขระพิเศษ @ และ _ (underscore) เท่านั้น
     3. ต้องไม่ขึ้นต้นด้วยตัวเลข เช่น 9number, 105Ages ถือว่าผิด
     4. ต้องไม่ประกอบไปด้วยอักษรพิเศษทุกชนิด (เครื่องหมาย /, +, -, *, %, !)
     5. ตัวอักษรใหญ่และเล็กจะถือว่าไม่เหมือนกัน เช่น mVar, MVAR จะถือว่าเป็นคนละตัวแปร
     6. ไม่ควรใช้ชื่อยาวเกินไป และควรตั้งให้เหมาะสมกับการนำไปใช้ เช่น ตัวแปรเก็บอายุก็ควรตั้งว่า Age เป็นต้น

 ตัวอย่างการตั้งชื่อตัวแปรที่ถูก 
       - _Number (ถูกต้องเพราะขึ้นต้นด้วย _ และประกอบไปด้วยตัวอักษร)
       - @humor123 - InputNumber (ถูกต้องเพราะขึ้นต้นด้วยตัวอักษร) ตัวอย่างการตั้งชื่อตัวแปรที่ผิด
       - 12Vat (ผิดเพราะ ขึ้นต้นด้วยตัวเลข)
       - inter-net (ผิดเพราะมีอักขระพิเศษ - )
       - case (ผิดเพราะ case เป็นคำสงวน)

 การตั้งชื่อตัวแปรในช่วงแรกๆนั้น  จะนิยมตั้ง นำหน้าด้วยตัวอักษรที่สื่อถึงชนิดของข้อมูล เช่น
         InCost (ตัวแปรเก็บค่าราคา ชนิด integer)
         Dpi (ตัวแปรเก็บค่าพาย ชนิด Double)
         bChecker (ตัวแปรเก็บค่าความจริงชนิด Boolean) เรียกการตั้งชื่อตัวแปรรูปแบบนี้ว่า "ฮันกาเรียน โนเตชั่น"

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

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

     ขนาดของหน่วยความจำที่ใช้จะขึ้นอยู่กับชนิดของตัวแปร (ชนิดของตัวแปร) (ชื่อของตัวแปร) ; // เป็นการประกาศค่าตัวแปรโดยที่ตัวแปรจะไม่มีค่าใดๆในหน่วยความจำ เช่น
     int number ; // เป็นการประกาศตัวแปร number ชนิด int (จำนวนเต็ม)

     เราสามารถประกาศตัวแปรได้หลายตัวพร้อมกัน (ชนิดของตัวแปร) (ชื่อของตัวแปร 1), (ชื่อของตัวแปร 2), (ชื่อของตัวแปร 3), ...., (ชื่อของตัวแปร n) ; เช่น
     int a,b,c,d,e ; ตัวแปรที่ได้จะเป็นชนิด int (จำนวนเต็ม) ทั้งหมด เราสามารถประกาศตัวแปรพร้อมกับใส่ค่าเริ่มต้นให้กับตัวแปรได้ (ชนิดของตัวแปร) (ชื่อของตัวแปร) = ค่าที่ของตัวแปร ; เช่น
     double pi = 3.14 ; // เป็นการประกาศค่าตัวแปร pi ชนิด double (จำนวนจริง) พร้อมกับใส่ค่าให้กับตัวแปร pi

     สำหรับการประกาศค่าของ string และ char จะมีการกำหนดค่าเริ่มต้นที่ต่างจากตัวเลขดังนี้ string text = "Oak"; // จะมีเครื่องหมาย "....." มาครอบข้อความเอาไว้
     char word = 'O'; // จะมีเครื่องหมาย '...' มาครอบข้อความเอาไว้

     การประกาศตัวแปรค่าคงที่ ( Constant ) ค่าคงที่ในโค้ดโปรแกรมมีหน้าที่เฉพาะเจาะจงในแต่ละค่า เช่น ค่า พาย ค่า e หรือค่าอะไรก็แล้วแต่ ซึ่งเมื่อเราประกาศตัวแปรค่าคงที่มาแล้วนั้น จะไม่สามารถเปลี่ยนแปลงค่าได้อีก ไม่ว่าในส่วนของโปรแกรมใดๆ

      รูปแบบการประกาศตัวแปรค่าคงที่ const (ชนิดของตัวแปรค่าคงที่) = (ค่าที่ต้องการ) ; *** การประกาศตัวแปร const จะต้องประกาศพร้อมกับใส่ค่าให้กับตัวแปร จะประกาศเพียงชื่อไม่ได้
     *** const int oak ; (ถือว่าผิด จะไม่สามารถรันโปรแกรมได้) x x x x x x const double PI = 3.14159 ; ** ส่วนใหญ่มักจะตั้งชื่อค่างคงที่ด้วยตัวอักษรใหญ่

การเขียนโปรแกรมแบบมีเงื่อนไข

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

      การควบคุมการทำงานของโปรแกรม มีอยู่ 2 แบบด้วยกัน
      1. การตัดสินใจ (Decision)
      2. การทำงานซ้ำ (Iteration) 

1. การตัดสินใจ (Decision) การทำงานตามเงื่อนไข โดยมีทางเลือกที่แน่นอน

     คำสั่ง if else

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

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

     *** Note ***
     ในส่วนของ เงื่อนไข-1 ส่วนใหญ่เราจะใช้การเปรียบเทียบเชิงตรรกะ โดยใช้ตัวดำเนินการทางตรรกะ (logical Operator) หมายความว่า ถ้าเงื่อนไข เป็นจริง ให้เข้ามาทำ คำสั่ง ; ภายใน loop ของ if เพื่อให้เข้าใจยิ่งขึ้นมาดูแผนผังการทำงาน (FlowChart) กันสักหน่อย

     จากรูป (condition = เงื่อนไข, statement = คำสั่ง) จากโฟลว์ชาร์ต โปรแกรมจะตรวจสอบเงื่อนไข (condition) เป็นอันดับแรก จากนั้น ถ้าเงื่อนไขเป็นจริง โปรแกรมจะเข้ามาทำงานในส่วนของ คำสั่ง1 (statement1) แต่ถ้า เงื่อนไขไม่เป็นจริง โปรแกรมจะกระโดดไปทำงานในส่วนของ คำสั่ง2 (statement2)

      **Note** 
      เราจะเรียก { } ว่า loop จากนั้นจะพูดถึงคำสั่ง else ซึ่งจะเป็นคำสั่งที่ตามหลัง if เสมอ (ไว้ก่อน if ไม่ได้โดยเด็ดขาด) เราจะใช้ else ในกรณีที่ต้องการเขียนคำสั่งในเงื่อนไขที่แตกต่างออกไปจาก เงื่อนไข-1 ใน if ( ให้มองเงื่อนไขเป็นแผนภาพเวนออยเลอร์ที่มีเซต A คำสั่ง else จะเปรียบดัง A' หรือ U-{A} ) แต่เงื่อนไข else จะไม่ชี้ชัดแน่นอน

      รูปแบบคำสั่ง else if ( เงื่อนไข-1 ) { คำสั่ง-1 ; } else { คำสั่ง-2 ; // สังเกตุให้ดีว่า else ไม่ต้องมีเงื่อนไขก็ได้ ซึ่งจำทำ คำสั่ง-2 ก็ต่อเมื่อ เงื่อนไข-1 เป็นเท็จ }

      ***Note****

      เมื่อคำสั่งใน loop if มีเพียงคำสั่งเดียว เรานิยมที่จะไม่ใส่ "{", "}"

     ซึ่งจากโค้ดด้านบนเราสามารถลดรูปได้ดังนี้ if ( เงื่อนไข-1 ) คำสั่ง-1 ; else คำสั่ง-2 ; เราสามารถระบุคำสั่ง if ต่อจาก else ได้เพื่อให้เกิดความชัดเจนในเงื่อนไขยิ่งขึ้น if ( เงื่อนไข-1 ) { คำสั่ง-1 ; } else if ( เงื่อนไข-2 ) { คำสั่ง-2 ; }

     แต่เมื่อมีเงื่อนไขอยู่หลายเงื่อนไขเราสามารถที่จะเขียนคำสั่ง else ไปเรื่อยๆได้ if ( เงื่อนไข-1 ) { คำสั่ง-1 ; } else if ( เงื่อนไข-2 ) { คำสั่ง-2 ; } . . . . else if ( เงื่อนไข-n ) { คำสั่ง-n ; } ซึ่งเห็นได้ว่า เราจะได้โค้ดที่ค่อนข้างยาว และไม่สวยงามกะทัดรัด  โดยถ้ามีหลายเงื่อนไข เราจะไม่นิยมใช้คำสั่ง ifelse

     ตัวอย่างของโปรแกรมที่มีการใช้ if  (โค้ดเหล่านี้ให้พิมพ์ใน เมธอด static void Main(string[]args) )

        int a = int.Parse( Console.ReadLine( ) ) ;
       int b = int.Parse( Console.ReadLine( ) ) ;
       if ( a<b )
       {
            Console.WriteLine(" {0} less than {1} ", a, b) ;
        }
        else if ( a>b )
       {
            Console.WriteLine(" {0} more than {1} ", a, b) ;
       }

 คำสั่ง switch

     คำสั่ง switch เป็นคำสั่งที่ใช้ตรวจสอบ ค่าของ object กับเงื่อนไข ซึ่งสามารถตรวจสอบเงื่อนไขได้หลายเงื่อนไขโดยจะทำการตรวจสอบทีละเงื่อนไข ซึ่งถ้าตรงกับค่าที่กำหนด (หลัง case) โปรแกรมจะทำงานในคำสั่ง หลังเครื่องหมายโครอน " : " ไปเรื่อยๆ จนกว่าจะเจอคำสั่ง break เมื่อเจอคำสั่ง break โปรแกรมจะกระโดดการทำงานไปยังส่วนสุดท้ายของคำสั่งคือ เครื่องหมายปีกกาปิด " } "

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

     เรามาดูรูปแบบคำสั่ง และ Flowchart ของ switch

     switch ( object ที่ต้องการตรวจสอบเงื่อนไข )
    {
        case เงื่อนไข-1 : คำสั่ง-1 ; break ;
        case เงื่อนไข-2 : คำสั่ง-2 ; break ;
        case เงื่อนไข-3 : คำสั่ง-3 ; break ;
        . . case เงื่อนไข-n : คำสั่ง-n ; break ;
        default : คำสั่ง-n+1 ; break ;
    }

     จากรูป (expression = objectที่เราใช้เปรียบเทียบ, condition = เงื่อนไข, statement = คำสั่ง) โปรแกรมจะนำ object หรือ expression เข้ามาตรวจสอบเงื่อนไขว่าตรงกับ ค่าที่ case ใด โดยจะค้นหาจนกว่าจะเจอ โดยถ้าเจอ (หรือได้ค่าความจริงเป็นจริง) จะกระโดดไปที่ส่วนสุดท้ายของโปรแกรม แต่ถ้าไม่เจอ (ได้ค่าความจริงเป็นเท็จ) จะทำการตรวจสอบไปเรื่อยๆ และเมื่อตรวจสอบไม่พบ จนมาถึงส่วนของ default โปรแกรมจะทำงานในคำสั่ง statementX ;

      ตัวอย่างของโปรแกรมที่มีการใช้ switch (โค้ดเหล่านี้ให้พิมพ์ใน เมธอด static void Main(string[]args) )

     Console.Write("a = ");
    int a = int.Parse( Console.ReadLine( ) ) ;
    Console.Write("b = ");
    int b = int.Parse( Console.ReadLine( ) ) ;
    Console.WriteLine( "Easy Calculator Press 1 to a+b Press 2 to a-b Press 3 to a*b" ) ;
    string c = Console.ReadLine( ) ;
    switch (c)
   {
      case "1" : Console.WriteLine(a+b) ; break ;
      case "2" : Console.WriteLine(a-b) ; break ;
      case "3" : Console.WriteLine(a*b) ; break ;
      default : Console.WriteLine( "Error" ); break ;
   }  

การเขียนโปรแกรมแบบวนซ้ำ (Itaration)

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

     คำสั่ง for

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

     จากรูป ( assignment = กำหนดค่าของจุดเริ่มต้น ส่วนนี้จะมีตัวแปรมารองรับ, condition = กำหนดค่าของจุดสิ้นสุดการวน, increment = อัตราการเพิ่มของค่า ) เริ่มต้นจาก การกำหนดค่าของจุดเริ่มต้น และเข้ามาเช็คที่ กำหนดค่าของจุดสิ้นสุดการวน ว่า เป็นจริงหรือเท็จ ถ้าจริง ให้เข้ามาใน loop ทำคำสั่ง และเมื่อทำคำสั่งเสร็จ จะเข้ามาทำในส่วนของ อัตราการเพิ่มของค่า และเพิ่มค่าขึ้นหรือลดค่าลงตามแต่จะกำหนด จากนั้นจะกลับไปเช็คในส่วนของ กำหนดค่าของจุดสิ้นสุดการวน และตรวจสอบว่าค่าของตัวแปรเดิมนั้นทำให้เงื่อนไขเป็นจริงหรือไม่ ถ้าจริงจะทำซ้ำจากที่กล่าวไปข้างต้นไปเรื่อยๆ แต่ถ้า เท็จ จะหลุดออกจาก loop ทันที

     จุดเด่นของ for คือ รู้จุดเริ่มต้น และ จุดสิ้นสุดที่แน่นอน

     for ( ตัวแปร = ค่าเริ่มต้น , [ตัวแปร] [ตัวดำเนินการเปรียบเทียบ] [ค่าคงที่] , อัตราการเพิ่มของตัวแปร )
    {
       คำสั่ง ;
     }

     หรือ รูปแบบของ for อีกแบบที่มีการประกาศตัวแปรไปเพิ่มๆกับบอกค่าเริ่มต้นของการวนรอบ

    for ( [ชนิดของตัวแปร] [ชื่อตัวแปร] = ค่าเริ่มต้น , [ตัวแปร] [ตัวดำเนินการเปรียบเทียบ] [ค่าคงที่] , อัตราการเพิ่มของตัวแปร )
   {
        คำสั่ง ;
    }

     เมื่อมีคำสั่งเดียวใน loop ของ for เราสามารถลดรูปของโค้ดได้ดังนี้

     for ( ตัวแปร = ค่าเริ่มต้น , [ตัวแปร] [ตัวดำเนินการเปรียบเทียบ] [ค่าคงที่] , อัตราการเพิ่มของตัวแปร ) คำสั่ง ;

      ***ในส่วนของ condition = ขอบเขตของการทำซ้ำ จะเป็นในรูปแบบของการเปรียบเทียบ เช่น
        x < 5 a <= 6 เป็นต้น

      ***ในส่วนของ อัตราการเพิ่มของตัวแปร จะเป็นรูปแบบของ postfix และ prefix - postfix

       รูปแบบ [ตัวแปร]++ ;
     หรือ
    [ตัวแปร]-- ;
     int a = 2 ; a++ ;
      Console.Write( a ) ; ผลลัพท์ 3 - prefix รูปแบบ ++[ตัวแปร] ;
      หรือ --
      [ตัวแปร] ; int b = 3 ; --b ; Console.Write( b ) ; ผลลัพท์ 2

       ** ความต่างของ postfix กับ prefix จะเห็นได้ชัดในส่วนของการ assign ค่า
     int c = 5 ;
     int x = ++c ;
     int y = c++ ;

      ผลลัพท์ของค่า x คือ 6 ผลลัพท์ของค่า y คือ 5 อาจกล่าวได้ว่า โปรแกรมจะอ่านจากซ้ายไปขวา ซึ่งก็คือ prefix นั้นโค้ดอ่านเจอเครื่องหมาย ++c จึงทำการบวกค่าอีก 1 แล้วจึงเก็บไว้ที่ตัวแปร x แต่ postfix เครื่องหมาย ++ อยู่หลัง c จึงทำให้โปรแกรมเก็บค่า c เดิมก่อน แล้วจึงค่อยบวก เพื่อไปใช้ในโค้ดถัดๆไป

    คำสั่ง while

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

     จากรูป (condition = เงื่อนไข , Statements1 = คำสั่ง) เมื่อโปรแกรมอ่านเจอคำสั่ง while ก็จะเริ่มตรวจสอบ เงื่อนไข(condition) ว่าเป็นจริงหรือไม่ ถ้าจริง(TRUE) ก็จะเข้ามาใน loop เพื่อทำคำสั่ง (Statements1) แล้วจะกลับไปตรวจสอบเงื่อนไขอีกครั้ง ว่ายังเป็นจริงอยู่หรื่อไม่ ซึ่งถ้าเป็นจริงก็จำทำคำสั่งใน loop ซ้ำไปเรื่อยๆ จนกว่า เงื่อนไข(condition)จะเป็นเท็จ เมื่อเป็นเท็จ โปรแกรมจะกระโดดออกมายังส่วนสุดท้ายของคำสั่ง while โดยไม่ทำคำสั่ง Statements1

     ** loop while ที่มีเงื่อนไขเป็นจริงตลอดกาลเราเรียกว่า "ลูปตลอดกาล" หรือ "Forever loops"

     while (เงื่อนไข) คำสั่ง ; while (เงื่อนไข)
     {
          คำสั่ง 1 ;
          คำสั่ง 2 ;
          คำสั่ง 3 ;
     }

     คำสั่ง do while

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

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

     จากรูป จะเห็นได้ว่าเมื่อโปรแกรมเจอคำสั่ง do while โปรแกรมก็จะทำคำสั่ง Statements ไปหนึ่งครั้งก่อน จากนั้นจึงค่อยมาตรวจสอบเงื่อนไข ซึ่งก็เป็นไปตามรูปแบบของคำสั่ง while ดังที่ได้กล่าวไปข้างต้น

     do
    {
        คำสั่ง 1 ;
        คำสั่ง 2 ; // คำสั่ง 1 , คำสั่ง 2 และ คำสั่ง3 จะถูกโปรแกรมทำก่อน 1 รอบ คำสั่ง 3 ;
    }
    while (เงื่อนไข) ;       // ห้ามลืม ; หลัง while () เด็ดขาด

       ตัวอย่างของโค้ดการทำงานซ้ำ ตัวอย่างต่อไปนี้จะเป็นโปรแกรมสูตรคูณ โดยจะแสดงผลเป็นสูตรคูณแม่ 3 (โค้ดต่อไปนี้ให้พิมพ์ในส่วนของเมธอด Main)

      รูปแบบ for

       for( int i = 1 ; i <= 12 ; i++ )
      {
           Console.WriteLine( "3 x {0} = {1} " , i, 3*i ) ;
      }

     หรือ

       int i ;
     for( i = 1 ; i <= 12 ; i++ )
     {
         Console.WriteLine( "3 x {0} = {1} " , i, 3*i ) ;
      }

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

      รูปแบบ while

         int i = 1 ;
        while( i <= 12 )
        {
               Console.WriteLine( "3 x {0} = {1} " , i, 3*i ) ; i++ ;
        }

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

    รูปแบบ do...while

       int i = 1 ; do
      {
          Console.WriteLine( "3 x {0} = {1} " , i, 3*i ) ; i++ ;
        }
       while( i <= 12 ) ;

       จริงๆไม่ต่างกับคำสั่ง while เท่าไหร่ เพียงแต่จะทำในรอบที่ 1 (i=1) โดยที่ไม่ตรวจสอบเงื่อนไขหนึ่งครั้ง แล้วจึงมาเริ่มตรวจสอบที่ i = 2

Credit : >> http://krooboo.net/programming.aspx