Basic of Csharp

1
Chapter 1 …… 1
 Basic of C# (part 1)
 History of C#
 Basic of C#(part 3)
 .Net Framework
Chapter 2 ……..4
 Hello world from C#
 Data Type of C#
 Data Type Conversation
Chapter 3 …….13
 Compile Error
 Logic Error
 Run Time Error
 Exception Handling
Chapter 4 ………25
 Function
 Value Parameter
 Reference Parameter
 Output Parameter
 Params Array
 Basic of C # (part 12)
 Selection control statement
 If ….else
 Switch
 Conditional operator(?:)
Written By SevenLamp
Chapter 5 ……….35
 Basic of C# (part 13) 2
 While
 Do-while
 For
 Foreach
 Array
Chapter 6 ……….44
 Array list Class
 Hashtable Class
 Enumeration
Chapter 7 ………51
 Instant constructor
 Private constructor
 Static constructor
Chapter 8 ………..60
 Static member
 Instant member
 Property
 Inheritance
 Polymorphism
 Data hiding
 Encapsulation
Chapter 9 ………..71
 Function Overloading Vs Function Overriding
 Graphics And Random
 Graphic Class
 Random Class 3
 Basic Window Application(part 1)
 Event
 Event2(Mouse Event)
 Automatic Moving The Ball
Chapter 10 …………85
 ADO.Net in C# (part 1)
 Question & Answer 1
Chapter 11 ………..112
 Create Your Database
 Database Replication(Synchronization)
Chapter 12 ………..148
 Basic of SQL Statement (part 1)
 Insert
 Update
 Delete
 Select
 Insert Statement
 Basic of SQL Statement(part 2)
 Update Statement
 Delete Statement
 Select Statement
Chapter 13 ………..160
 Aggregate Function List
 Basic of SQl Statement (part 6)
 Cross join
 Inner join
 Outer join
 Create Function
 Alter Function 4
 Drop Function
http://sevenlamp.wordpress.com
http://www.sevenlamp.com
Basic OF C#.Net(Our Notes For Our Youngers) 1
Chapter 1
basic of C# (part 1)
ဒီအခ်ိန္မွာ C# လို႔ ေျပာလိုက္ရင္ programming လုပ္ေနတဲ႔သူေတြ၊ programming ကိုစိတ၀
္ င္စားတဲ႔ သူေတြ
အားလံုးနီးနီး ၾကားဖူး ၊ သံုး ဖူး၊ ဖတ္ဖူး ၊ ေလ့လာဖူး ၾကမယ္လ႔ို ထင္ပါတယ္။ ကြၽန္ေတာ္အခု ဒီပိုစ့္ကို အခုမွ C#
စတင္ေလ့လာမယ္ ညီငယ္၊ညီမငယ္ ေက်ာင္းသား/သူ ေတြ အတြက္ရည္ရြယ္ျပီးေရးပါမယ္။ ညီငယ္၊
ညီမငယ္တ႔အ
ို တြက္ C# programming ေလ့လာတဲ႔ ခရီးမွာ အနည္းငယ္မွ်ေလာက္ပဲျဖစ္ျဖစ္
အေထာက္အကူရသြားေစခ်င္တ႔ဲ ရည္ရြယ္ခ်က္န႔ပ
ဲ ါ။ လံုး၀ အေျခခံကေနျပီး ကြၽန္ေတာ္ သိသေလာက္ ေရးမွာ
ျဖစ္တ႔ဲ အတြက္ မွားေတြေတြ႔ရင္လည္း ေထာက္ျပကူညီပါ၊ မရွင္းတာရွိရင္လည္း ေမးပါ၊ လိုအပ္တာရွိရင္လည္း
ကူညီလ႔ို ျဖည့္ေပးၾကပါလိ႔ု အရင္းဆံုး ေတာင္းပန္ပါတယ္။
ကြၽန္ေတာ္ဟာ professional developer တစ္ေယာက္ မဟုတ္ေသးပါဘူး။ C# အေၾကာင္းကို နည္းနည္းပါးပါး
နားလည္၊ လုပ္ဖူး တဲ႔ သူတစ္ေယာက္သာျဖစ္တ႔ဲ အတြက္၊ မွားခဲ႔တာရွိရင္ ေက်းဇူး ျပဳျပီး
ေျပာေပးျပင္ေပးၾကပါလိ႔လ
ု ည္း ေတာင္း ပန္ပါတယ္။ကြၽန္ေတာ္ အခ်ိန္ရရင္ ရသေလာက္
ပံုမွန္ေလးေရးေပးပါ့မယ္။ ဒါေၾကာင့္မ႔ို ပိုစ့္ေတြတင္တာၾကာခဲ႔ရင္၊ ေမးခြန္းမ်ားကို replyၾကာခဲ႔ရင္၊ နားလည္ျပီး
ခြင့္လႊတ္ေပးပါ(ေမးခဲ႔တာကို ရရင္ရတယ္ မရရင္မရဘူး ေသခ်ာေပါက္ ျပန္ေျဖပါ့မယ္) အားလံုးပဲ
ကူညီေပးၾကမယ္လ႔ို ေမွ်ာ္လင့္ပါတယ္။ ေက်းဇူးတင္ပါတယ္။
အရင္ဆံုး C# ဆိုတာ ဘာလဲ စေျပာရေအာင္။ ကြၽန္ေတာ္သိတာကို ေျပာမွာေနာ္။

အားလံုးမွန္ခ်င္မွလည္း မွန္လိမ့္မယ္။
ကဲ… စျပီ….။
History of C#
C# ဆိုတာ Microsoft က ထုတ္လိုက္တဲ႔ programming language တစ္ခုေပါ့။ C# ျဖစ္ေပၚလာရတဲ႔

history ကို အရင္ ေျပာၾကည့္မယ္ဗ်ာ။ programming language ေတြ အမ်ားၾကီး ရွိတဲ႔ အထဲမွာ
ေတာ္ေတာ္မ်ားမ်ား စလုပ္ဖူးတာက C , C++ ထင္ပါတယ္။ C နဲ႔ ေရးရင္ ကြၽန္ေတာ္တို႔ Graphic User
Interface ေတြ ေရးရတာ အဆင္မေျပဘူးဗ်။ နည္းနည္းပင္ပန္းတယ္။ ဒါနဲ႔ ပိုလြယ္တဲ႔ language ေတြ
ရွာလာတဲ႔ အခါ Microsoft ကထုတ္တဲ႔ Visual Basic(VB) ကိုသံုးျဖစ္လာၾကတယ္။ VBက Microsoft
က ထုတ္တဲ႔ Visual Studio လိ႔ေ
ု ခၚတဲ႔ programming language အစုအေ၀းၾကီးထဲက Language
တစ္ခုေပါ့ဗ်ာ။ အဲ့ဒီ Visual Studio ထဲမွာ VB, VC++, Visual Foxpro, စသည္ျဖင့္ဗ်ာ ေရြးခ်ယ္လို႔
ရတဲ႔ language ေတြပါပါတယ္။ VB ရဲ့ အားသာခ်က္က Design အပိုင္းမွာ ေတာ္ေတာ္ေလးကို
လြယ္တာပါပဲ။ ဒါေပမယ့္ အားနည္းခ်က္ကေတာ့ Object-Oriented Technology ကို သံုးလို႔ မရဘူး။
OOP မဟုတ္ဘူးေပါ့ဗ်ာ။ ဒီေတာ့ တကယ့္ Enterprise Application ၾကီးေတြ ေရးလို႔
အဆင္မေျပဘူးလို႔ ေျပာၾကတယ္။ VC++ နဲ႔ ေရးဖို႔ကလည္း ေတာ္ေတာ္ေလးကို ခက္တယ္လို႔
ေျပာၾကတယ္ဗ်။ (ကြၽန္ေတာ္ေတာ့ မေရးဖူးပါ)။ ဒါေၾကာင့္ ေနာက္ပိုင္းမွာ programmer ေတြက Java
လိုင္းကို ေျပာင္းၾကတယ္။ ဒီေတာ့ Microsoft က java ကို fightဖိ႔ု အၾကံထုတ္ရျပီေပါ့။
တျခားprogramming language ေတြရဲ့ အားသာခ်က္ေတြကို ၅ႏွစ္ေလာက္ေလ့လာျပီးမွ
၂၀၀၁၊၂၀၀၂ မွာ Visual Studio .NET ဆိုတာၾကီးကို ထုတ္လိုက္တယ္ဗ်။ အဲ့ဒီ Visual Studio .NET
ထဲမွာ နဂို VS ေတြထဲက ပါေနၾကျဖစ္တဲ႔ VB, VC++ စတာေတြ အျပင္ Visual J# ဆိုတာနဲ႔ Visual
C# ဆိုတဲ႔ language အသစ္ ၂ ခုကို မိတ္ဆက္ေပးလိုက္တယ္ဗ်။ java သမားေတြအတြက္ J# နဲ႔ C
သမားေတြ အတြက္ C# ဆိုပါေတာ့ဗ်ာ။ အဲ့ဒီ language ၂ ခုမွာ C# ကေတာ့ ေတာ္ေတာ္ေလးကို
ေအာင္ျမင္သြားတယ္။(ေပါက္သြားတယ္ေပါ့ဗ်ာ)။ Microsoft ကလည္း C#ကို
ေတာ္ေတာ္ညႊန္းတယ္ဗ်။ တျခားlanguage ေတြ အားလံုးရဲ့ အားသာခ်က္ေတြကို ယူထားတဲ႔
language ဆိုပဲဗ်။ VB လိုမ်ိဳး design ကို အလြယ္တကူေရးနိုင္တယ္။ Java လိုမ်ိဳး OO ရဲ့ feature
ေတြကို သံုးနိုင္တယ္။(java ထက္ေတာင္မွ OO ပိုစစ္ေသးတယ္ဆိုပဲဗ်)(ဥပမာဗ်ာ java မွာဆိုရင္
data type ေတြက keyword အဆင္မွာပဲ ရွိတယ္၊ C# မွာေတာ့ datatype ေတြကိုယ္တိုင္က
classေတြ အျဖစ္ရွိတယ္ဗ်ာ၊ class မဟုတ္တာဆိုလို႔ operator ေတြပဲ က်န္ေတာ့တယ္တဲ႔)။
ကဲ ဒါကေတာ့ C# language ေမြးဖြားလာပံုေပါ့ဗ်ာ။
.NET Framework
C# language စျပီးပါလာတဲ႔ Visual Studio .NET 2002 မွာပဲ Microsoft က .NET Framework
ဆိုတာၾကီးကိုပါ မိတ္ဆက္ေပးခဲ႔တယ္ဗ်။ အဲ့ဒီ .NET Frameworkၾကီးထဲမွာ အဓိကကေတာ့ အပိုင္း
၂ပိုင္းပါတယ္ဗ်။ Common Language Runtime (CLR) နဲ႔ Framework Class Library(FCL)
ဆိုျပီးေတာ့။
CLR က ကြၽန္ေတာ္တို႔ .NET Platform မွာ ေရးတဲ႔ ဘယ္language codeကိုမဆို Microsoft

Intermediate Language အျဖစ္ေျပာင္းေပးျပီး Run လို႔ ရေအာင္လုပ္ေပးတယ္ေပါ့ဗ်ာ။ FCL
ကေတာ့ predefined class library အစုအေ၀းၾကီးလို႔ပဲ နားလည္ထားတယ္ဗ်။ .NET Framework
အလုပ္လုပ္ပံု ေလးၾကည့္ၾကည့္ရေအာင္ဗ်ာ။
အရင္ဆံုးကြၽန္ေတာ္တို႔ Programတစ္ခုေရးလိုက္တယ္ဗ်ာ။ အဲ့ဒ ါကို source code လိ႔ု ေခၚတယ္။

source code ကို ကြၽန္ေတာ္တို႔ ကြန္ပ်ဴတာၾကီးက နားမလည္ပါဘူး။ ဒီေတာ့ ကြန္ပ်ဴတာနားလည္မယ့္
machine code အျဖစ္ကို ေျပာင္းဖို႔လိုပါတယ္။ ဒီအလုပ္ကို .NET Framework အတြင္းမွာ ရွိတဲ႔
သက္ဆိုင္ရာ Language အလိုက္ compiler ေတြက ဘာသာျပန္အလုပ္လုပ္ပါတယ္။ ဒီေနရာမွာ
သိထားရမွာက .NET Framework ကိုသံုးျပီးေရးထားတဲ႔ code ေတြကို compile လုပ္ရင္ machine
code တန္းမထြက္ပါဘူး။ .NET Framework ကပဲနားလည္နိုင္တဲ႔ MSIL လိ႔ေ
ု ခၚတဲ႔ Microsoft
Intermediate Language Code အျဖစ္ပဲထြက္ပါတယ္။ အဲ့ဒီ code ကိုမွတဖန္ CLR ထဲမွာ ရွိတဲ႔ Jet
In-time Compilier (JIT) ေလးက ထပ္ျပီး Compile လုပ္ပါတယ္။ ဒီလိုလုပ္လိုက္မွ Operating
System ကနားလည္တဲ႔ code အျဖစ္ကိုေရာက္ရွိပါတယ္။ ဆိုလိုတာကေတာ့ဗ်ာ .NET Framework
မရွိရင္ .NET program ေတြ run လိုေတာင္မရဘူးေပါ့။ ေနာက္ပိုင္း Microsoft က ထုတ္တဲ႔ OS
ေတြမွာ .NET Framework ကို build-in ထည့္ေပးပါတယ္။ ဒါမွမဟုတ္လည္း internet ကေန
framework ကို အလကားေပးပါတယ္။ Visual Studio .NET ၾကီးတစ္ခုလံုး ၀ယ္မယ္ဆိုရင္ေတာ့
ေစ်းေတာ္ေတာ္ၾကီးတယ္ၾကားတယ္ဗ်။ (ကြၽန္ေတာ္တို႔ ျမန္မာနိုင္ငံမွာေတာ့ ေပါပါတယ္ J) FCL
အေၾကာင္းေတာင္ ေမ႔ေတာ့မလို႔။ ဒီလိုဗ် Framework Class Library ဆိုတာ ကြၽန္ေတာ္တို႔ program
ထဲမွာ user monitor ေပၚ ‘hello’ ဆိုျပီး ရိုက္ထုတ္ျပခ်င္တယ္ဆိုပါေတာ့။ အဲ့ဒါကို C နဲ႔ ေရးရင္
printf(“hello”);
ဆိုျပီး ရိုက္တယ္ဗ်ာ။ အဲ့ဒီကုဒ္ထဲမွာ ေရးလိုက္တဲ႔ printf ဆိုတဲ႔ဟာေလးကို function လိ႔ေ

ု ခၚတယ္ဗ်။
အဲ့ဒီ function က ကြၽန္ေတာ္တို႔ကိုယ္တိုင္ေရးတာမဟုတ္ဘူးဗ်ာ၊ library ထဲကေနေခၚသံုးတာေပါ့။
အဲ့ဒီလို predefined function ေတြေရးျပီး သိမ္းထားတဲ႔ class အစုအေ၀းၾကီးကို Framework Class
Library လို႔ ေခၚေၾကာင္းပါဗ်ား။
ကဲ ဒီဇယားေလးကေတာ့ .NET Framework version history ပါဗ်ာ။
Version Release Visual Studio Default in Window

1.0 2002 Visual Studio .NET -
1.1 2003 Visual Studio .NET 2003 Window Server 2003
2.0 2005 Visual Studio 2005 -
3.0 2006 - Window Vista, Window Server 2008
3.5 2007 Visual Studio 2008 Window 7, Window Server 2008 RC2
4.0 Beta1 2009 Visual Studio 2010
Chapter 2
Hello World from C#
ကဲ အခုကြၽန္ေတာ္တို႔ C# programming language နဲ႔ program တစ္ခုေလာက္

စေရးၾကရေအာင္ဗ်ာ။ programming language တိုင္းရဲ့ first time program ေလး helloworld နဲ႔ပဲ
စလိုက္ရေအာင္။ C# program စေရးဖို႔အတြက္ ခင္ဗ်ားတို႔ စက္မွာ .NET Framework install
လုပ္ထားျပီးသားျဖစ္ဖို႔ေတာ့ လိုတယ္ဗ်။ Visual Studio install လုပ္ထားျပီးသားဆိုရင္ framework
ထပ္သြင္းစရာမလိုေတာ့ဘူးေနာ္။ မသြင္းရေသးဘူးဆိုရင္ေတာ့ ဒီမွာ
(http://www.microsoft.com/downloads/details.aspx?FamilyId=333325FD-AE52-4E35-
B531-508D977D32A6&displaylang=en) သြားျပီး download လုပ္ျပီးသြင္းလိုက္ဗ်ာ။ framework
သြင္းျပီးရင္ေတာ့ ကြၽန္ေတာ္တို႔ program စေရးလို႔ ရျပီ။
C# program ေတြ ေရးခ်င္တယ္ဆိုရင္ Microsoft Visual Studio(IDE) ကို သံုးျပီးေရးမွာလား။

မသံုးပဲေရးမွာလား နည္းလမ္း ၂ ခုရွိတယ္။ အခုပထမဆံုး program ကို java လို Visual Studio IDE
မသံုးပဲေရးၾကရေအာင္။ program ေရးဖို႔အတြက္ Text Editor တစ္ခုေတာ့လိုတယ္ဗ်။
ခင္ဗ်ားတို႔စက္မွာ Notepad ေတာ့ ရွိျပီးသား ျဖစ္မွာပါ။ ကဲ Notepad ဖြင့္ဗ်ာ။
window key + R ႏွိပ္ျပီး Run Box ကိုေခၚလိုက္ဗ်ာ ျပီးရင္ အဲ့ဒီ Box ထဲမွာ notepad
လို႔သာရိုက္ထည့္လိုက္၊ ဒါဆို Notepad ပြင့္လာလိမ့္မယ္။ ဟုတ္ျပီ… program စေရးရေအာင္။
ဒီအတိုင္းေရးလိုက္ဗ်ာ ျပီးမွ ျပန္ရွင္းမယ္။
class Hello
{
static void Main()
{
System.Console.Write("Hello World");
}
}
ေရးျပီးျပီေနာ္… အိုေက ျပန္ရွင္းရေအာင္။ C တိ႔ု java တိ႔လ

ု ိုပဲ C# program ေတြကလည္း Main
function ကေနစျပီး အလုပ္လုပ္တယ္ဗ်။ ဒါေပမယ့္ C# မွာေတာ့ Main ကို M အၾကီးနဲ႔
ေရးရတယ္ေနာ္။ ျပီးေတာ့ static ဆိုတဲ႔ keyword လည္းထည့္ရတယ္။ အိုေက ကြၽန္ေတာ္တို႔
ဒီအတိုင္းေရးလိုက္ျပီ static void Main() ေပါ့။ အဲ့ဒီ Main function ရဲ့ scope ကိုသက္မွတ္ဖို႔ { နဲ႔ }
ကို သံုးတယ္။ ဒါလည္း C တိ႔ု java တိ႔န
ု ဲ႔ တူတူပဲ။ အဲ့ဒီ scope ထဲမွာမွ ကြၽန္ေတာ္တို႔ computer ကို
ခိုင္းေစခ်င္တဲ႔ statement ေတြကို ေရးရမယ္။ statement တစ္ေၾကာင္း ျပီးျပီဆိုတိုင္းမွာ
semicomar(;) ပိတ္ဖို႔လည္း မေမ႔နဲ႔ဦးေနာ္။
monitor မွာ စာရိုက္ခုိင္းဖို႔ အတြက္ C# မွာ Write or WriteLine function ကို သံုးရတယ္ဗ်။ အဲ့ဒီ
Write function ကိုလည္း ဒီတိုင္းေခၚခြင့္မရွိဘူးဗ်၊ function ရွိေနတဲ႔ class name နဲ႔
တဆင့္ေခၚရတယ္။ Write function က Console class ထဲမွာ ရွိတယ္ေလ၊ ဒါေၾကာင့္ ေရးတဲ႔အခါ
Console.Write လိ႔ေ
ု ရးမွမွန္မယ္။ ဟုတ္ျပီ ဒါဆို ေရွမွာ ဘာလို႔ System ဆိုတာၾကီးပါရတာလဲ။ ဒါက
ဒီလိုရွိတယ္ဗ် အဲ့ဒီ System ဆိုတာကို Namespace လို႔ ေခၚတယ္။ Namespace ဆိုတာ class ေတြ
စုထားတဲ႔ class အစုအေ၀းၾကီး class library ေပါ့ဗ်ာ။ Console class က System namespace
ထဲမွာ ရွိတယ္။ ဒါေၾကာင့္ ကြၽန္ေတာ္တို႔က System.Console.Write လိ႔ု ေရးရတာဗ်။ ဒီလိုမ်ိဳး class
name ရဲ့ ေရွ႕မွာ ထည့္မ ေရးခ်င္ဘူး ဆိုလည္း ေနာက္တစ္နည္းရွိေသးတယ္။ class မေဆာက္ခင္မွာ
library file အေနနဲ႔ ၾကိဳျပီး ေၾကျငာေပးထားလို႔ ရတယ္။ C မွာ #include၊ java မွာ import ဆိုျပီး
ေၾကျငာသလို C# မွာလည္း using ဆိုျပီး ေၾကျငာရတယ္။ ဒီလိုမ်ိဳးဗ်ာ…
using System;
class Hello
{
static void Main()
{
Console.Write("Hello World");
}
}
ခုလို႔ class အေပၚမွာ System namespace ကို using လုပ္လိုက္ရင္။ ဒီ class အတြင္းမွာ အဲ့ဒီ
System namespace ထဲက class ေတြကို စိတ္ၾကိဳက္ေခၚသံုးလို႔ ရျပီ။ ေနာက္ထပ္ထပ္ေရးေနစရာ
မလိုေတာ့ဘူး။ မဟုတ္ရင္ Console.Write တစ္ခါရိုက္ခ်င္တိုင္း ေရွ႕မွာ System ဆိုတာၾကီးကို
ျပန္ျပန္ထည့္ေပးေနရလိမ့္မယ္။
ကဲ Main function ေရးျပီေတာ့ ျပီးေရာလားဆိုေတာ့ မျပီးေသးဘူးဗ်။ C# က OOP language ေလ။
ဒီေတာ့ ဒီfunction ကိုလည္း class တစ္ခုခုအထဲမွာပဲ ထည့္ေရးခြင့္ရွိတယ္ဗ်။ function ၾကီး ပဲ
ဒီတိုင္းေရးလို႔ မရဘူး။ ဒါေၾကာင့္ ကြၽန္ေတာ္က Hello ဆိုတဲ႔ class ထဲမွာ ထည့္ေရးလိုက္တာ။ class
name က ကိုယ္ၾကိဳက္တာေပးခြင့္ရွိပါတယ္။ java မွာလိုမ်ိဳး file name နဲ႔ class name နဲ႔ တူစရာ
မလိုဘူး။
ဒီေလာက္ဆိုရင္ အေပၚက program ထဲမွာ ေရးထားတဲ႔ coding ေတြကို နားလည္ျပီထင္တယ္ေနာ္။
အဓိကနားလည္ေစခ်င္တာကေတာ့ ဘာလုပ္ခ်င္လို႔ ဘယ္ကုဒ္ကိုေရးရတယ္ ဆိုတာကို
နားလည္ေစခ်င္တာ။ ကဲ ကြၽန္ေတာ္တို႔ ေရးလို႔ ျပီးျပီဆိုေတာ့ ဒီ source code ေတြကို သိမ္းရမယ္။

Ctrl + S ႏွိပ္ျပီး C: Drive ေအာက္မွာ ခင္ဗ်ားတို႔ ၾကိဳက္တဲ႔ နာမည္နဲ႔ သိမ္းဗ်ာ၊ အဲ file extension
ကေတာ့ (.cs) ျဖစ္ရမယ္ေနာ္။ ဥပမာ ကြၽန္ေတာ္က filename ကို Test1 လိ႔ု ေပးခ်င္တယ္ဆိုရင္
Test1.cs ဆိုျပီးေပးရမယ္။ ရတယ္ေနာ္… အိုေက အခုကြၽန္ေတာ္တို႔ ဒီ C# source file ေလးကို
compile လုပ္ျပီး run ၾကည့္ရေအာင္။ compile လုပ္ဖ႔ို အတြက္ command prompt
ထဲသြားဖို႔လိုတယ္။ ကဲ႔ Run Box ကိုေခၚျပီး cmd လိ႔ု ရိုက္လိုက္ဗ်ာ ဒါဆို command prompt
ေပၚလာမယ္။ command prompt ထဲမွာ လက္ရွိ cursor location က C: ေအာက္က document
and setting ေအာက္က login ၀င္ထားတဲ႔ username ေအာက္ကို ေရာက္ေနလိမ့္မယ္ထင္တယ္။
ဒါဆိုအဆင္မေျပဘူး ကြၽန္ေတာ္တို႔ Root Directory ေအာက္ကို ျပန္သြားရေအာင္။ CD\ ရိုက္ျပီး
Enter ေခါက္လိုက္။ ဒါဆို C: ေအာက္ကို ျပန္ေရာက္သြားျပီ။ အဲ့ဒီမွာမွ ကြၽန္ေတာ္က .NET
Framework သြင္းထားတဲ႔ location ကို ရွာရေအာင္။ ဒီေနရာမွာ ကြၽန္ေတာ္
တစ္ခုေျပာဖို႔က်န္သြားတယ္။ အေပၚပိုစ့္မွာ ေျပာခဲ႔တ႔ဲ အတိုင္း ကြၽန္ေတာ္တို႔ ေရးထားတဲ႔ source file
ေတြကို သက္ဆိုင္ရာ language ရဲ့ compilier နဲ႔ compile လုပ္ရတယ္။ C# အတြက္ေတာ့ C Sharp
Compiler (csc.exe) ေပါ့ဗ်ာ။ ဒါေၾကာင့္ csc.exe file ေလးကို ရွာမယ္ဗ်ာ။ ကဲ command prompt
ထဲမွာ ဒီလိုေလးရိုက္လိုက္ပါဦး။
dir csc.exe /s
ခဏေတာ့ ေစာင့္ရမယ့္ထင္တယ္။ ရွာလိုေတြ႔ျပီဆိုရင္ အဲ့ဒ ီ compiler ေလးရွိတဲ႔ ေနရာကို path

ေပးရမယ္ဗ ်။ ခက္တာက ကြၽန္ေတာ္က path ေပးတာကို ေမ႔ေနျပီ။ ဒါေၾကာင့္ အဲ့ဒီ compiler ရွိတဲ႔
location ကိုပဲ CD command သံုးျပီး သြားလိုက္မယ္ဗ်ာ။ ေၾသာ္ဒါနဲ႔ ခင္ဗ်ားစက္မွာ framework
version အမ်ားၾကီးရွိေနတာလဲ ျဖစ္နိုင္တယ္ေနာ္။ ၾကိဳက္တဲ႔ version ေအာက္ကို ၀င္လိုက္ဗ်ာ။ ျပီးရင္
compile လုပ္ရေအာင္။
csc.exe C:\Test1.cs
ခုလို compile လုပ္လုိက္ေတာ့ compiler က exe file ထုတ္ေပးတယ္ဗ်။ ရွာရင္ ရွာၾကည့္လိုက္ဦး။
dir Test1.exe
ေတြ႔တယ္မလားဗ် ကြၽန္ေတာ္တို႔ program ရဲ့ executable file ေလး။ အဲ့ဒီ file ေလးကို run ရင္
ရျပီေပါ့။ တခုေတာ့ မွတ္ထားဦးေနာ္၊ ဒီ exe file က .NET Framework ရွိမွ run လိ႔ု ရမွာေနာ္။ အခု
တခါတည္း run ၾကည့္ရေအာင္ဗ်ာ။ exe file ဆိုေတာ့ ဒီတိုင္း filename ရိုက္လိုက္ရံုပါပဲ။
Test1.exe or Test1
ကဲ႔ ဒါဆိုရင္ ခင္ဗ်ားတို႔ရဲ့ ပထမဆံုး C# program ရဲ့ output ကို ေတြ႔ရျပီေပါ့။
ကြၽန္ေတာ္ video training ေလးပါ တင္ေပးလိုက္တယ္။ ဒီမွာ ယူဗ်ာ။
http://ifile.it/38lwqa5
Compile လုပ္ရင္ program မွာမွားနိုင္တာေလးေတြလည္း ရွိတယ္ဗ်။
၁ – using, class, static, void အဲ့ဒါေတြကို စာလံုး အေသးနဲ႔ေရးရမယ္။
၂ – System, Console, Write, Main အဲ့ဒါေတြကိုေတာ့ အစစာလံုးကို အၾကီးနဲ႔ ေရးရမယ္။
၃ – write function အဆံုးမွာ ( ; ) ထည့္ရမယ္။
၄ – Hello World ဆိုတဲ႔ စာသားကို (“ နဲ႔ “) ထဲထည့္ေရးရမယ္။
ဒီေလာက္ဆို အားလံုး run လိ႔ု ရၾကမွာပါ။ စမ္းၾကည့္ျပီး တစ္ခုခုျပန္ေျပာၾကဗ်ာ။
data type of C#
အခု C# data type ေတြ အေၾကာင္း ဆက္ေျပာရေအာင္ဗ်ာ။ Data type ဆိုတာဘာလဲ။

ကြၽန္ေတာ္တို႔ user ေတြဆီကေန data အခ်က္အလက္ေတြကို program ထဲမွာ သိမ္းထားဖို႔အတြက္
ကြၽန္ေတာ္တို႔ computer ရဲ့ memory ေပၚမွာ ေနရာသြားယူေပးရတယ္ဗ်။ အဲ့ဒီလို ေနရာယူတာကို
Variable Declaration လုပ္တယ္လို႔ ေျပာတာေပါ့။ Variable declaration လုပ္တ႔ဲ အခါ memory
ေပၚမွာ ကိုယ္သိမ္းခ်င္တဲ႔ data ရဲ့ အမ်ိဳးအစား(data type)ကို ေၾကျငာေပးရတယ္။ Number
သိမ္းမွာလား၊ ဒါမွမဟုတ္ စာသားေတြသိမ္းမွာလား စသည္ျဖင့္ေပါ့။
C# မွာ အဓိက data type ၂ မ်ိဳးရွိတယ္ဗ်။ Value Type နဲ႔ Reference Type ဆိုျပီးေခၚတယ္ဗ်ာ။
Value Type ဆိုတာကေတာ့ memory ေပၚက ကြၽန္ေတာ္တို႔ ေၾကျငာထားတဲ႔ ေနရာမွာ value
ကိုတိုက္ရိုက္ သိမ္းထားတာဗ်ာ။ Reference Type ဆိုရင္ေတာ့ value ကို မသိမ္းထားပဲ အဲ့ဒီ value
ရွိေနတဲ႔ memory address ကိုပဲ ကြၽန္ေတာ္တို႔ရဲ့ variable ထဲမွာ သိမ္းထားတာကို ဆိုလိုတာေပါ့။
နမူနာက ဒီလိုဗ်ာ…
int num = 3;
number value data တခုသိမ္းဖို႔အတြက္ num ဆိုတဲ႔ variable တစ္ခုကို memory ေပၚမွာ
ေနရာယူလိုက္ပါတယ္။ ျပီး တခါတည္း အဲ့ဒီ ေနရာမွာ 3 ဆိုတဲ႔ value တစ္ခုကို သိမ္းလုိက္ပါတယ္။
ေၾကျငာထားတဲ႔ ေနရာထဲမွာ value သိမ္းသြားတဲ႔ အတြက္ int ဟာ value type ျဖစ္ပါတယ္။
string st = “abc”;
ဒီလိုပါပဲ abc ဆိုတ႔ဲ စာသားကို သိမ္းဖို႔အတြက္ st ဆိုတ႔ဲ variable ကို ေၾကျငာလိုက္ပါတယ္။

ဒါေပမယ့္ st ထဲကိုထည့္လိုက္တဲ႔ value ျဖစ္တ႔ဲ abc ဟာ st ထဲမွာ မရွိပါဘူး။ memory ရဲ့
တျခားတေနရာမွာ ရွိသြားပါတယ္။ အဲ့ဒီ abc ေရာက္သြားတဲ႔ ေနရာရဲ့ address ကသာလွ်င္ st
ထဲကိုေရာက္သြားပါတယ္။ ဒါေၾကာင့္ string ဟာဆိုရင္ျဖင့္ reference type ထဲမွာ ပါ၀င္ပါတယ္။
ရွင္းသြားေအာင္ ပံုေလးကိုၾကည့္ပါ…
ဒါဆိုရင္ value type နဲ႔ reference type ကို ခြဲျပီး နားလည္မယ္ထင္ပါတယ္။ ဟုတ္ျပီ ဒါဆိုရင္ value
type မွာ ဘာေတြပါလဲ ဆက္ၾကည့္ရေအာင္။
value type ထဲမွာ integral type ေတြ၊
Type Range Size

sbyte -128 to 127 Signed 8-bit
integer
byte 0 to 255 Unsigned 8-bit
integer
char U+0000 to U+ffff Unicode 16-bit
character
short -32,768 to 32,767 Signed 16-bit
integer
ushort 0 to 65,535 Unsigned 16-bit
integer
int -2,147,483,648 to 2,147,483,647 Signed 32-bit

integer
uint 0 to 4,294,967,295 Unsigned 32-bit
integer
long -9,223,372,036,854,775,808 to Signed 64-bit
9,223,372,036,854,775,807 integer
ulong 0 to 18,446,744,073,709,551,615 Unsigned 64-bit
integer
floating point typeေတြ၊
Type Approximate range Precision

float ±1.5e−45 to ±3.4e38 7 digits
double ±5.0e−324 to ±1.7e308 15-16 digits
decimal type၊
Type Approximate Range Precision

decimal ±1.0 × 10−28 to ±7.9 × 1028 28-29 significant digits
boolean data type၊ enumeration data type နဲ႔ structure data type ေတြပါ၀င္ပါတယ္။
reference type ထဲမွာေတာ့
 string type၊
 object type၊
 array data type၊
 class data type၊
 interface နဲ႔
 delegate type
ေတြပါ၀င္ပါတယ္။
variable declaration အပိုင္းမွာ ကြၽန္ေတာ္တို႔ သိဖို႔လိုတ ာတခုရွိတယ္ဗ်။ ကြၽန္ေတာ္တို႔ variable

name ေတြေၾကျငာတဲ႔ေနရာမွာ C# keywords ေတြနဲ႔ သြားျပီးတူလို႔မရဘူးဗ်။ Keywords
ဆိုတာကေတာ့ဗ်ာ compiler က နားလည္ျပီးသား စကားလံုးေတြေပါ့။ သူတို႔ကို reserved words

လို႔လဲေခၚေသးတယ္ဗ်။
keywords table
abstract event new struct

as explicit null switch
base extern object this
bool false operator throw
break finally out true
byte fixed override try
case float params typeof
catch for private uint
char foreach protected ulong
checked goto public unchecked
class if readonly unsafe
const implicit ref ushort
continue in return using
decimal int sbyte virtual
default interface sealed volatile
delegate internal short void
do is sizeof while
double lock stackalloc
else long static
enum namespace string
ဒီဇယားထဲက keyword ေတာ္ေတာ္မ်ားမ်ားကို ကြၽန္ေတာ္တို႔ သိျပီးသားျဖစ္မွာပါ။
Data Type Conversation
Data Type ေတြနဲ႔ ပတ္သက္ျပီး ေနာက္ထပ္ သိထားစရာေလးေတြ ေျပာခ်င္ေ သးတယ္ဗ်။

ကြၽန္ေတာ္တို႔ C# ထဲမွာ 3 လို႔ ရိုက္လိုက္ရင္ အဲ့ဒီ 3 ရဲ့ datatype က default အေနနဲ႔ integer type
ဗ်။ ကြၽန္ေတာ္က long အျဖစ္ေရးခ်င္တယ္ဆိုရင္ 3L လိ႔ု ေရးရမယ္။ က်န္တာေတြကို
ေအာက္မွာၾကည့္လိုက္ပါဦး။
3 => int
3L => long
3.0 or 3.0D => double
3.0F => float
3.0M => decimal
’3′ => char
“3″ => string
အေပၚမွာ ျပထားတာကိုၾကည့္မယ္ဆိုရင္ တကယ့္ value က 3 ျဖစ္ေပမယ့္ သူ႔ကို data type

အမ်ိဳးမ်ိဳးမွာ ေရးတဲ႔ပံုစံေလးပါ။
အဲ့ဒီထဲမွာ string type ကလြဲျပီး က်န္တဲ႔ type ေတြက numeric type ေတြပါ။ ဆိုလိုတာက သူတို႔ကို
ေပါင္းႏႈတ္ေျမွာက္စား လုပ္လို႔ရတယ္။ string type ကိုေတာ့ မရဘူး။
ဥပမာ
string v1 = “3″;
string v2 = “4″;
Console.Write(v1+v2);
ဆိုရင္ output က 34 ဆိုျပီး ျပေနလိမ့္မယ္ဗ်ာ။ ဆိုလိုတာကေတာ့ဗ်ာ 3 နဲ႔ 4 ကို number အေနနဲ႔

မေပါင္းပဲ string အေနနဲ႔ ေပါင္းသြားတာေပါ့ဗ်ာ။ ဒီေတာ့ ကြၽန္ေတာ္တို႔က string type အေနနဲ႔
ရွိေနတဲ႔ value ေတြကို ေပါင္းခ်င္တဲ႔ အခါမွာ numeric type အျဖစ္ကို ေျပာင္းဖို႔လိုလာျပီေပါ့။ ဒီလိုမ်ိဳး
datatype တစ္ခုကေန တစ္ခုကို ေျပာင္းဖို႔အတြက္ဆိုရင္ Data Type Conversation အေၾကာင္းကို
သိဖို႔လိုလာပါျပီ။ အဲ့ဒီလို ေျပာင္းတဲ႔ ေနရာမွာ numeric type အခ်င္းခ်င္း ေျပာင္းတာနဲ႔ numeric type
နဲ႔ string type ေျပာင္းတာ ဆိုျပီး ခြဲေျပာပါမယ္။
numeric type အခ်င္းခ်င္း ေျပာင္းမယ္ဆိုရင္ type conversation မွာ ၂ မ်ိဳးရွိပါတယ္။

အလြယ္မွတ္မယ္ဆိုရင္ေတာ့ ငယ္တဲ႔ type ကေန ၾကီးတဲ႔ type ကို ေျပာင္းတာ (Widening) နဲ႔
ၾကီးတဲ႔ type ကေန ငယ္တဲ႔ type ကို ေျပာင္းတာ (Narrowing) ဆိုျပီး ရွိတယ္ဗ်။ ဥပမာ int data
type ကေန long ကို ေျပာင္းခ်င္ရင္ widening , long ကေန int ကို ေျပာင္းခ်င္ရင္ေတာ့ narrowing
ေပါ့။
int int_var1 = 123;
long long_var1 = int_var1; // implicit conversation (widening)
long long_var2 = (long) int_var1; // explicit conversation (widening)
int int_var2 = (int) long_var1; // explicit conversation (narrowing)
*** narrowing မွာ implicit မရွိပါဘူး ***

object data type ကေန numeric type ကိုေျပာင္းမယ္ဆိုရင္….
int i = 123;
object o = i; // implicit boxing
object o = (object) i; // explicit boxing
int i = (int) o; // unboxing
string type ကေနေျပာင္းခ်င္တယ္ဆိုရင္ေတာ့ အဲ့ဒီလို type casts လုပ္လ႔ို မရေတာ့ပါဘူး။ ဒါဆိုရင္

ဘယ္လိုေျပာင္းမလဲ? Convert Function ေတြကိုသံုးျပီးေတာ့ ေျပာင္းရပါမယ္။ FCL ထဲက Convert
class ထဲမွာ data type တစ္ခုကေန တစ္ခုကို ေျပာင္းဖို႔ function ေတြရွိပါတယ္။ သက္ဆိုင္ရာ Data
type class ေတြထဲမွာလဲ ရွိပါတယ္။ အဲ့ဒီ function ေတြနဲ႔ ေျပာင္းရပါမယ္။ ေအာက္မွာ
နမူနာၾကည့္ပါ။
string st = “123″;
int i = Convert.ToInt32(st);
int i = Int32.Parse(st);
string st = Convert.ToString(i);
string st = i.ToString();
အိုေက.. ဒါဆိုရင္ C# မွာ data type ေတြ တခုကေန တခုကို ေျပာင္းတာ ေျပာင္းတက္မယ္ေနာ္။
Chapter 3
အခု ကြၽန္ေတာ္တို႔ program ေလးတခုေလာက္ ေရးၾကည့္ရေအာင္။ ကြၽန္ေတာ္က

ဘာလုပ္ခ်င္လဲဆိုရင္ user ဆီကေန number value တစ္ခုေတာင္းမယ္ဗ်ာ။ ျပီးေတာ့ အဲ့ဒီnumber ရဲ့
square တန္ဖိုးကို ျပန္ျပီး ရိုက္ထုတ္ခ်င္တယ္။ ဟုတ္ျပီေနာ္ ဒါဆို ေရးၾကည့္ရေအာင္…
အရင္ဆံုး C# မွာ Main function ကေန စေရးရမယ္ဆိုေတာ့…
static void Main()

{
}
ဆိုျပီး ေရးလိုက္မယ္ဗ်ာ။ ျပီးရင္ user ဆီကေန ေတာင္းမယ့္ number ကို memory ေပၚမွာ
ခဏသိမ္းထားဖို႔ အတြက္ ေနရာယူ(variable declare) ရမယ္။ ဒါေၾကာင့္….
int num;
ဟုတ္ျပီး ဒါဆိုရင္ integer တန္ဖိုးေတြ သိမ္းဖို႔အတြက္ ေနရာေလးရျပီး။ အခု user ကို

တန္ဖိုးတစ္ခုထည့္ေပးပါလို႔ ေျပာခ်င္တယ္။ user ကို ေျပာတယ္ဆိုတာက monitor မွာ output
ထုတ္ျပတာပဲေလ။ ဒါေၾကာင့္ ဒီလိုေလးေျပာလိုက္မယ္….
Console.Write(“Enter a number : “);
ဒါဆိုရင္ user က number တစ္ခုရိုက္ထည့္ေတ့မယ္။ အဲ့ဒီ number ကို လက္ခံဖို႔ အတြက္ C#

console application မွာ ReadLine() function ကိုသံုးရမယ္။ အဲ့ဒီ function ကလည္း Console
class ထဲမွာရွိတယ္။ ဒါေပမယ့္ အဲ့ဒီ ReadLine function က user ဘာရိုက္ထည့္ထည့္ string data
type ပဲ return ျပန္တယ္။ ဒီေတာ့ user က 3 ရိုက္ထည့္ရင္ “3” ဆိုျပီး string type ျဖစ္သြားမယ္။
ဒါဆုိရင္ ကြၽန္ေတာ္တို႔ memory ေပၚမွာေၾကျငာထားတဲ႔ integer variable ထဲကို ဒီတိုင္းတန္းျပီး

ထည့္လ႔မ
ို ရေတာ့ဘူး။ string type ကေန integer type ကို convert လုပ္ေပးရေတာ့မယ္….
string temp = Console.ReadLine();

num = Convert.ToInt32(temp);
ဒီလိုေရးလည္း ရပါတယ္။
num = Convert.ToInt32(Console.ReadLine());
ကဲ… ကြၽန္ေတာ္တို႔ရဲ့ num variable ထဲမွာ user ထည့္လိုက္တဲ႔ တန္ဖိုးေလး ေရာက္သြားပါျပီ။ အခု
user ကို square result ထုတ္ျပဖို႔ပဲက်န္ပါေတာ့တယ္…
Console.WriteLine(“Square of {0} is {1}”, num, num*num);
Result ထုတ္ျပလိုက္တဲ႔ code ေလးကို နည္းနည္းေလး ရွင္းျပပါမယ္။ Write or WriteLine function

အတြင္းမွာ parameter ၃ ခု ကြၽန္ေတာ္ေပးလိုက္ပါတယ္။ ပထမဆံုးတစ္ခု “Square of {0} is {1}”
ဆိုတာမွာ {} အတြင္းထဲမွာ ေရးတဲ႔ ဟာ၂ခုကလြဲျပီး က်န္တာေတြအားလံုးက ဒီအတိုင္းေပၚပါမယ္။
အဲ့ဒါကို format string လုိ႔ ေခၚပါတယ္။ ေနာက္က Parameter ၂ ခုကေတာ့ format string ထဲမွာ
ထည့္ေပးလိုက္ခ်င္တဲ႔ value ေတြပါ။ num က index 0 ၊ num*num က index 1 ေနရာမွာ
ရွိပါတယ္။ အဲ့ဒီ value ေတြကို format string ထဲမွာ ျပန္ေခၚဖို႔ အတြက္ {} ကိုသံုးပါတယ္။ index 0
ေနရာက value ကို ေခၚခ်င္ရင္ {0} လို႔ေခၚရပါမယ္။ ဒီအတိုင္းပဲ index 1 ေနရာက
ဟာကိုေခၚဖို႔အတြက္ေတာ့ {1} ေပါ့။ ဒါဆိုရင္ နားလည္မယ္ထင္တယ္ေနာ္။ အဲ့ဒီလို မေရးပဲ
ေနာက္တစ္မ်ိဳးလည္း ေရးလို႔ရပါေသးတယ္…
Console.WriteLine(“Square of “+num+” is “+num*num);
အခု ေနာက္ဆံုးအေနနဲ႔ user ကို program ပိတ္ဖို႔အတြက္ ဒီလိုေလး ေရးေပးလိုက္ပါမယ္…
Console.Write(“\npress enter to close…”);

Console.Read();
\n ကို ေနာက္တစ္လိုင္းဆင္းဖို႔ အတြက္သံုးျပီး။ Console.Read() ကေတာ့ user enter ေခါက္တာကို

ေစာင့္ေနေပးပါတယ္။
ဒီ ပုစာၦေလးထဲမွာ ကြၽန္ေတာ္ Convert class နဲ႔ Console class ၂ ခုကို သံုးထားပါတယ္။ ဒါေၾကာင့္
အေပၚဆံုးမွာ ဒီလိုေလးေရးေပးလိုက္တယ္….
using System;
အားလံုးစုျပီး ေရးလိုက္ေတာ့ ဒီလိုမ်ိဳး…
using System;
class Program
{
static void Main()
{
string temp; int num;
Console.Write("Enter a number : ");
temp = Console.ReadLine();
Console.WriteLine("Square of {0} is {1}", num, num * num);
Console.Write("\npress enter to close...");
Console.Read();
}
}
Output =>
Enter a number : 4
Square of 4 is 16
Press enter to close…
4 က user input ပါ။

ဒီ program ေလးကို ေရးဖို႔အတြက္ Visual Studio ထဲမွာ File->New->Project->C# language-
>Console Application ကိုေရြးပါမယ္။ ဒါဆိုရင္ class ေတြ Main function ေနရာေတြ IDE က auto
လုပ္ေပးသြားလိမ့္မယ္။ အဲ့ဒီ ထဲမွာ ရိုက္ရံုပါပဲ။ ျပီးလို႔ run မယ္ဆိုရင္ေတာ့ F5 ပါ။ အဆင္မေျပရင္
ျပန္ေျပာပါခင္ဗ်ာ။
မေန႔က Program ေလးနဲ႔ပဲ ဆက္ေျပာရေအာင္ဗ်ာ။ အဲ့ဒီprogram ေလးမွာ user ဆီကေန number

value တစ္ခုေတာင္းတယ္။ square တန္ဖိုးကို output ထုတ္ျပတယ္။ အိုေက။ ဒါကို user ကေန
သတိမထားမိပဲ number မဟုတ္တ႔ဲ တျခား character ေတြထည့္လိုက္တယ္ဆိုပါေတာ့… ကဲ

program ဘာျဖစ္သြားမလဲ?
ဒီပံုေလးထဲကလို ျဖစ္သြားမွာေပါ့ဗ်ာ….
ဒါကို error တက္သြားတယ္လ႔ို ေခၚမယ္ထင္တယ္။ ဟုတ္တယ္ဟုတ္
ကဲ… အခု ကြၽန္ေတာ္ေျပာခ်င္တာက Error ေတြအေၾကာင္းပါပဲဗ်ာ။ ကြၽန္ေတာ္တို႔ program

ေတြေရးတဲ႔အခါ error ဆိုတာေတြန႔က
ဲ မလြဲမေသြေတြ႔ၾကံဳေနရမွာပါပဲ။ အဓိကကေတာ့ error
အမ်ိဳးအစား ၃ မ်ိဳးရွိတယ္ဗ်။
1 – compile error ( grammar error, syntax error လိုလဲေခၚေသးတယ္ဗ် )
2 – logic error ( semantic error )
3 – run time error
1) Compile Error
Compile error ဘယ္အခ်ိန္မွာ ျဖစ္လည္းဆိုေတာ့ ကြၽန္ေတာ္တို႔ ေရးလိုက္တ႔ဲ source code ေတြကို

compiler က နားမလည္ေတာ့ဘူး ဆိုရင္ compile error ျဖစ္တာေပါ့။ ဥပမာအားျဖင့္ statement
အဆံုးမွာ semicolon (;) က်န္ခဲ႔တာတို႔။ Main function ကို m အေသးနဲ႔ ေရးတာတို႔ စသည့္ျဖင့္ေပါ့။
compile error က အေတြ႔အမ်ားဆံုးနဲ႔ ေျဖရွင္းရအလြယ္ဆံုး error အမ်ိဳးအစားျဖစ္တယ္ဗ်။
2) Logic Error
Logic error ဆိုတာကေတာ့ programmer ရဲ့ စဥ္းစားပံုမွားလို႔ ျဖစ္ေစ၊ careless ျဖစ္ျပီး မွား ရိုက္မိလို႔
ျဖစ္ေစ၊ program ရဲ့ output မွာ အေျဖမွန္ မထြက္ေတာ့ပဲ၊ wrong result ထြက္လာတာမ်ိဳးကို
ဆိုလိုတာပါ။ ဥပမာ..
Console.WriteLine(“Square of {0} is {1}”, num, num*num);
လို႔ ေရးရမယ့္ေနရာမွာ
Console.WriteLine(“Square of {0} is {1}”, num, num+num);
လို႔ ေရးလိုက္မိတယ္ဆိုပါစို႔။ ဒါဆိုရင္ program က compile error တက္မလား ? မတက္ဘူးေနာ္

result ေတာ့ျပမွာပဲ။ ဒါေပမယ့္ ျပတဲ႔ အေျဖက ကိုယ္လိုခ်င္တဲ႔ အေျဖထြက္မလား..
မထြက္ေတာ့ဘူးေလ။ ဟုတ္တယ္မလား။ ဒါဆိုရင္ ဒီ program မွန္တယ္လို႔ ေျပာလို႔ ရမလား။
မရပါဘူး။ ဒီလို error မ်ိဳးကို logic error လိ႔ု ေခၚပါတယ္။ logic error ေတြကို ေျဖရွင္းဖို႔
အတြက္ေတာ့ ကြၽန္ေတာ္တို႔ program ကို line by line Trace လိုက္ျပီး error ကိုရွာရပါမယ္။
3) Runtime Error
Runtime error ကေတာ့ အေပၚဆံုးမွာ ကြၽန္ေတာ္ျပထားတဲ႔ ပံုထဲက error မ်ိဳးေပါ့။ user fault
ေၾကာင့္ျဖစ္ေစ၊ ကြန္ပ်ဴတာရဲ့ အမွားေၾကာင့္ျဖစ္ေစ program မွားသြားတာမ်ိဳးေပါ့။
အျမဲတမ္းမွားမလားဆိုေတာ့ user သာ အမွန္ထည့္ရင္ မမွားဘူး ။ user ကမွားထည့္တာနဲ႔
ကြၽန္ေတာ္တို႔ program လည္း မွားသြားမယ္။ ဒါေပမယ့္ တကယ္ေကာင္းမြန္ျပည့္စံုတဲ႔ program
တစ္ခုျဖစ္ဖို႔အတြက္ ဒီလို error မ်ိဳးေတြကိုလည္း မျဖစ္ေအာင္ programmer က
စဥ္းစားေပးနိုင္ရမယ္။
Runtime error ေတြကို ေျဖရွင္းဖို႔အတြက္ေတာ့ ကြၽန္ေတာ္တို႔ Error Handling (Exception

Handling) Statement ကိုသံုးရပါမယ္။ အားလံုး သိျပီးသားျဖစ္တဲ႔ try…..catch ကိုေျပာတာပါ။
Exception Handling
Runtime error ေတြကို handle လုပ္ဖ႔အ

ို တြက္ error ျဖစ္နိုင္တဲ႔ statement ေတြကို try{ နဲ႔ }
ၾကားမွာ ေရးရပါမယ္။ ျပီးရင္ အကယ္လို႔ error ျဖစ္ခ႔သ
ဲ ည္ရွိေသာ္ အဲ့ဒ ီ error ကို
ကိုင္တြယ္ေျဖရွင္းေပမယ့္ statement ေတြကိုေတာ့ catch{ နဲ႔ } ၾကားမွာ ေရးရပါမယ္။
ဥပမာ…
try{
}
catch{
Console.WriteLine(“Invalid Input”);
num = 0;
}
String temp ထဲမွာ ရွိတဲ႔ data ကို integer အျဖစ္ေျပာင္းလို႔ ရရင္ num ထဲကို ၀င္သြားမယ္။ catch
ထဲကို မ၀င္ပဲ Program အလုပ္ဆက္လုပ္သြားမယ္။ ေျပာင္းလို႔ မရဘူးဆိုရင္ေတာ့ catch ထဲကို
၀င္လာျပီး user ကို error message ျပတယ္။ num ထဲကို zero ထည့္ျပီး program
အလုပ္ဆက္လုပ္ပါလိမ့္မယ္။ try.. catch ကိုသံုးျခင္းေၾကာင့္ ကြၽန္ေတာ္တို႔ program က
လမ္းတ၀က္မွာ ရပ္သြားတာမ်ိဳး ရွိေတာ့မွာ မဟုတ္ပါဘူး။
အခု error handling statement ကို detail ၾကည့္ရေအာင္။ အေပၚက example အတိုင္းဆိုရင္
Convert လုပ္တဲ႔ အခ်ိန္မွာ error တက္တာနဲ႔ catch ထဲက အလုပ္ေတြကို သြားျပီး လုပ္မွာပါ။ try
statement ထဲမွာ error ျဖစ္နိုင္တဲ႔ statement က တစ္ခုထဲရွိတဲ႔ အခ်ိန္မွာ သိပ္ျပီး ကိစၥမရွိပဲ error
messge ျပလို႔ရပါတယ္။ ဒါေပမယ့္ တခါတေလမွာ error ျဖစ္နိုင္တဲ႔ statement ေတြက
တစ္ခုထက္ပိုျပီးေတာ့လည္း ရွိနိုင္ပါတယ္။ error အမ်ိဳးအစားကလည္း မတူဘူးဆိုရင္ catch ထဲမွာ
user ကို error ျပတဲ႔ ေနရာမွာ detail information ျပလိ႔ု မရတဲ႔ အခက္အခဲရွိလာပါတယ္။ ဒီ
example ထဲမွာ ဆိုရင္ပဲ error ျဖစ္နိုင္တဲ႔ အေျခအေနက ၂ မ်ိဳးရွိေနပါတယ္။ number
အစားတျခားဟာထည့္လိုက္ရင္ FormatException ျဖစ္ျပီး၊ number ၾကီးပဲ ၁၅
လံုးေလာက္ရိုက္ထည့္လိုက္ရင္ OverFlowException ျဖစ္ပါတယ္။ ဒါေပမယ့္ ဘယ္exception
ပဲျဖစ္ျဖစ္ ကြၽန္ေတာ္တို႔ catch ထဲမွာ ေရးထားတဲ႔ Invalid Input ဆိုတဲ႔ message ပဲ ျပပါလိမ့္မယ္။
ဒါကို ကြၽန္ေတာ္တို႔က ပိုျပီး detail ၾကတဲ႔ message ျပခ်င္တယ္ဆိုရင္ေတာ့ Catch ေရးတဲ႔ အခါမွာ
Exception အမ်ိဳးအစားနဲ႔ parameter ခြဲျပီး လက္ခံလို႔လည္း ရပါတယ္။ ဒီလိုမ်ိဳးပါ..
try{
}
catch( FormatException ex )
{
Console.WriteLine(“Please enter number value”);
num = 0;
}
catch( OverflowException ex )
{
Console.WriteLine(“Your number is too large”);
num = 0;
}
catch
{
Console.WriteLine(“Unknown error”);
num = 0;
}
ဒါဆိုရင္ေတာ့ user ထည့္တာ number မဟုတ္ရင္ Please enter number value ဆိုျပီး ျပပါမယ္။
တန္ဖိုး အရမ္းၾကီးေနရင္ေတာ့ Your number is too large ဆိုျပီး detail ျပနိုင္ပါလိမ့္မယ္။
ကဲဒါဆိုရင္ error အမ်ိဳးအစားေတြနဲ႔ exception handling အေၾကာင္းအၾကမ္းေလးေတာ့
သိမယ္ထင္ပါတယ္။ program ေလးကို ျပန္ျပင္ေရးလုိက္ပါဦးေနာ္။
using System;
class Program
{
static void Main()
{
string temp; int num;
temp = Console.ReadLine();
try
{
}
catch (FormatException ex)
{
Console.WriteLine("Please enter number value");
num = 0;
}
catch (OverflowException ex)
{
Console.WriteLine("Your number is too large");
num = 0;
}
catch
{
Console.WriteLine("Unknown error");
num = 0;
}
Console.WriteLine("Square of {0} is {1}", num, num * num);
Console.Write("\npress enter to close...");

Console.Read();
}
}
ေနာက္ေနဆက္ၾကတာေပါ့။
အခုကြၽန္ေတာ္တို႔ C# မွာ သံုးတဲ႔ operator ေတြ အေၾကာင္းကို ဆက္ေျပာၾကရေအာင္။ အိုေက

operator ဆိုတာဘာကိုေျပာတာလဲ။ ကြၽန္ေတာ္တို႔ computer ကို ခိုင္းေစတဲ႔ statement ေတြထဲမွာ
operator ေတြကို သံုးေလ႔ ရွိၾကတယ္။ ဥပမာ number ၂ ခုကို ေပါင္းခ်င္တယ္ ဆိုရင္ ( + )
operator ကိုသံုးတယ္။ variable တခုခုထဲကို တန္ဖိုး ထည့္ေပးခ်င္တယ္ဆိုရင္ ( = ) operator
ကိုသံုးတယ္။ ဟုတ္တယ္ မလား။ ကြၽန္ေတာ္တို႔ ဒီ operator ေတြရဲ့ အလုပ္ေ တြကို သိျပီးသားပါ။ C#
ရဲ့ Operator table ေလးၾကည့္လိုက္ဦးေနာ္။
Operator category Operators
Primary x.y
f(x)
a[x]
x++
x–
new
typeof
checked
unchecked
->
Unary +
-
!
~
++x
–x
(T)x
true
false
&
sizeof
Multiplicative *
/
%
Additive +
-
Shift <<
>>
Relational and type testing <

>
<=
>=
is
as
Equality ==
!=
Logical &
|
^
Conditional &&
||
?:
Assignment =
+=
-=
*=
/=
%=
&=
|=
^=
<<=
>>=
??
Lambda =>
ကြၽန္ေတာ္ အဓိက ေျပာခ်င္တာကေတာ့ ဒီ operator ေလးေတြနဲ႔ ပတ္သက္ျပီး

သိသင့္တာေလးေတြပါ။ အရင္ဆံုး statement တစ္ခုအတြင္းမွာ operator တစ္ခုထက္ပိုျပီး
ပါလာျပီဆိုရင္ ဘယ္operator ကို အရင္ဆံုး အလုပ္လုပ္သြားမလဲ။ ဥပမာဗ်ာ ကြၽန္ေတာ္က output
20 ထြက္ခ်င္တယ္ဆိုရင္ ေအာက္က ၂ ခုမွာ ဘယ္လိုေရးမွ မွန္မလဲ။
1) Console.Write( 2+3*4 );
2) Console.Write( (2+3)*4 );
နံပါတ္ ၁ အတိုင္းဆိုရင္ output က 14 ဆိုျပီး ထြက္သြားပါလိမ့္မယ္။ ဒါဆိုရင္ေတာ့ login error
ျဖစ္ျပီေပါ့။ no 2 အတိုင္းေရးမွ ကြၽန္ေတာ္လိုခ်င္တဲ႔ output ရပါလိမ့္မယ္။ ဒီေနရာမွာ operator
ေတြရဲ႕ priority ကို သိဖို႔လိုလာပါျပီ။
Precedence Operators
Highest + – ! ~ ++x –x (T)x
*/%
+-
<< >>
< > <= >= is as
== !=
&
&&
||
Lowest = *= /= %= += -= <<= >>= &= ^= |=
operator ေတြ ၁ခုထပ္ပိုေတြ႔ရင္ Precedence အျမင့္ဆံုးကို အရင္ဆံုးလုပ္ပါတယ္

အတိုမွတ္ခ်င္ရင္ေတာ့
( )
*/
+-
ေလာက္မွတ္ထားရင္ လံုေလာက္ပါတယ္။ ( ) ကိုအရင္ဆံုးလုပ္မယ္။ ျပီးရင္ * / ။ ေနာက္ဆံုးမွ + –
ေပါ့။ ရမယ္ေနာ္။
ေနာက္တခုေျပာခ်င္တာက increment operator(++) & decrement operator(–) အေၾကာင္းပါ။
ကြၽန္ေတာ့ဆီမွာ ရွိတဲ႔ integer value တစ္ခုကို 1 တိုးခ်င္ 1 ေလွ်ာ့ခ်င္ရင္ အဲ့ဒီ့ operator ေတြ
သံုးရပါတယ္။
ဒီ statement ေလးက output ဘယ္ေလာက္ထြက္မလဲ စဥ္းစားၾကည့္ပါဦး။
int num1 = 3;
int num2 = 4;
Console.Write( num1++ + ++num2 );
output = 7 or 8 or 9 ????
increment operator ကို ေရွ႕မွာ ေရးရင္ pre incrememt ေနာက္မွာ ေရးရင္ post increment
လို႔ခြဲတယ္။ pre ဆိုရင္ အရင္လုပ္တယ္။ post ဆိုရင္ ေနာက္မွလုပ္တယ္ေပါ့။ ဒါဆိုရင္ေတာ့ output
ဘယ္ေလာက္ထြက္မလဲဆိုတာ မွန္းနိုင္ေလာက္ျပီထင္တယ္ေနာ္။ (num1++) က ေပါင္းတဲ႔ အခ်ိန္မွာ
3 ပဲရွိေသးတယ္။ (++num2) ကေတာ့ 5 ျဖစ္ေနျပီး။ ဒါေၾကာင့္ 8 ထြက္ပါတယ္။
ကဲ ေနာက္ထပ္သိထားစရာ တစ္ခုရွိေသးတယ္ဗ်။ အဲ့ဒ ါကေတာ့ operator ေတြ႔

ေပါင္း၊ႏႈတ္၊ေျမာက္၊စား လုပ္တဲ႔ အခါ datatype တူရင္ တူတဲ႔type ထြက္တယ္။ မတူဘူးဆိုရင္ေတာ့
ၾကီးတဲ႔type ထြက္ပါတယ္။ ဒါေပမယ့္ integer ထက္ေသးတဲ႔ type ေတြ ဆုိရင္ေတာ့ integer type
ထြက္ပါတယ္။
ဥပမာ…
short v1 = 3;
short v2 = 4;
short v3 = v1 + v2; // error တက္ပါလိမ့္မယ္။
int v3 = v1 + v2; // ဆိုမွ မွန္မယ္။
ဒီ program ေလး ေရးျပီး run ၾကည့္လိုက္ပါဦး။
using System;
public class Example1_6
{
static void Main()
{
int i1 = 5;
long l = i1 * 3L;
decimal d = l; // implicit conversation
int i2 = (int) d; // explicit conversation
Console.WriteLine("{0:C}\n{0:D5}\n{0:F2}\n",i2);
int i3 = i2 / 2;
int i4 = i1 + i2 * 10;
int i5 = i2++ + ++i3; // increment operator
Console.Write("press enter to close...");
Console.Read();
}
}
program ထဲက {0:C} ဆိုတာက 0 index က တန္ဖိုးကို currency format နဲ႔ ျပမယ္ေျပာတာ။
{0:D5} ဆိုတာက ေနရာ ၅ ေနရာ အျပည့္ယူျပီး ေနာက္ဆံုးကေန ျပမယ္။ စသည္ျဖင့္ေပါ့။ run
ၾကည့္လိုက္ရင္ သိသြားမွာပါ။ ဒီေန႔ေတာ့ ဒီေလာက္နဲ႔ပဲ နားလိုက္ရေအာင္ဗ်ာ။
မရွင္းတာေမးခ်င္တာေတြအားလံုး ေကာမန္႔ ေပးခဲ႔ၾကပါေနာ္။
Chapter 4
ကြၽန္ေတာ္တို႔ ဒီေန႔ C# language မွာ function ေတြ ဘယ္လိုတည္ေဆာက္မလဲ။

ဘယ္လိုေခၚသံုးမလဲ စတာေတြကို ေလ့လာရေအာင္။ Function ဆိုတာ C# language မွာမွ
မဟုတ္ပါဘူး။ ဘယ္programming language မွာမဆို ရွိပါတယ္၊ သံုးၾကပါတယ္။ function
သံုးရတယ္ ရည္ရြယ္ခ်က္ေတြေတာ့ အမ်ိဳးမ်ိဳးရွိတာေပါ့ဗ်ာ။ ဥပမာအားျဖင့္ေတာ့ ကြၽန္ေတာ္တို႔
program ရဲ့ ေနရာေတာ္ေတာ္မ်ားမ်ားမွာ သံုးဖို႔လိုအပ္နိုင္တဲ႔ code ေတြကို function
ေလးအျဖစ္ခြဲေရးထားမယ္ဆိုရင္ ကိုယ္ေ ခၚခ်င္တဲ႔ေနရာကေန လြယ္လြယ္ကူကူေခၚသံုးနိုင္မယ္။
မ်ားျပားလွတဲ႔ coding ေတြကို ရႈပ္ပြေနေအာင္မထားခ်င္တဲ႔အခါမ်ိဳးမွာလဲ function ေလးေတြ
ခြဲျပီးေရးေလ႔ရွိတာေပါ့။ function ခြဲျပီးေရးကိုေရးရမယ္ဆိုတဲ႔ သက္မွတ္ခ်က္ေတာ့ မရွိပါဘူး။
ကြၽန္ေတာ္program စေရးတုန္းကဆိုရင္ function ခြဲေရးခ်င္ေပမယ့္ ဘယ္နားကို သြားျပီး
ခြဲရမလဲဆိုတာ မစဥ္းစားနိုင္လို႔ code ေတြ အားလံုး main function ထဲမွာ ပဲ စုျပံဳျပီးေရးခဲ႔တာပါ။
ေနာက္ပိုင္း ေရးလာရင္းနဲ႔ ဘယ္လိုမ်ိဳးဆိုရင္ function ေလးေတြ ခြဲေရးသင့္တယ္ ဆိုတာ
သိလာတာပါပဲ။ အဓိကကေတာ့ program မ်ားမ်ားေရးလာရင္ အလိုလို နားလည္လာပါလိမ့္။
Function
Function တစ္ခုမွာ return type , function name and argument list ဆိုျပီး အပိုင္း ၃
ပိုင္းပါတယ္ဗ်။ ဥပမာ….
int AddTwoNumber( int p1, int p2 )

{
return p1 + p2;
}
ဒီ function ေလးမွာ int လိ႔ေ

ု ရးလုိက္တာကို return type လိ႔ေ
ု ခၚပါတယ္။ ဒီ function ေလးကို
ေခၚမယ္ဆိုရင္ integer value တစ္ခု ျပန္ထြက္လာမယ္လို႔ ေျပာတာပါ။ return value
မရွိဘူးဆိုရင္ေတာ့ void လိ႔ု ေရးေပးရပါတယ္။ မေပးလို႔ေတာ့ မရပါဘူး။ AddTwoNumber
ဆိုတာကေတာ့ function name ေပါ့။ function name ေတြ ေပးတဲ႔ေနရာမွာ space ေတြ special
char ေတြ ထည့္ေပးလို႔ မရပါဘူး။ ( ) ထဲမွာ ေရးလိုက္တဲ႔ int p1, int p2 ဆိုတာေတြက argument
ေတြပါ။ ဒီ function ကိုေခၚသံုးခ်င္ရင္ ထည့္ေပးရမယ့္ parameter ေတြပါခင္ဗ်ာ။ parameter
လက္မခံခ်င္တဲ႔ function ေတြေရးရင္ေတာ့ ( ) ထဲမွာ ဘာမွ မထည့္ပဲေရးလို႔ ရပါတယ္။
Function တခုမွာေရးတဲ႔ပံုေပၚမူတည္ျပီး function declaration, function definition နဲ႔ function

call ဆိုျပီး ခြဲျခားထားပါေသးတယ္။ အခု အေပၚမွာ ေရးလိုက္တဲ႔ function ကို function definition
လို႔ေခၚပါတယ္။ ဘာလို႔လဲဆိုေတာ့ ဒီ function ထဲမွာ ဘာအလုပ္ေတြလုပ္မယ္ဆိုတဲ႔ statement
ေတြထည့္ေရးထားလို႔ပါ။ အဲ့ဒီ function ေတြကို Interface ထဲမွာ ထည့္ေရးေတာ့မယ္ဆိုရင္ေတာ့
အခုလိုမ်ိဳး definition ေတြ ထည့္ေရးလုိ႔ မရပါဘူး။ function declaration ပဲေရးခြင့္ရွိပါတယ္။
ဒီလိုမ်ိဳးပါ….
int AddTwoNumber( int p1, int p2 );
ကြၽန္ေတာ္တို႔ေရးထားတဲ႔ function ေတြကို ျပန္ေခၚသံုးမယ္ဆိုရင္ေတာ့ အဲ့ဒါကို function call လို႔

ေခၚပါတယ္။ အေပၚက function ေလးကို ျပန္ေခၚမယ္ဆိုရင္ ဒီလိုေလး ေခၚရမွာပါ…
int res = AddTwoNumber( 3 , 4 );
note: function call ပဲျဖစ္ျဖစ္ definition ပဲျဖစ္ျဖစ္ declaration ပဲျဖစ္ျဖစ္ function လိ႔ု
ေျပာလိုက္တာနဲ႔ ( ) ပါရမယ္ဆိုတာေတာ့ အေသသာမွတ္ထားလိုက္ဗ်ာ။
function parameter Passing အေၾကာင္းကို ေနာက္တပိုစ့္မွာ ေရးေပးမယ္ဗ်ာ။
Parameter passing in C#
Parameter passing ဆိုတာဘာလဲ အရင္ေျပာျပမယ္ေနာ္၊ ကြၽန္ေတာ္တို႔ေရးထားတဲ႔ function
ေတြကိုျဖစ္ေစ၊ library ထဲမွာ ရွိျပီးသား predefined function ေတြကိုျဖစ္ေစ ေခၚသံုးေတာ့မယ္ဆိုရ င္
အဲ့ဒီ function definition မွာ ေၾကျငာထားတဲ႔ argument(parameger) ေတြကို
ထည့္ေပးဖို႔လိုအပ္ပါတယ္။ အဲ့လို function call မွာ parameter ေတြထည့္ေပးတာကို parameter
passing လိ႔ု ေခၚတာပါ။ C# မွာ parameter passing ၄ မ်ိဳးရွိပါတယ္။
1. Value Parameter
2. Reference Parameter
3. Output Parameter နဲ႔
4. Params Array တိ႔ု ျဖစ္ပါတယ္။
1) Value Passing
C# မွာ default parameter passing က value pass ပါ။ ဆိုလိုတာကေတာ့ ကြၽန္ေတာ္တ႔ို function
ထဲကို parameter ေပးလိုက္တာက actual value ကို copy တစ္ခုအေနနဲ႔ ထည့္ေပးလိုက္တာပါ။
ဒါေၾကာင့္ function အတြင္းမွာ အဲ့ဒီ value ကို ဘယ္လိုပဲ ေျပာင္းသည္ျဖစ္ေစ၊ နဂို value ေတာ့
ေျပာင္းသြားမွာ မဟုတ္ပါဘူး။ ဥပမာ..
using System;
class valuePassTest
{
static void Main()
{
int num = 10;
Console.WriteLine("before : " + num);
Inc(num);
Console.WriteLine("after : " + num);
Console.Read();
}
static void Inc(int num)
{
num = num + 1;
}
}
output
before : 10
after : 10
2) Reference Passing
ကြၽန္ေတာ္က Inc function ထဲမွာ ေျပာင္းလိုက္တဲ႔ တန္ဖိုးကို main function ထဲမွာပါ လိုက္ျပီး
ေျပာင္းခ်င္တယ္ဆိုရင္ေတာ့ reference pass လုပ္ေပးရပါမယ္။ reference pass
လုပ္ဖို႔အတြက္ဆိုရင္ ref keyword ေလးကို parameter ရဲ႕ေရွ႕မွာ ထည့္ျပီး ေရးေပးရမွာပါ။ တခ်ိဳ႕
reference data type(class, array) ေတြကို parameter ပိ႔ရ
ု င္ေတာ့ ref keyword
မထည့္ေပးလည္း ရပါတယ္။
using System;
class valuePassTest
{
static void Main()
{
int num = 10;
Console.WriteLine("before : " + num);
Inc(ref num);
Console.WriteLine("after : " + num);
Console.Read();
}
static void Inc(ref int num)
{
num = num + 1;
}
}
output
before : 10
after : 11
3) output parameter
Output parameter က reference parameter နဲ႔ ဆင္တူပါတယ္။ ဒါေပမယ့္ output parameter
ဆိုတဲ႔ အတိုင္း သူ႔ကို output return ျပန္ခ်င္တဲ႔ variable ေတြအတြက္ သံုးေလ႔ရွိပါတယ္။ function
အတြင္းမွာ out variable ထဲကတန္ဖိုးကို assign မလုပ္ေသးခင္ ယူတြက္လို႔မရပါဘူး။
using System;
class outputPassTest
{
static void Main()
{
int num = 10; int result;
Square(out result, num);
Console.WriteLine("result : " + result);
Console.Read();
}
static void Square(out int result, int num)
{
result = num * num;
}
}
output
result : 100
4) Params Array
Function call မွာ ထည့္ေပးလိုက္တဲ႔ value ေတြကို array တစ္ခုအေနနဲ႔ လက္ခံခ်င္တယ္ဆိုရင္
params keyword ကိုသံုးရပါတယ္။ example ေလးပဲ ၾကည့္လိုက္ေတာ့ေနာ္။
using System;
class paramsTest
{
static void Main()
{
Show(1, 3, 5, 7, 9);
Console.Read();
}
static void Show(params int[] arr)
{
foreach (int x in arr)
{
Console.Write(x + " ");
}
}
}
output
13579
ဒီ example ေလးမွာ ကြၽန္ေတာ္ေပးလိုက္တဲ႔ parameter 5 လံုးကို array အေနနဲ႔ လက္ခံသြားတာကို

ေတြ႔ရမွာပါ။
Selection control statement
C# program ေတြ ေရးေနတဲ႔အခါ ကိုယ္ေရးထားတဲ႔ statement ေတြကို line by line compiler

ကအလုပ္လုပ္ေပးပါတယ္။ တခါတေလ ကိုယ္ေရးထားတာေတြအားလံုး မလုပ္ေစခ်င္ပဲ အေျခအေန
တစ္ခုေပၚမူတည္ျပီး ေရြးခ်ယ္လုပ္ခိုင္းခ်င္ရင္ Condition စစ္ဖ႔လ
ို ိုလာပါျပီ။ ကြၽန္ေတာ္တ႔ို C# မွာ
condition ေတြစစ္ဖို႔အတြက္ ပံုစံ ၃မ်ိဳးေရးလို႔ရတယ္ဗ်။
if…..else
switch
conditional operator (?:)
အရင္ဆံုး ဥပမာေလး တစ္ခုန႔ဲ သူတို႔ကို ဘယ္လိုသံုးလဲ ယွဥ္ျပီး ေျပာၾကည့္မယ္ဗ်ာ။ ကြၽန္ေတာ္က

user ဆီကေန number value တစ္ခုကို လက္ခံျပီး even လား order လား ဆိုတာ စစ္တဲ႔ program
ေလးတစ္ခုေရးၾကည့္ရေအာင္။
using System;
class Program
{
static void Main()
{
int num;
Console.Write("enter number");
try
{
if (num % 2 == 0)
{
Console.WriteLine("Even");
}
else
{
Console.WriteLine("Odd");
}
}
catch
{
Console.WriteLine("Error");
}
Console.Read();
}
}
ကြၽန္ေတာ္ အနီေရာက္ကာလာနဲ႔ ေရးထားတဲ႔အပိုင္းေလးကို ျပန္ရွင္းျပပါ့မယ္။ user ထည့္လိုက္တဲ႔

တန္ဖိုးကို num ထဲမွာ သိမ္းလိုက္ပါတယ္။ အဲ့ဒီ တန္ဖိုးကို even ျဖစ္လားစစ္ဖို႔အတြက္ 2 နဲ႔
စားၾကည့္ပါတယ္။ အၾကြင္းက 0 နဲ႔ ညီေနရင္ စားလိုျပတ္တယ္ေပါ့။ ဒါဆိုရင္ စံုကိန္းျဖစ္ျပီး စားလို႔
မျပတ္ဘူးဆိုရင္ေတာ့ မကိန္းပါ။ if ေနာက္မွာ ကိုယ္စစ္ခ်င္တဲ႔ expression ကို ( နဲ႔ )
ထဲထည့္ေရးရပါတယ္။ ျပီး { } အတြင္းမွာ မွန္ရင္ လုပ္ခ်င္တဲ႔ အလုပ္ကိုေရးတယ္။ else ေနာက္က { }

ထဲမွာေတာ့ မွားရင္ လုပ္ခ်င္တဲ႔ အလုပ္ကို ေရးရပါတယ္။ အခုကြၽန္ေတာ္ေရးထားသလိုမ်ိဳး လုပ္ခ်င္တဲ႔
အလုပ္က statement တစ္ေၾကာင္းထဲဆိုရင္ { } ကို မထည့္ေပးဘူး ဆိုရင္လည္း မွန္ပါတယ္။
statement တစ္ေၾကာင္းထက္ပိုရင္ေတာ့ { } ကို မထည့္ေပးလို႔ မရပါဘူး။ if condition မွာ
မွန္ရင္လုပ္ခ်င္တာပဲ ရွိျပီး မွားရင္ လုပ္ခ်င္တာ မရွိဘူး ဆိုရင္လည္း else အပိုင္းကို ထည့္မေရးရပါဘူး။
အဲ.. မွားရင္လုပ္ခ်င္ျပီး မွန္ရင္ လုပ္ခ်င္တာ မရွိဘူးဆိုရင္ေတာ့ if ကို ျဖဳတ္ထားျပီး else ၾကီး ပဲ
ေရးလို႔ေတာ့ မရဘူးေနာ္။ အဲ့လိုလုပ္ခ်င္တယ္ဆိုရင္ေတာ့ if () ထဲမွာ not (!) ခံေပးရပါမယ္။
ကဲ.. အခု switch ကိုသံုးျပီး ေရးၾကည့္ရေအာင္။
using System;
class Program
{
static void Main()
{
int num;
try
{
switch (num % 2)
{
case 0: Console.WriteLine("Even");
break;
default: Console.WriteLine("Odd");
break;
}
}
catch
{
}
Console.Read();
}
}
switch ကိုသံုးျပီး စစ္ဖို႔အတြက္ switch ေနာက္မွာ ကိုယ္စစ္ခ်င္တဲ႔ condition တစ္ခုထည့္ေပးရတယ္။

ျပီး အဲ့ဒီ condition ကထြက္လာမယ့္ result ေတြကို case ေနာက္မွာ ေရးျပီးစစ္ရပါတယ္။ case
ေတြၾကိဳက္သေလာက္ ေရးလို႔ရပါတယ္။ case တစ္ခုစီအဆံုးမွာ break ထည့္ေပးရပါတယ္။ default

ဆိုတာကေတာ့ else သေဘာမ်ိဳးပါ။ အေပၚက case ေတြအားလံုး မွားခဲ႔ရင္လို႔ အဓိပၸါယ္ရပါတယ္။
ဒါေလးကိုပဲ conditional operator နဲ႔ ေျပာင္းစစ္ၾကည့္ရေအာင္…
using System;
class Program
{
static void Main()
{
int num;
try
{
Console.WriteLine( (num % 2 == 0) ? "Even" : "Odd" );
}
catch
{
}
Console.Read();
}
}
Conditional operator ကိုသံုးရင္ေတာ့ ( ? ) ရဲ႕ေရွမွာ ကြၽန္ေတာ္စစ္ခ်င္တဲ႔ expression

ကိုေရးရတယ္၊ ( ? ) ရဲ႕ေနာက္မွာ မွန္ရင္လုပ္ခ်င္တာေရး ( : ) ရဲ႕ေနာက္မွာေတာ့ မွားရင္
လုပ္ခ်င္တာကို ေရးရပါတယ္။
Selection statement တစ္ခုစီမွာ သူ႔ အားသာခ်က္နဲ႔ သူရွိၾကပါတယ္။ ဒီထဲမွာ

အသံုးအမ်ားဆံုးကေတာ့ အားလံုးသိၾကတဲ႔ if … else statement ပါပဲ။ condition စစ္ခ်င္တဲ႔ေနရာ
ေတာ္ေတာ္မ်ားမ်ားမွာ if – else ကိုသံုးၾကေလ႔ရွိပါတယ္။ if-else မွာ variable အခ်င္းခ်င္း
တိုက္စစ္လို႔လည္း ရပါတယ္။ တခါတေလမွာေတာ့ ကြၽန္ေတာ္တို႔မွာ စစ္စရာ အေျခအေနေတြ
အရမ္းမ်ားေနရင္ေတာ့ if-else နဲ႔စစ္ရတာ အလုပ္ရႈပ္တယ္ထင္ရင္ switch ကိုသံုးေလ႔ ရွိပါတယ္။
ဥပမာဗ်ာ.. ကြၽန္ေတာ္က user ဆီကေန ၀ ကေန ၁၀ အတြင္း number
တစ္လံုးထည့္ေပးပါလို႔ေတာင္းမယ္။ ျပီး.. user ထည့္လိုက္တ႔ဲ number ကို ျပန္စစ္မယ္ဆိုပါေတာ့။
ဒီလိုမ်ိဳးဆိုရင္ေတာ့ if-else ထက္ switch က ပိုျပီးသံုးလို႔ေကာင္းမွာပါ။ conditional operator
နဲ႔ေရးရင္ေတာ့ အရမ္းကို ရႈပ္ေထြးသြားမွာပါ။ လံုး၀ အဆင္ေျပမွာမဟုတ္ပါဘူး။
if-else
if(num == 0)
Console.WriteLine("Zero");
else if (num == 1)
Console.WriteLine("One");
else if (num == 2)
Console.WriteLine("Two");
else if (num == 3)
Console.WriteLine("Three");
else if (num == 4)
Console.WriteLine("Four");
else if (num == 5)
Console.WriteLine("Five");
else if (num == 6)
Console.WriteLine("Six");
else if (num == 7)
Console.WriteLine("Seven");
else if (num == 8 )
Console.WriteLine("Eight");
else if (num == 9)
Console.WriteLine("Nine");
else
Console.WriteLine("Greater than 9");
switch
switch(num)
{
case 0:Console.WriteLine("Zero");
break;
case 1:Console.WriteLine("One");
break;
case 2:Console.WriteLine("Two");
break;
case 3:Console.WriteLine("Three");
break;
case 4:Console.WriteLine("Four");
break;
case 5:Console.WriteLine("Five");
break;
case 6:Console.WriteLine("Six");
break;
case 7:Console.WriteLine("Seven");
break;
case 8:Console.WriteLine("Eight");
break;
case 9:Console.WriteLine("Nine");
break;
default:Console.WriteLine("Greater than 9");
break;
}
Conditional Operator
Console.WriteLine((num == 0) ? "Zero" : (num == 1) ? "One" :

(num == 2) ? "Two" : (num == 3) ? "Three" : (num == 4) ? "Four" :
(num == 5) ? "Five" : (num == 6) ? "Six" : (num == 7) ? "Seven" :
(num == 8 ) ? "Eight" : (num == 9) ? "Nine" : "Greater than 9");
Switch နဲ႔ေရးတာ အရွင္းဆံုးျဖစ္မယ္ထင္တယ္ေနာ္။ ဒါေပမယ့္ switch ရဲ႕

အားနည္းခ်က္ေတြကလည္း ေတာ္ေတာ္မ်ားတယ္ဗ်။ switch မွာ case ေနာက္မွာ constant
expression ပဲေရးခြင့္ရွိတယ္။ variable ေတြန႔စ
ဲ စ္လ႔ို မရဘူး။ ဥပမာ
int val = 0;
if(num%2==val) // this is ok
switch(num%2)
{
case val: // this is not ok ( coz : val is a variable name, not a constant )
Conditional operator ကိုေတာ့ သိပ္ရႈပ္ရႈပ္ေထြးေထြး စစ္စရာ မလိုတဲ႔ အခါမ်ိဳးမွာ သံုးတယ္။

statement တစ္ေၾကာင္းထဲမွာ condition စစ္တဲ႔ အပိုင္းကိုအျပီးအစီး ထည့္ေရးခ်င္ရင္ သံုးတာေပါ့။
ကဲ… Selection Control Statement ေကာင္းေကာင္း ေရးတက္ေလာက္ျပီ ထင္တယ္
မရွင္းတာေတြ ရွိရင္ ျပန္ေမးၾကပါ ခင္ဗ်။
Chapter 5
ဒီေန႔ ကြၽန္ေတာ္တို႔ looping ေတြ အေၾကာင္း ဆက္ရေအာင္။ looping ဆိုတာဘာလဲ….

အလုပ္တစ္ခုကို ထပ္တလဲလဲ လုပ္တာကို loop လိုေခၚတယ္။ ဥပမာဗ်ာ ကြၽန္ေတာ္က screen မွာ
လိုင္း၁လိုင္းမွာ star(*) တစ္လံုးပါတဲ လိုင္း ၁၀လိုင္းရိုက္ျပခ်င္တယ္ ဆိုပါေတာ့။ ဒါကိုေရးမယ္ဆိုရင္
Console.WriteLine(“*”); ဆိုတာကို ၁၀ခါေရးရမွာေပါ့။ ဟုတ္တယ္မလား။ ဒီလို ၁၀ခါမေရးပဲ
၁ခါပဲေရးျပီး အဲ့ဒီ statement ကိုပဲ ၁၀ၾကိမ္လုပ္ေပးပါလို႔ compiler ကိုခိုင္းခ်င္ရင္ ကြၽန္ေတာ္တို႔
looping ကိုသံုးရေတာ့မွာပါ။ C# မွာ looping ၄ မ်ိဳးရွိပါတယ္။
၁။ while
၂။ do – while
၃။ for
၄။ foreach
looping ဆိုရင္ ေတာ္ေတာ္မ်ားမ်ား သံုးၾကတာက for loop ပါ။ looping ေတြမွာ looping variable
ဆိုတာေလး မ်ားေသာအားျဖင့္ရွိၾကပါတယ္၊ ဥပမာ looping ၁၀ၾကိမ္လုပ္မယ္ဆိုရင္ လက္ရွိမွာ
ဘယ္ႏွစ္ၾကိမ္ရွိျပီလဲဆိုတာ မွတ္ေပးထားမယ့္ variable ေလးေပါ့။ looping အလုပ္လုပ္ဖို႔အတြက္
အဓိက အခ်က္ ၃ခ်က္ သိရပါမယ္။ loopng variable ေလး ဘယ္ကစျပီး အလုပ္လုပ္မလဲ ဆိုတဲ႔
start ရယ္၊ ဘယ္အခ်ိန္ထိအလုပ္လုပ္မလဲဆိုတဲ႔ stop ရယ္၊ ဘယ္လို တိုးသြားမလဲဆိုတဲ႔ step
ရယ္ေပါ့။ ဒီ၃ခ်က္ကို for looping မွာ ဒီလိုေရးပါတယ္…
for( start; stop; step )

{
statements;
}
Example:
for( int i = 1; i<=10; i++ )

{
Console.WriteLine(“*”);
start ဆိုတာ looping variable ေလး စေၾကျငာျပီး တန္ဖိုးတစ္ခုထည့္ေပးလိုက္တဲ႔

အပိုင္းျဖစ္ပါတယ္။ stop ဆိုတာကေတာ့ condition တစ္ခုျဖစ္ျပီး၊ အဲ့ဒီ condition မွာ မွန္ေနသေရႊ႕
looping က အလုပ္လုပ္ေနမွာပါ။ step အပိုင္းမွာေတာ့ looping variable ထဲကို ေျပာင္းသြားခ်င္တဲ႔
တန္ဖိုးတခုခုထည့္ေပးရပါတယ္။ အေပၚက ဥပမာမွာ looping variable ထဲထတန္ဖိုးကို
၁တိုးသြားခ်င္လို႔ i++ လိုေရးတာပါ။ တခါတေလ start အပိုင္းကို looping ရဲ႕ အေပၚမွာလည္း
ေရးတာေတြ႕ဖူးမွာပါ။ ဒီလိုပါပဲ step ကိုလည္း looping statements ေတြထဲမွာ
ထည့္ေရးလို႔ရပါတယ္။ ဒါဆိုရင္ ဒီလိုေလး ျဖစ္သြားမွာေပါ့။
start;
for( ; stop; )
{
statements;
step;
}
Example:
int i = 1;
for( ; i<=10; )
{
i++;
}
အခုေရးျပလိုက္တဲ႔ for looping ေလးကို while looping နဲ႔ ေျပာင္းေရးမယ္ဆိုရင္ေတာ့

ဒီလိုျဖစ္သြားပါမယ္။
start;
while ( stop )
{
statements;
step;
}
Example:
int i = 1;
while( i<=10 )
{
Console.Write(“*”);
i++;
}
ကဲ… အဲ့ဒီ while loop ေလးမွာပါတဲ႔ while() ေလးကို ေအာက္ကိုပို႔ျပီးေရးမယ္ ဆိုရင္ေတာ့ do-while
ေလးက ဒီလိုပံုစံပါ။
start;
do{
statements;
step;
}while( stop );
Example:
int i = 1;
do{
i++;
}while( i<=10 );
do-while looping မွာ condition စစ္တ႔ဲ အလုပ္ကို ေနာက္ဆံုးမွာ ေရးလိုက္ေတာ့ condition

မွန္သည္ျဖစ္ေစ၊ မွားသည္ျဖစ္ေစ အနည္းဆံုးတစ္ၾကိမ္ေတာ့ looping ထဲက statement ေတြကို
အလုပ္လုပ္သြားမွာပါ။ for loop နဲ႔ while loop ကေတာ့ မွားရင္ တစ္ၾကိမ္မွ အလုပ္လုပ္မွာ
မဟုတ္ပါဘူး။
တခါတေလ ကြၽန္ေတာ္တို႔ Looping ေတြထဲမွာ looping variable မပါတာမ်ိဳးလည္း ရွိပါတယ္။

looping ကို အၾကိမ္အေရအတြက္ အတိအက် မဟုတ္ပဲ looping variable မပါတဲ႔ looping မ်ိဳး သံုးဖို႔
လိုလာျပီ ဆိုရင္ေတာ့ while နဲ႔ do-while ကိုသံုးေလ့ရွိပါတယ္။ ဥပမာ.. ကြၽန္ေတာ္က user ဆီက
character တစ္လံုးလက္ခံမယ္၊ ျပီးရင္ အဲ့ဒီ character ရဲ႕ ASCII value ကိုျပန္ျပီးထုတ္ျပေပးမယ္။
ဒီအလုပ္ကိုပဲ user ၾကိဳက္သေလာက္ လုပ္နိုင္တယ္။ မလုပ္ခ်င္ေတာ့ဘူးဆိုရင္ ESC key
ႏွိပ္ျပီးထြက္ရမယ္။ ဟုတ္ျပီေနာ္ ဒီ program ေလးေရးၾကည့္ရေအာင္။
using System;
class forlooptest
{
static void Main()
{
bool stop = false;
do
{
Console.Write("Enter a char to see ASCII value of it (or) press ESC to close.");
ConsoleKeyInfo cki = Console.ReadKey();
if (cki.Key != ConsoleKey.Escape)
Console.WriteLine("\n{0} = {1}\n", cki.Key.ToString(), (int)cki.KeyChar);
else
stop = true;
} while (stop==false);
}
}
ဒီ program ေလးမွာ looping ဆက္လုပ္မလား မလုပ္ေတာ့ဘူးလား ဆိုတာကို stop ဆိုတဲ႔ boolean

variable ေလးနဲ႔ ထိန္းထားတယ္။ default value အေနနဲ႔ false ထည့္ေပးထားတယ္(program
မပိတ္ဖူးလို႔ ဆိုလိုတာေပါ့) user ဆီကေန key တစ္ခုထဲလက္ခံမယ္ဆိုရင္ Console.ReadKey()
function ကိုသံုးရတယ္။ သူက ConsoleKeyInfo ဆိုတဲ႔ structure ေလး return ျပန္တယ္။ အဲ့ဒ ီ
ConsoleKeyInfo structure ထဲမွာ Key ဆိုတ႔ဲ property က user ရိုက္လိုက္တဲ႔ ConsoleKey
အမ်ိဳးအစားျဖစ္ျပီး၊ KeyChar ကေတာ့ character ျပန္ထုတ္ေပးတယ္။ ဒါေၾကာင့္ user ရိုက္လိုက္တဲ႔
key က Escape နဲ႔ မတူဘူးဆိုရင္ user ကို output ထုတ္ျပတယ္။ တူတယ္ဆိုရင္ေတာ့ program
ပိတ္ဖို႔အတြက္ stop ထဲကို true ထည့္ေပးလိုက္တယ္။ ေနာက္ဆံုးမွ while condition မွာ stop ထဲက
တန္ဖိုးဟာ false နဲ႔ ညီလား စစ္လိုက္တယ္။ ညီရင္ looping ကို ေနာက္တစ္ေခါက္ျပန္လုပ္မယ္။
မညီဘူးဆိုရင္ program ပိတ္သြားမွာပါ။
foreach looping
foreach looping ကို collection(အစုအေ၀း) တစ္ခုအတြင္းမွာ ရွိသေလာက္ အားလံုး
လုပ္ခ်င္တယ္ဆိုရင္ သံုးေလ႔ရွိပါတယ္။ array ထဲမွာ ရွိသေလာက္လုပ္ခ်င္တယ္၊ class ထဲက
property ေတြအားလံုးလုပ္ခ်င္တယ္၊ ဒီလို အေျခအေနမ်ိဳးမွာ foreach loop ကိုသံုးပါတယ္။ ဥပမာ..
ကြၽန္ေ တာ့္ ဘေလာ့ကို လာၾကည့္တ႔ဲ သူငယ္ခ်င္းေတြ အားလံုးကို တစ္ေယာက္ laptop တစ္လံုး
လက္ေဆာင္ေပးခ်င္တယ္ ဆိုရင္ foreach ကိုသံုးျပီး ဒီလို ေရးရမွာပါ..
foreach( People p in myBlog.visitors )

{
p = “a laptop”;
}
foreach ကိုသံုးလိုက္ျခင္းအားျဖင့္ ကြၽန္ေတာ့ ဘေလာ့ကို လာၾကည့္တဲ႔သူ ဘယ္ေလာက္ရွိလဲ

ဆိုတာကို သိေနစရာ မလိုေတာ့ပါဘူး။ visitor မကုန္မခ်င္း ဒီ looping က အလုပ္လုပ္မွာပါ။ foreach
looping မွာေတာ့ start ေတြ stop ေတြ step ေတြ မလိုပါဘူး။ in keyword ရဲ႕ ေရွ႕မွာ colletion
အတြင္းမွာ ရွိတဲ႔ value ေတြရဲ႕ datatype ကိုေၾကျငာရျပီး in ရဲ႕ ေနာက္မွာေတာ့ collection name
ကိုေပးရပါတယ္။ အခု foreach ကိုသံုးျပီး program ေလးတစ္ခု ေရးၾကည့္ရေအာင္။ ကြၽန္ေတာ္က
user ဆီက စာေၾကာင္းတစ္ေၾကာင္းလက္ခံမယ္။ ျပီးရင္ အဲ့ဒီ စာေၾကာင္းထဲမွာ ရွိတဲ႔ character ေတြရဲ့
ASCII value ကို ျပန္ျပီး ျပမယ္။
using System;
class forlooptest
{
static void Main()
{
string st;
Console.Write("Enter a string : ");
st = Console.ReadLine();
foreach (char c in st)
{
Console.WriteLine("{0} = {1}", c, (int)c);
}
Console.Read();
}
}
အခု ကြၽန္ေတာ္တို႔ C# မွာ သံုးလို႔ရတဲ႔ Array ေတြအေၾကာင္း ေလ့လာရေအာင္။ C# မွာ array

အမ်ိဳးအစား ေတာ္ေတာ္စံုစံုလင္လင္ကို သံုးလို႔ရပါတယ္။ အရင္ဆံုး ကြၽန္ေတာ္တို႔ သိျပီးသား single
dimension array ေလးကေန စလိုက္ရေအာင္။ ကြၽန္ေတာ္က integer value ၅ ခုသိမ္းဖို႔အတြက္
array ေလးတစ္ခု ေဆာက္ခ်င္ရင္ ခုလိုေၾကျငာရမွာပါ။
int[ ] arr = new int[5];
ျပီးရင္ အဲ့ဒီ array ထဲကို တန္ဖိုး ၅ခု ထည့္ခ်င္တယ္ဆိုရင္ ခုလိုေရးရမယ္။
arr[0] = 2;
arr[1] = 4;
arr[2] = 6;
arr[3] = 8;
arr[4] = 0;
ေနာက္တစ္နည္းအားျဖင့္ array ေၾကျငာေနတုန္းမွာ တန္းဖိုးကိုပါ ထည့္ေပးလိုက္ခ်င္တယ္ဆိုရင္

လည္းရပါတယ္။ အဲ့ဒါကို array initialization လိ႔ေ
ု ခၚပါတယ္။ ဒီလိုမ်ိဳးပါ….
int[ ] arr = new int[ ] { 2, 4, 6, 8, 0 };
အခုလိုမ်ိဳး statement တစ္ေၾကာင္းထဲမွာ array declaration ေရာ initialization ပါ

ေပါင္းလုပ္မယ္ဆိုရင္ ေနာက္တစ္မ်ိဳးက ဒီလိုလည္း ေရးလို႔ ရပါတယ္…
int[ ] arr = { 2, 4, 6, 8, 0 };
ဒါေပမယ့္ statement ၂ ေၾကာင္းခြဲေရးမယ္ဆိုရင္ေတာ့ new int[ ] ဆိုတဲ႔ အပိုင္းေလးကို မထည့္လို႔

မရပါဘူး။
int[ ] arr; // declaration statement

arr = new int[ ] { 2, 4, 6, 8, 0 };// initialization statement
example ေလး တစ္ခုေလာက္ ေရးၾကည့္ရေအာင္..
using System;
class forlooptest
{
static void Main()
{
int[] arr1 = { 1, 3, 5, 7, 9 };
int[] arr2 = { 2, 4, 6, 8, 0 };
int[] arr3 = new int[5];
for (int i = 0; i < arr1.Length; i++)
{
arr3[i] = arr1[i] + arr2[i];
}
Console.Write("Result array : ");
foreach (int v in arr3)
Console.Write(v + " ");
Console.Read();
}
}
multi-dimension array ဆိုတာကေတာ့ dimension တစ္ခုထက္ပိုပါတဲ႔ array လို႔ ဆိုလိုတာေပါ့ ။

dimension တစ္ခုစီကို ( , ) ေလးနဲ႔ ခံျပီးေရးေပးရပါတယ္။
int[,] arr = new int[3,2];
အခု ေၾကျငာလိုက္တဲ႔ array ေလးမွာ dimension ၂ ခုပါျပီး၊ ပထမ dimension မွာ ၃ ခန္း၊ ဒုတိယ
dimension မွာ ၂ ခန္း၊ ယူသြားပါမယ္။
တန္ဖိုးထည့္မယ္ဆိုရင္…
arr[0,0] = 1;
arr[0,1] = 2;
arr[1,0] = 3;
arr[1,1] = 4;
arr[2,0] = 5;
arr[2,1] = 6;
multidimensional array ေတြကိုလည္း initialize လုပ္လ႔ရ

ို ပါတယ္။ ဒီလိုမ်ိဳးပါ…
int[,] arr = { {1,2} , {3,4} , {5,6} } ;
multidimensional array ေတြကို looping ပတ္မယ္ဆိုရင္ေတာ့ dimension

အေရအတြက္ေပၚမူတည္ျပီး loopingေတြ ေရးရမွာပါ။
for (int i = 0; i <= arr.GetUpperBound(0); i++)

{
for (int j = 0; j <= arr.GetUpperBound(1); j++)
Console.Write(arr[i, j]+" ");
Console.WriteLine();
}
GetUpperBound function ေလးက demension တစ္ခုရဲ႕ upperbound တန္ဖိုးကို return

ျပန္ပါတယ္။ ဒါေၾကာင့္ ကိုယ္သိခ်င္တဲ႔ dimension index ေလးကို parameter ထည့္ေပးရပါတယ္။
အခုကြၽန္ေတာ္တို႔ matrix 2 ခု ေျမွာက္တဲ႔ program ေလး ေရးၾကည့္ရေအာင္။ နည္းနည္းေတာ့
ရွည္ျပီး ႐ႈပ္မယ္ထင္တယ္
using System;
class Program
{
static int GetInteger()
{
try
{
return Convert.ToInt32(Console.ReadLine());
}
catch
{
return 1;
}
}
static void Main(string[] args)
{
int r1, r2, c1, c2;
int[,] matrix1;
int[,] matrix2;
int[,] matrix3;
Console.WriteLine("First Matrix\n************");
Console.Write("row : ");
r1 = GetInteger();
Console.Write("col : ");
c1 = GetInteger();
matrix1 = new int[r1, c1];
Console.WriteLine("Second Matrix\n************");
Console.Write("row : ");
r2 = GetInteger();
Console.Write("col : ");
c2 = GetInteger();
if (!((r1 == 1 && c1 == 1) || (r2 == 1 && c2 == 1) || (c1 == r2)))

{
Console.WriteLine("\nOut of result!");
Console.Read();
return;
}
for (int i = 0; i <= matrix1.GetUpperBound(0); i++)
{
for (int j = 0; j <= matrix1.GetUpperBound(1); j++)
{
Console.Write("Enter value for first matrix : row {0}, column {1} : ", i, j);
matrix1[i, j] = GetInteger();
}
}
{
{
Console.Write("Enter value for second matrix : row {0}, column {1} : ", i, j);
matrix2[i, j] = GetInteger();
}
}
if (c1 != r2)
{
if (r1 == 1 && c1 == 1)
{
matrix3[i, j] = matrix2[i, j] * matrix1[0, 0];
}
else
{
matrix3[i, j] = matrix1[i, j] * matrix2[0, 0];
}
}
else
{
{
{
for (int k = 0; k <= matrix2.GetUpperBound(1); k++)
matrix3[j, k] += matrix1[j, i] * matrix2[i, k];
}
}
}
Console.WriteLine("\nResult Matrix\n*************");
{
{
Console.Write(matrix3[i, j] + " ");
}
}
Console.Read();
}
}
Chapter 6
ကြၽန္ေတာ္တို႔ array ေတြ ေၾကျငာတဲ႔ အခါမွာ integer array ေၾကျငာရင္ integer ပဲ သိမ္းလို႔
ရပါမယ္။ string array ဆိုရင္လည္း string ေတြပဲ သိမ္းမွာေပါ့။ ဒီလိုမဟုတ္ပဲ ကိုယ္ၾကိဳက္တဲ႔ data
type ကို သိမ္းလို႔ ရခ်င္ရင္ေတာ့ object array ေဆာက္ေ ပးရပါတယ္။
object[] arr = new object[3];

arr[0] = 1;
arr[1] = 2.2;
arr[2] = "abcdefg";
အခုထိ ကြၽန္ေတာ္တို႔ သံုးခဲ႔တဲ႔ array ေတြရဲ႕ size ဟာ static size ျဖစ္ပါတယ္။ ကြၽန္ေတာ္တို႔ array
ကို ၃ ခန္းေၾကျငာလိုက္ရင္ ၃ ခန္းထက္ပိုျပီး တန္ဖိုးထည့္လို႔ မရပါဘူး။ ကြၽန္ေတာ္တို႔ သံုးမယ့္ array
ရဲ႕ size ကို dynamic size အျဖစ္သံုးခ်င္တယ္ ဆိုရင္ေတာ့ သီးျခားအေနနဲ႔ collection class ေတြကို
သံုးၾကရမွာပါ။ ပထမဆံုးအေနနဲ႔ ArrayList Class အေၾကာင္း စေျပာပါ့မယ္။
ArrayList Class က array တစ္ခုလိုမ်ိဳး အလုပ္လုပ္ေပးပါတယ္။ သူက variant size ပါ။
စေၾကျငာခ်င္းခ်င္းမွာ ArrayList ရဲ႕ capacity က ၄ ခန္းယူထားေပးပါတယ္။ ကြၽန္ေတာ္တို႔

တန္ဖိုးထည့္ရင္းနဲ႔ ၄ခန္းျပည့္ျပီးလို႔ ေနာက္ထပ္ထပ္ထည့္တာနဲ႔ capacity က ၈ခန္းျဖစ္သြားမွာပါ။
ကိုယ္တကယ္ တန္ဖိုးထည့္ထားတဲ႔ အေရအတြက္ကိုေတာ့ count ဆိုတဲ႔ property ကေန
ျပန္သိနိုင္ပါတယ္။ ArrayList က zero base index ျဖစ္ျပီးေတာ့ သူ႔ရဲ႕ index က integer type ပါ။
ArrayList ကလည္း object type လက္ခံတာျဖစ္တဲ႔ အတြက္ ကြၽန္ေတာ္တို႔ ၾကိဳက္တဲ႔ type
ထည့္ေပးခြင့္ရွိပါတယ္။ example ေလးၾကည့္ရေအာင္။
using System;
using System.Collections;
class arraylistTest
{
static void Main()
{
object[] arr = new object[3];
arr[0] = 1;
arr[1] = 2.2;
arr[2] = "abcdefg";
ArrayList ar = new ArrayList();

ar.Add(1);
ar.Add(9.456);
ar.Add("ABC");
ar.Add('Z');
ar.Add(new arraylistTest());
for (int i = 0; i < ar.Count; i++)

{
Console.WriteLine("{0}\t( {1} )", ar[i], ar[i].GetType());
}
Console.WriteLine("\nActual Size of your Array : " + ar.Count);
Console.WriteLine("Total Capacity of your Array : " + ar.Capacity);
Console.Read();
}
}
Hashtable Class
Hashtable class ထဲမွာ key/value တြဲ႕ data ေတြ လက္ခံပါတယ္။ key/value အတြဲလိုက္ကို
DictionaryEntry လို႔ေခၚပါေသးတယ္။ ArrayList မွာ ကြၽန္ေတာ္တို႔ index ကို integer type
သံုးပါတယ္။ Hashtable မွာေတာ့ index ေထာက္ဖို႔အတြက္ key ကိုသံုးပါတယ္။ သူကလည္း object

type ပါ၊ ဒါေၾကာင့္ ကြၽန္ေတာ္တို႔ ၾကိဳ႔က္တဲ႔ type နဲ႔ index ေထာက္လို႔ ရပါတယ္။ သိမ္းမယ့္ data
ေတြကိုေတာ့ value အပိုင္းမွာ သိမ္းရပါတယ္။ သူလည္း object type ပါပဲ။ Hashtable ကလည္း
ArrayList လိုပဲ size ကို dynamically increment လုပ္လို႔ ရပါတယ္။ Example ေလးၾကည့္ရေအာင္။
using System;
using System.Collections;
class arraylistTest
{
static void Main()
{
Hashtable ht = new Hashtable();
ht.Add("Name", "Sevenlamp");
ht.Add("Address", "Yangon");
ht.Add("Age", 28);
foreach (DictionaryEntry de in ht)

{
Console.WriteLine("{0}\t\t: \t {1} ", de.Key, de.Value);
}
Console.WriteLine("\nThere are {0} element/s in your Hashtable Array", ht.Count);
Console.Read();
}
}
ဒီေန႔ ကြၽန္ေတာ္ OOP အေၾကာင္း မစခင္ enumeration နဲ႔ structure အေၾကာင္း နည္း နည္း
ေျပာခ်င္တယ္ဗ်ာ။ အရင္ဆံုး variable declaration အေၾကာင္းကို ျပန္ေႏႊးရေအာင္။ ကြၽန္ေတာ္တို႔
number တန္ဖိုးတစ္ခု သိမ္းဖို႔ integer အမ်ိဳးအစား variable တစ္ခုေၾကျငာမယ္ဆိုရင္…
int num;
ဆိုျပီးေၾကျငာပါတယ္။ ဒါဆိုရင္ memory ေပၚမွာ integer value တစ္ခုသိမ္းဖိ႔ု အတြက္ ေနရာ

တစ္ေနရာ ယူလိုက္ပါတယ္။ ဟုတ္ျပီ… ဒါဆိုရင္ ကြၽန္ေတာ္က
myOwnType var1;
ဆိုျပီး ေၾကျငာလိုက္တယ္ ဆိုပါေတာ့။ ဒါဆိုကြၽန္ေတာ္တို႔ program ကို compiler က

နားလည္ပါဦးမလား။ နားမလည္နိုင္ေတာ့ပါဘူး ဘာလို႔လဲဆိုေတာ့ myOwnType ဆိုတဲ႔ pre-defined
type မဟုတ္တာတစ္ခုကို ေၾကျငာလိုက္လို႔ပါ။ ကြၽန္ေတာ္တို႔ Integer type ေၾကျငာေတာ့ compiler
က integer value ေတြထည္ဖ
့ ို႔မွန္းသိပါတယ္။ myOwnType ကိုေၾကျငာလိုက္ေတာ့ compiler က
ဘာအမ်ိဳးအစားအတြက္ ေၾကျငာေပးရမွန္းမသိဘူး ျဖစ္သြားပါတယ္။ ဒါဆိုရင္ ကြၽန္ေတာ္တို႔က
compiler ကို myOwnType ဆိုတ ာကေတာ့ ဘယ္လို data မ်ိဳးေတြကို သိမ္းခ်င္တာပါဆိုျပီး
ေျပာေပးလိုက္ရင္ မျဖစ္ဘူးလား။ ျဖစ္ပါတယ္။ ဘယ္လိုလုပ္ေပးရမွာလဲ ကြၽန္ေတာ္တို႔ user defined
data type ေတြ ေၾကျငာေပးရမွာပါ။ ဒီလိုလုပ္ဖို႔အတြက္ ကြၽန္ေတာ္တို႔ enumeration ေတြ၊
structure ေတြ၊ class ေတြ အေၾကာင္းကို သိဖို႔လိုလာပါျပီ။
ကြၽန္ေတာ္တို႔ enumeration ေဆာက္ဖို႔အတြက္ enum keyword ကိုသံုးရပါတယ္။ ဟုတ္ျပီ အခု
ကြၽန္ေတာ္ myOwnType ကို create လုပ္ပါေတာ့မယ္။
enum myOwnType
{
Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday
}
myOwnType ထဲမွာ ကြၽန္ေတာ္က ေန႔ ၇ ေန႔ကို သိမ္းခ်င္ပါတယ္လို႔ defined လုပ္လိုက္ပါတယ္။

ကြၽန္ေတာ္က ေန႔ေတြကို စာသားေတြနဲ႔ ေရးလိုက္ေပမယ့္ enumeration မွာ
တစ္ကယ္သိမ္းသြားမွာက default integer type ပါ။ ကြၽန္ေတာ္က integer type အစား တျခား
ကိန္းျပည့္ number type အျဖစ္ ေၾကျငာခ်င္လို႔လည္း ရပါတယ္။ default အားျဖင့္ 0 ကေန စျပီး
တခုစီကို 1 ေပါင္းေပါင္းျပီးသိမ္းသြားမွာပါ။ ဆိုလိုတာက ေရွ႕ဆံုးမွာ ရွိတဲ႔ Sunday ရဲ႕ value က 0
ျဖစ္ျပီး Monday က 1 ၊ Tuesday က 2 ပါ။ ကြၽန္ေတာ္တို႔ ၾကိဳက္တဲ႔ number နဲ႔လည္း ကိုယ္စားျပဳလို႔
ရပါတယ္။ ဥပမာ..
enum myOwnType : byte

{
Sunday, Monday = 5, Tuesday, Wednesday, Thursday = 100, Friday, Saturday
}
အိုေက ဒီပံုစံအတိုင္းဆိုရင္
Sunday = 0,
Monday = 5,
Tuesday = 6,
Wednesday = 7,
Thursday = 100,
Friday = 101,
Saturday = 102
ဆိုျပီး ျဖစ္သြားပါမယ္။
ကြၽန္ေတာ္တို႔ enumeration test လုပ္ဖ႔ို program တစ္ခုေလာက္ ေရးၾကည့္ရေအာင္။
using System;
class Program
{
enum myOwnType : byte
{
Sunday, Monday = 5, Tuesday, Wednesday, Thursday = 100, Friday, Saturday
}
static void Main()

{
myOwnType wd = myOwnType.Friday;
int i = 7;
Console.WriteLine("{0} is {1}", wd, (int)wd);
Console.WriteLine("{0} is {1}", i, (myOwnType)i);
Console.ReadLine();
}
}
Output
Friday is 101
7 is Wednesday
Enumeration ကိုသံုးျခင္းအားျဖင့္ ကြၽန္ေတာ္တို႔ ကိုယ္ပိုင္data type ေတြေဆာက္ျပီး

သံုးလို႔ရလာပါမယ္။ enumeration သံုးတာ ဘာပိုေကာင္းလာလဲ အတိအက်ေတာ့ မသိဘူးဗ်။
ကြၽန္ေတာ္စိတ္ထင္ေတာ့ enumeration သံုးလိုက္ျခင္းအားျဖင့္ ၁။ memory ေပၚမွာ ေနရာယူတဲ႔ size
ေသးသြားမယ္၊ ၂။ project တစ္ခုကို develop လုပ္တ႔ဲ programmer ေတြ ၾကားထဲမွာ standardized
ျဖစ္သြားမယ္ ( ဥပမာ.. developer တစ္ေယာက္က Sunday လိ႔ေ
ု ပါင္းရင္ေပါင္းမယ္၊
ေနာက္တစ္ေယာက္က SUNDAY လို႔ေပါင္းမယ္၊ တျခားတစ္ေယာက္က sun လို႔ပဲ
ေပါင္းရင္ေပါင္းမယ္၊ enum defined လုပ္လိုက္ျခင္းအားျဖင့္ ဒါမ်ိဳးကိစၥေတြ မရွိနိုင္ေတာ့ဘူး ေပါ့ )။
Enumeration သံုးရင္ ကြၽန္ေတာ္တို႔က data type တစ္မ်ိဳးထဲပဲ သံုးလို႔ရတယ္။ integer ဆို integer,
byte ဆို byte ေပါ့၊ record တစ္ခုပံုစံမ်ိဳး data type အစံုသိမ္းခ်င္ရင္ေတာ့ enum အစား structure
ေဆာက္ျပီးသံုးၾကပါတယ္။ (ဆိုင္မဆိုင္ေ တာ့ မသိဘူး တြဲျပီးေျပာလိုက္တာ ) ဥပမာ.. ကြၽန္ေတာ္က
ေက်ာင္းသားတစ္ေယာက္ရဲ႕ data ေတြသိမ္းခ်င္တယ္ဆိုရင္ သိမ္းမယ့္ data ေတြထဲမွာ roll (int),
name (string), mark (int) စတာေတြ ပါမယ္ဗ်ာ။ ဒါဆိုရင္ enum သံုးလို႔ မရေတာ့ဘူး၊ structure
ဒါမွမဟုတ္ class ကိုသံုးရေတာ့မယ္။ structure နဲ႔ class က အဓိက value type နဲ႔ reference type
ပဲကြာသြားတာ။ က်န္တာအားလံုး အတူတူနီးပါးပဲ။ example program ေလးၾကည့္ရေအာင္။
using System;
struct Student
{
public int roll;
public string name;
public int mark;
}
class structuretest
{
static void Main()
{
Student s1;
s1.roll = 1; s1.name = "Ag Ag"; s1.mark = 90;
Student s2 = s1;
s2.roll = 2; s2.name = "Mg Mg";
Student s3 = new Student();
s3.roll = 3; s3.name = "Zw Zw"; s3.mark = 80;
Console.WriteLine("\nRoll : {0} \nName : {1} \nMark : {2}", s1.roll, s1.name, s1.mark);

Console.Read();
}
}
ျပန္ရွင္းရေအာင္
struct Student
{
public int roll;
public string name;
public int mark;
ဒါက Student ဆိုတ႔ဲ user defined type တစ္ခု create လုပ္တာပါ။ ဒီလိုေရးလိုက္ျခင္းအားျဖင့္
compiler က Student ဆိုတာမွာေတာ့ integer အမ်ိဳးအစား variable ႏွစ္ခုရယ္၊ string တစ္ခုရယ္
ပါတယ္ဆိုတာ သိသြားပါျပီ။ variable ေတြရဲ႕ေရွ႕မွာ public လို႔ေရးတာကေတာ့ အဲ့ဒီ variable
ေတြကို structure ရဲ႕ အျပင္ဘက္ တျခားေနရာကေန ေခၚသံုးခြင့္ျပဳတာပါ။
ျပီးေတာ့ Main function ထဲမွာ ကြၽန္ေတာ္က ေက်ာင္းသား ၃ေယာက္ရဲ႕ data သိမ္းခ်င္တယ္
ဆိုေတာ့ Student variable ၃ ခုေၾကျငာရမွာေပါ့။ ဒါေၾကာင့္ ကြၽန္ေတာ္က s1, s2 နဲ႔ s3 ဆိုျပီး
ေၾကျငာလို္က္ပါတယ္။
Student s1;
ဆိုျပီး ေၾကျငာလိုက္တာနဲ႔ ကြၽန္ေတာ္တို႔ စက္ရဲ႕ memory ေပၚမွာ Student အမ်ိဳးအစား data

ေတြသိမ္းလို႔ရမယ့္ ေနရာတစ္ခု ေဆာက္ေပးသြားပါတယ္။ အဲ့ဒီ ေနရာထဲမွာ roll, name, mark တို႔
သိမ္းဖို႔ေနရာပါ ပါျပီးသားပါ။
s1.roll = 1; s1.name = "Ag Ag"; s1.mark = 90;
ျပီးေတာ့မွ ကြၽန္ေတာ္က အဲ့ဒီထဲကို 1, “Mg Mg”, 90 တိ႔က

ု ို ထည့္လိုက္ပါတယ္။ Student
အမ်ိဳးအစား s1 ထဲမွာ ရွိတဲ႔ variable ေတြကို ျပန္ေခၚခ်င္တာျဖစ္လို႔ s1(dot)variable name ဆိုျပီး
ေရးရပါတယ္။
Student s2 = s1;
ေနာက္ထပ္ s2 ကို ေၾကျငာတဲ႔ေနရာမွာေတာ့ s1 ထဲက တန္ဖိုးေတြကိုပါ s2 ထဲကို

ထည့္လိုက္ပါတယ္။ ဒါဆိုရင္ s2 ထဲမွာ ရွိတဲ႔ roll, name နဲ႔ mark မွာ s1 ထဲက တန္ဖိုးေတြ
ေရာက္ျပီးသားျဖစ္သြားပါတယ္။
s2.roll = 2; s2.name = "Mg Mg";
ျပီးေတာ့မွ s2 ရဲ႕ roll နဲ႔ name ကို ျပန္ျပင္လိုက္ပါတယ္။ အမွတ္ကိုေတာ့ မျပင္လိုက္ပါဘူး။

ဒီလိုျပင္လိုက္ျခင္းအားျဖင့္ နဂိုတန္ဖိုးျဖစ္တဲ႔ s1 ထဲမွာ ေျပာင္းသြားမလား? Structure က value type
ျဖစ္လို႔ s1 ထဲမွာ လုိက္ျပီး ေျပာင္းသြားမွာ မဟုတ္ပါဘူး။

s3.roll = 3; s3.name = "Zw Zw"; s3.mark = 80;
s3 ထပ္ေၾကျငာတယ္၊ တန္ဖိုးထည့္ပါတယ္။ ဒီေနရာမွာ s3 ကို new Student() ဆိုျပီး object

ေဆာက္ေပးထားတာ ေတြ႔မွာပါ။ ကြၽန္ေတာ္တို႔ structure ကို object ေဆာက္ျပီးေတာ့ ျဖစ္ျဖစ္
မေဆာက္ပဲနဲ႔ ျဖစ္ျဖစ္ ၾကိဳက္သလိုသံုးလို႔ရပါတယ္။ object ေဆာက္ေပးရင္ structure ထဲက
variable ေတြကို default value assign လုပ္ေပးသြားမွာျဖစ္ျပီးေတာ့၊ object
မေဆာက္ပဲသံုးရင္ေတာ့ default value assign မလုပ္ေပးပါဘူး။ ဒါဆို default value
ကဘာေတြလဲ? ဟုတ္ကဲ႔ number ေတြဆို default value က 0 ပါ။ string အတြက္ကေတာ့ null
ေပါ့။
ဒီ program ေလးကို ရိုက္ျပီး run ၾကည့္လိုက္ပါဦး။
Chapter 7
ကြၽန္ေတာ္တို႔ မေန႔က ေရးခဲ႔တ႔ဲ structure test program ေလးနဲ႔ပဲ ဆက္ျပီး ေျပာရေအာင္ဗ်ာ။

structure ကိုသံုးျခင္းအားျဖင့္ ကြၽန္ေတာ္တို႔ record ေတြသိမ္းလို႔ ရတယ္ဆိုတာ သိခဲ႔ပါျပီ။ structure
ဟာ object-oriented programming မွာ အေျခခံအက်ဆံုး အပိုင္းျဖစ္တဲ႔ class ေတြျဖစ္ေပၚလာဖို႔
ကနဦး အစပါပဲ။ structure က value type ပါ။ ဒါေၾကာင့္ OOမွာ သံုးလို႔ အဆင္မေျပပါဘူး။ ဒီအခါမွာ
structure ပံုစံအတိုင္း reference type အေနနဲ႔ သံုးနိုင္မယ့္ class ကို ေနာက္ပိုင္းမွာ
အသံုးတြင္က်ယ္လာပါတယ္။ OOP မွာ အဓိကအက်ဆံုးကေတာ့ class ေတြပါပဲ။ ဟုတ္ျပီ၊ class
တစ္ခုမွာ အေျခခံအားျဖင့္ေ တာ့ data member ေတြနဲ႔ member function ေတြပါေလ႔ရွိပါတယ္။
member data ေတြဟာ သက္ဆိုင္ရာ classရဲ႕ ၀ိေသသ လကၡဏာေတြကို ကိုယ့္စားျပဳျပီးေတာ့၊
member function ေတြကေတာ့ အဲ့ဒီ classရဲ႕ လုပ္ေဆာင္ခ်က္ေတြပါ။ ဥပမာအားျဖင့္ People ဆိုတ႔ဲ
class တစ္ခုမွာ အမည္(name)၊ အသက္(age) စသည္တ႔ဟ
ို ာ member data ေတြ ျဖစ္ၾကျပီး၊
စားသည္(eat())၊ အိပ္သည္(sleep()) စသည္တို႔ကေတာ့ member function ေတြ ျဖစ္ၾကမွာပါ။
class People
{
string name; // member data
int age; // member data
void eat() // member function
{
// eat something…
}
void sleep() // member function
{
// sleep at night.
}
}
အခုကြၽန္ေတာ္ ေရးလိုက္တဲ႔ People class ကို datatype class လို႔ ေခၚပါတယ္။ မေန႔က program
ေလးကို class အေနနဲ႔ ျပန္ျပီး ေရးၾကည့္ရေအာင္။
class Student
{
public int roll;
public string name;
public int mark;
public void Display()
{
Console.WriteLine(“\n Roll : {0} \n Name : {1} \n Mark : {2}”,
roll, name, mark);
}
}
class StudentTest
{
static void Main()
{
s1.roll = 1; s1.name = “Ag Ag”; s1.mark = 90;
s2.roll = 2; s2.name = “Zw Zw”; s2.mark = 88;
Student s3 = s2;
s3.roll = 3; s3.name = “Ma Ma”;
// display
s1.Display();
s2.Display();
s3.Display();
Console.Read();
}
}
OUTPUT :
1 Ag Ag 90
3 Ma Ma 88
3 Ma Ma 88
ဒီ program ေလးကို အေသးစိတ္ျပန္ရွင္းျပပါ႔မယ္။ ပထမဆံုး data type class (Student) ေလး

ေဆာက္ပါတယ္။ member data အေနနဲ႔ roll၊ name နဲ႔ mark တို႔ပါျပီး။ student information ေတြ
ျပန္ထုတ္ျပေပးဖို႔ Display ဆိုတဲ႔ member function တစ္ခုပါပါတယ္။ student class ထဲက
member ေတြ အားလံုးရဲ႕ ေရွ႕မွာ public ဆိုတ႔ဲ keyword ေလးေရးထားတာ ေတြ႕မွာပါ၊ class
တစ္ခုအတြင္းမွာ member ေတြ ေၾကျငာရင္ default က private ပါ။ ဆိုလိုတာကေတာ့ သက္ဆိုင္ရာ
class အတြင္းမွာပဲ သံုးခြင့္ရွိျပီး အျပင္(တျခား class ေတြ) ကေန ေခၚသံုးလို႔ မရဘူးဆိုတဲ႔ အဓိပၸါယ္ပါ။
အခုကြၽန္ေတာ္က public လုပ္ေပးလိုက္တဲ႔ အတြက္ ၾကိဳက္တဲ႔ ေနရာကေန ေခၚသံုးခြင့္ရွိသြားပါတယ္။
ဟုတ္ျပီ။ အခုကြၽန္ေတာ္တို႔ program ေလးကို run ဖို႔ အတြက္ Main function ပါတဲ႔ run class
တစ္ခု ထပ္ေဆာက္ပါတယ္။ Main function အတြင္းမွာ ပထမဆံုး ေက်ာင္းသားတစ္ေယာက္ရဲ႕
information သိမ္းဖို႔အတြက္ Student အမ်ိဳးအစား variable a ကို ေၾကျငာျပီး object
ေဆာက္ေပးပါတယ္။ class ေတြဟာ reference data type ျဖစ္တဲ႔ အတြက္ variable ေၾကျငာရံုနဲ႔
တန္ဖိုးသိမ္းလို႔ မရေသးပါဘူး။ ဒါေၾကာင့္ တန္ဖိုးတကယ္ သိမ္းနိုင္ဖို႔အတြက္ object
ေဆာက္ေပးရပါတယ္။ ရႈပ္သြားျပီထင္တယ္
ကြၽန္ေ တာ္တို႔ memory မွာ stack အပိုင္းနဲ႔ heap အပိုင္း ဆိုျပီး အပိုင္း၂ပိုင္းရွိတယ္ဗ်။ value type
variable ေတြကို stack အပိုင္းမွာပဲ သိမ္းေလ့ရွိတယ္။ ဒါေၾကာင့္ မေန႔က သိမ္းခဲ႔တဲ႔ Student
အမ်ိဳးအစား s1, s2, s3 တိ႔က
ု structure (value type) ျဖစ္တဲ႔အတြက္ stack အပိုင္းမွာ
ေနရာယူသြားပါတယ္။ အဲ့ဒီေနရာမွာပဲ တန္ဖိုးကို တကယ္သိမ္းပါတယ္။ class ကေတာ့ မတူပါဘူး။
သူက stack ရယ္ heat ရယ္ ခြဲျပီးေနရာယူပါတယ္။ object reference(variable) ကို stack မွာ
သိမ္းျပီး၊ real object ကိုေတာ့ heat မွာ သိမ္းပါတယ္။ structure နဲ႔ class တိ႔ု memory ေပၚမွာ
ေနရာယူပံုကို ပံုေလး ဆြဲျပေပးထားပါတယ္၊ ပံုၾကည့္လိုက္ရင္ နည္းနည္းနားလည္သြားမယ္
ထင္ပါတယ္။
Structure မွာ သိမ္းသြားတဲ႔ ပံုကေတာ့ ရွင္းပါတယ္ ကြၽန္ေတာ္တို႔ class မွာ သိမ္းသြားတဲ႔ ပံုကိုပဲ
ၾကည့္ရေအာင္။ ကြၽန္ေတာ္ေျပာခဲ႔သလိုပဲ class ကို variable ေၾကျငာလိုက္လို႔ ရလာတဲ႔ ေနရာမွာ
value ေတြသိမ္းလိ႔မ
ု ရပါဘူး၊ reference ေတြပဲ သိမ္းလို႔ ရပါတယ္။ value
တကယ္သိမ္းနိုင္ဖို႔အတြက္ေတာ့ ကြၽန္ေတာ္တို႔က new operator သံုးျပီး object
ေဆာက္ေပးရပါတယ္။ အဲ့ဒီလို new နဲ႔ ေဆာက္လိုက္တ႔ဲ object ေတြဟာ heap memoryထဲမွာ
ေနရာသြားယူပါတယ္။ ဒါေၾကာင့္ Student s3 က object မေဆာက္ထားပါဘူး၊ class variable ပဲ
ေၾကျငာထားပါတယ္။ ဒါေၾကာင့္ s3 အတြက္ ကိုယ္ပိုင္ object မရွိပါဘူး။ s3 ထဲကို s2
ကိုထည့္လိုက္ပါတယ္။ ဒီေနရာမွာ s2 ထဲမွာ ဘာရွိလဲ ကြၽန္ေတာ္တို႔ ျပန္ၾကည့္ေတာ့ s2
ေၾကျငာထားတဲ႔ ေနရာမွာ memory address (f002) ပဲ ရွိပါတယ္။ ဒါေၾကာင့္ s3 ထဲကိုလည္း f002 ပဲ
ေရာက္သြားမွာပါ။ ဒါဆို s3 ကလည္း memory address f002 ရွိေနတဲ႔ ေနရာက object ကိုပဲ
သြားျပီး point လုပ္ပါတယ္။ ဒါေၾကာင့္ s2 နဲ႔ s3 ၂ ခုလံုးက object တစ္ခုထဲကိုပဲ point
ထားၾကပါတယ္။ ဒါေၾကာင့္ s3 ထဲကိုထည့္လိုက္တ႔ဲ roll 3 နဲ႔ name “Ma Ma” ဟာ s2 ကို
ရိုက္ထုတ္တဲ႔ ေနရာမွာပါ ေပၚလာရျခင္းျဖစ္ပါတယ္။ ေတာ္ေတာ္ေလးေတာ့ ရႈပ္သြားမယ္ထင္တယ္။
ကြၽန္ေ တာ္ စာအေရးအသား ညံ့ေတာ့ ေသေသခ်ာခ်ာ နားလည္ေအာင္ မရွင္းျပနိုင္လို႔ပါ။
ဒီေန႔ ကြၽန္ေတာ္တ႔ို Constructor အေၾကာင္း ေျပာရေအာင္။ ကြၽန္ေတာ္တို႔ student ကို object

ေဆာက္တုန္းကေရးခဲ႔တ႔ဲ code ေလးကို ျပန္ၾကည့္ရေအာင္။
ကြၽန္ေတာ္တို႔ class ေတြကို object ေဆာက္ဖို႔ အတြက္ new operator ကိုသံုးျပီး function တစ္ခုကို
ေခၚရပါတယ္။ အဲ့ဒီ function name က class name နဲ႔ တူပါတယ္။ အဲ့ဒီ function ကို constructor
function လိ႔ု ေခၚပါတယ္။ ကြၽန္ေတာ္တို႔ ွStudent class ေဆာက္တုန္းက constructor function
ေဆာက္ခဲ႔လား။ မေဆာက္ေပးခဲ႔ပါဘူး။ ကြၽန္ေတာ္တို႔မေဆာက္ေပးခဲ႔ပဲ ဘယ္လိုျဖစ္လို႔ ေခၚသံုးလို႔
ရေနပါလိမ္႔။ ဟုတ္ကဲ႔ ကြၽန္ေတာ္တို႔ class တစ္ခု ေဆာက္လိုက္ျပီဆိုတာနဲ႔ compiler က အဲ့ဒီ class
ထဲမွာ constructor function ပါလားစစ္ပါတယ္၊ မပါဘူး ဆိုရင္ default constructor function
တစ္ခုကို compiler က အလိုအေလွ်ာက္ ေဆာက္ေပးပါတယ္။ ဒီလိုေဆာက္ေပးသြားလိုသာ
ကြၽန္ေတာ္တို႔ class ေတြကို object ေဆာက္လို႔ ရတာဗ်။ အိုေက compiler ကေဆာက္ေပးတဲ႔
default constructor က ဘာေတြလုပ္ေပးလဲ ဆိုေတာ့ class ထဲမွာ ရွိတဲ႔ member data ေတြကို
default value assign လုပ္ေပးပါတယ္။ default value ဆိုတာဘာလဲ ေျပာျပီးျပီထင္တယ္ေနာ္။
တခါတေလ default constructor က လုပ္ေပးတဲ႔ အလုပ္ေတြကို ကြၽန္ေတာ္က မၾကိဳက္ဘူး ဆိုရင္
ကြၽန္ေတာ္တို႔ လိုခ်င္တဲ႔ ပံုစံရေအာင္ ကိုယ္တိုင္ constructor ေတြ ေဆာက္ေပးဖို႔ လိုပါတယ္။ ဟုတ္ျပီ
ဒါဆိုရင္ constructor ေတြဘယ္လို အလုပ္လုပ္လဲ၊ constructor ဘယ္ႏွစ္မ်ိဳးရွိလဲ၊ ကိုယ္ပိုင္
constructor ေတြ ဘယ္လိုေဆာက္လဲ ေလ့လာလိုက္ရေအာင္။
Instant Constructor, Private Constructor နဲ႔ Static Constructor ဆိုျပီး Constructor

အမ်ိဳးအစား ၃ မ်ိဳးရွိပါတယ္။ လူသိအမ်ားဆံုးနဲ႔ အသံုးလည္း အမ်ားဆံုး မျဖစ္မေနသံုးေနရတဲ႔
constructor အမ်ိဳးအစားကေတာ့ instant constructor ျဖစ္ပါတယ္။ instant constructor
ဆိုတာကေတာ့ ကြၽန္ေတာ္တို႔ class ေတြကို object ေဆာက္ဖို႔အတြက္ new operator နဲ႔ တြဲျပီး
ေခၚေနရတဲ႔ constructor ပဲ ျဖစ္ပါတယ္။ instant constructor မွာ ၂ မ်ိဳးထပ္ခြဲနိုင္ပါတယ္။ Default
Constructor နဲ႔ Parameterized Constructor ဆိုျပီး ျဖစ္ပါတယ္။ Default constructor ကို
compiler က auto ေဆာက္ေပးတယ္ဆိုတာ အေပၚမွာ ကြၽန္ေတာ္ေျပာခဲ႔ျပီးပါျပီ။ ဒါေပမယ့္ တစ္ခု
သိထားရမွာက compiler က ကြၽန္ေတာ္တို႔ class ထဲမွာ constructor လံုး၀ မပါဘူး ဆိုမွ default
constructor ကို ေဆာက္ေပးတာပါ။ ကြၽန္ေတာ္တို႔ class ထဲမွာ constructor တစ္ခု ပါျပီဆိုတာနဲ႔
default constructor ေဆာက္တဲ႔ အလုပ္ကို compiler က မလုပ္ေပးေတာ့ပါဘူး။ instant
constructor တစ္ခုေဆာက္ဖို႔အတြက္ လိုက္နာရမယ့္ စည္းကမ္းေတြကေတာ့ constructor ရဲ႕
ေရွ႕မွာ public keyword ပါရပါမယ္၊ class name နဲ႔ နာမည္တူရပါမယ္၊ return type
မထည့္ေပးရပါဘူး။ ကဲ ဟိုေန႔က ေရးခဲ႔တဲ႔ student class ေလးမွာပဲ စမ္းၾကည့္ရေအာင္ဗ်ာ။
ကြၽန္ေတာ္က roll, name နဲ႔ mark တို႔ကို ကိုယ့္ စိတ္ၾကိဳက္ default value ထည့္ေပးဖိ႔ု ကိုယ္ပိုင္
default constructor ေလး ေဆာက္ပါမယ္။
class Student
{
public int roll;
public string name;
public int mark;

public Student() // default constructor
{
roll = -1;
name = “?”;
mark = 0;
}
{
roll, name, mark);
}
}
class StudentTest
{
static void Main()
{
s1.Display();
Console.Read();
}
}
အိုေက ဒီ program ေလးကို run ၾကည့္ရင္ constructor ထဲမွာ ကြၽန္ေတာ္တို႔ ထည့္ေပးထားတဲ႔

အတိုင္း Roll = 1, Name = “?” နဲ႔ Mark = 0 ဆိုျပီး ေပၚလာမွာပါ။ constructor ကို မထည့္ပဲ run
ၾကည့္ရင္ေတာ့ Roll = 0, Name = “” နဲ႔ Mark = 0 ျဖစ္ေနပါလိမ့္မယ္။ ဒါက default constructor
အလုပ္လုပ္ပံုပါ။ အခု parameterized constructor အေၾကာင္းဆက္ၾကည့္ရေအာင္။ ကြၽန္ေတာ္က
student class ကို object ေဆာက္တဲ႔ constructor function ေလးထဲကို student ရဲ႕ name
ေလးကို parameter အေနနဲ႔ ထည့္ေပးခ်င္တယ္ ဆိုရင္ အခုကြၽန္ေတာ္တို႔ ေဆာက္ထားတဲ႔ default
constructor ကို သံုးလို႔ မရေတာ့ပါဘူး။ ဒါဆို string တစ္ခု လက္ခံမယ့္ constructor
တခုထပ္ေရးေပးဖို႔ လိုအပ္လာပါျပီ။ အခုလို ေရးလိုက္ပါမယ္။
class Student
{
public int roll;
public string name;
public int mark;
public Student(string name) // parameterized constructor
{
roll = -1;
this.name = name; // assign local to member
mark = 0;
}
{
roll, name, mark);
}
}
class StudentTest
{
static void Main()
{
Student s1 = new Student(“Mg Mg”);
s1.Display();
Console.Read();
}
}
ဒီ program ေလးကို run ရင္ Roll = -1, Name = “Mg Mg” နဲ႔ Mark = 0 ဆိုျပီး ျပပါလိမ့္မယ္။ ဒီ
program မွာ ကြၽန္ေတာ္က default constructor အစား parameterized constructor
ကိုထည့္လိုက္ပါတယ္။ ဒါဆိုရင္ compiler က default constructor ေဆာက္ေပးမွာလား ?
မေဆာက္ေပးဘူးေနာ္။ ဒါေၾကာင့္ ကြၽန္ေတာ္က Main function ထဲမွာ ဒီလို သြားေရးရင္ error
တက္ပါလိမ့္မယ္။
Student s2 = new Student(); // error code
ဘာလို႔လဲ ဆိုေတာ့ default constructor မပါလို႔ပါ။ အခုေရးလိုက္တဲ႔ constructor ထဲမွာ this.name
= name; ဆိုျပီး ေရးလိုက္တာကို ေတြ႔မွာပါ၊ အဲ႕ဒါေလး ျပန္ရွင္းပါဦးမယ္။ Student class ထဲမွာ
ကြၽန္ေတာ္က name ဆိုတဲ႔ variable ေလးကို ေၾကျငာထားျပီးသားပါ။ အဲ့ဒ ါကို member variable လို႔
ေခၚေၾကာင္းလည္း သိျပီးသားပါ။ ဒီလိုပါပဲ ကြၽန္ေတာ္ အခု ေဆာက္လိုက္တဲ႔ constructor ထဲမွာ လဲ
parameter variable name ကို ထပ္ေၾကျငာလိုက္ပါတယ္။ အဲ့ဒါကိုေတာ့ local variable လိ႔ု
ေခၚပါတယ္။ ကဲ အခု member နဲ႔ local နာမည္တူေနပါျပီ။ ဒါဆို အေနအထားမ်ိဳးမွာ ကြၽန္ေတာ္က
name လိ႔ု ေခၚလိုက္ရင္ အနီးဆံုး local variable ကိုပဲ compiler က ယူသံုးသြားပါတယ္။ ဒါေၾကာင့္
ကြၽန္ေတာ္က member variable name ကို ေခၚဖို႔အတြက္ this ဆိုတ႔ဲ keyword နဲ႔ တြဲျပီး
ေခၚေပးရပါတယ္။ instant constructor အေၾကာင္း နားလည္ျပီလားေတာ့ မသိဘူး။
နားမလည္ဘူးဆိုရင္လည္း ေျပာၾကဦးဗ်ာ။ ထပ္ျပီး ျပန္ရွင္းေပးပါ့မယ္။
ေနာက္ေန႔မွ Private နဲ႔ Static constructor ေတြ အေၾကာင္းဆက္ရေအာင္ဗ်ာ။
ဟိုေန႔က ကြၽန္ေတာ္တို႔ Instant constructor အေၾကာင္းသိခဲ႔ျပီးျပီ။ Constructor လိ႔ဆ

ု ိုလိုက္တာနဲ႔
programmer ေတာ္ေတာ္မ်ားမ်ား ေျပးျမင္မီၾကတာလည္း ဒီ Instant Constructor ပါပဲ။
အသံုးအမ်ားဆံုးနဲ႔ မသံုးမျဖစ္ Constructor လည္းျဖစ္ပါတယ္။ Instant Constructor အျပင္ တျခား
လူသိနည္းတဲ႔ constructor ၂ ခုရွိပါေသးတယ္။ အဲ့ဒါေတြကေတာ့ Private Constructor နဲ႔ Static
Constructor တိ႔ပ
ု ါပဲ။ Instant Constructor ကို public constructor လိုလဲ ေခၚပါေသးတယ္။
constructor ရဲ႕ ေရွ႕မွာ public keyword ကိုေရးေပးရပါတယ္။ ဘာလို႔လဲ ဆိုေတာ့ class ကို object
ေဆာက္ဖို႔အတြက္ တျခား class ေတြ ထဲမွာ ေခၚသံုးလို႔ ရေအာင္ပါ။ private
လို႔ေရးလိုက္လို႔ရွိရင္ေတာ့ အဲ့ဒီ private constructor ပါတဲ႔ class ကို object ေဆာက္လုိ႔
မရေတာ့ပါဘူး။ ဒါေၾကာင့္ object မေဆာက္ေစခ်င္တဲ႔ class ေတြမွာ private constructor
ကိုေရးေပးေလ့ရွိပါတယ္။ ဥပမာ…
using System;
class Constant
{
private Constant()
{}
public static string DeveloperName = "Sevenlamp";
}
class Program
{
static void Main()
{
//Constant c = new Constant(); // error
Console.WriteLine(Constant.DeveloperName);
Console.Read();
}
}
ဒီ program ေလးမွာ private constructor ေၾကျငာထားလို႔ Constant class ကို object ေဆာက္လို႔
မရပါဘူး။ ဒါဆိုရင္ အဲ့ဒီ class ထဲမွာ ရွိတဲ႔ member data ေတြကို ဘယ္လို ျပန္ေခၚသံုးမလဲ။ ဟုတ္ကဲ႔
ကြၽန္ေတာ္တို႔ private constructor ရွိတဲ႔ class ေတြထဲက member ေတြကို ျပန္သံုးလို႔ ရေအာင္
အဲ့ဒီ member ေတြကို static keyword နဲ႔ တြဲ႔ျပီး ေၾကျငာေပးရပါမယ္။ ဟုတ္ျပီ အဲ့ဒီ variable ေတြကို
static variable တနည္းအားျဖင့္ class variable လို႔ေခၚပါတယ္။ အဲ့ဒ ီ class variable ေတြကို
ေခၚဖို႔အတြက္ သူရွိေနတဲ႔ class ကုိ object ေဆာက္စရာ မလိုပါဘူး။ program မွာ ေခၚထားသလို
class name ကေနတဆင့္ ေခၚသံုးလို႔ ရပါတယ္။ ေနာက္ constructor တစ္မ်ိဳးကေတာ့ static

constructor ပါ။ class တစ္ခုအတြင္းမွာ ရွိတဲ႔ static member ေတြအလုပ္မလုပ္ခင္ အရင္ဆံုး static
constructor က အလုပ္လုပ္ေလ့ရွိပါတယ္။ ခုန program ေလးကိုပဲ static constructor
ေလးထည့္ျပီး ျပန္ run ၾကည့္ရေအာင္။
using System;
class Constant
{
private Constant()
{}
static Constant()
{
Console.WriteLine("print from static constructor");
DeveloperName = "Sevenlamp";
}
public static string DeveloperName;
}
class Program
{
static void Main()
{
Console.Read();
}
}
Program run လိုက္ရင္ “Sevenlamp” ဆိတ

ု ဲ႔ စာသားကို မရိုက္ျပခင္မွာ “print from static
constructor” ဆိုတ႔ဲ စာသားကိုအရင္ ရိုက္သြားတာ ေတြ႔ရမွာပါ။ ဒါေပမယ့္ တစ္ခုသိထားရမွာက
static constructor က static member ေတြကို မေခၚခင္ ပထမဆံုး တစ္ၾကိမ္ပဲ အလုပ္လုပ္ပါတယ္။
ဒါေၾကာင့္ ကြၽန္ေတာ္က developername ကို ၂ ၾကိမ္ရိုက္ျပထားေပမယ့္ “print from static
constructor” ကေတာ့ တစ္ၾကိမ္ပဲ ေပၚလာမွာျဖစ္ပါတယ္။ ကဲ ဒီေလာက္ဆို ကြၽန္ေတာ္တို႔
constructor ေတြ အေၾကာင္း နည္းနည္းနားလည္လာျပီ ထင္ပါတယ္။
ေနာက္ပိုဒ့္မွာ static member နဲ႔ instant member အေၾကာင္း ဆက္ေျပာပါ့မယ္။
Chapter 8
class တစ္ခုထဲမွာ ရွိတဲ႔ member ေတြကို static member နဲ႔ instant member ဆိုျပီး ၂
မ်ိဳးခြဲ႔ျခားနိုင္ပါေသးတယ္။ static member ကို class member လိ႔လ
ု ည္း ေခၚပါတယ္။ instant
member ကေတာ့ object member ေပါ့။ ဟုတ္ျပီ ဒါဆုိရင္ အဲ့ဒီ static member ေတြနဲ႔ instant
member ေတြ ဘာကြာျခားလဲ ဆက္ၾကည့္ရေအာင္။ အဓိက ကြာျခားခ်က္ ၄ ခ်က္ေလာက္ ရွိတယ္ဗ်။
အရင္ဆံုး ဒီ program ေလးကို run ၾကည့္လိုက္ပါဦး။
class Test
{
public static string clsVar; // static member
public string objVar; // instant member
public void Show()
{
Console.WriteLine(clsVar); // use class member from instant member
Console.WriteLine(objVar);
}
}
class Program
{
static void Main(string[] args)
{
Test t = new Test();
Test t2 = new Test();
t.objVar = "this is object member"; // call from object instant
Test.clsVar = "this is class member"; // call from class name
t.Show();
t2.Show();
Console.Read();
}
}
၁။ static member ေတြ ေၾကျငာဖို႔အတြက္ static keyword ကို သံုးရပါတယ္။ ရိုးရိုး member
ေတြမွာေတာ့ static ထည့္ရန္မလိုပါ။
public static string clsVar; // static member

public string objVar; // instant member
၂။ instant member ေတြက class ကိုေဆာက္တ႔ဲ object ေတြမွာ တစ္ခုဆီ copy ပါသြားမွာ
ျဖစ္ေပမယ့္၊ static member ကေတာ့ object အားလံုး အတြက္ တစ္ခုထဲရွိမွာ ျဖစ္ပါတယ္။
Test t = new Test();

Test t2 = new Test();
၃။ instant member ကို object name ကေန ျပန္ေခၚသံုးရျပီး၊ static member

ကိုသံုးဖို႔အတြက္ေတာ့ class name ကေနတဆင့္သာ ေခၚခြင့္ရွိပါတယ္။
t.objVar = "this is object member"; // call from object instant

Test.clsVar = "this is class member"; // call from class name
၄။ static member ေတြကို instant member ေတြကေန တဆင့္ေခၚသံုးခြင့္ရွိပါတယ္။ ဒါေပမယ့္

instant member ေတြကိုေတာ့ static member ေတြကေန ေခၚခြင့္မရွိပါဘူး။
public void Show()

{
Console.WriteLine(clsVar); // call class member from object member
Console.WriteLine(objVar);
}
ကြၽန္ေ တာ္တ႔ို static member ေတြကို အရင္က သံုးဖူးတယ္ထင္လား? ဟုတ္ကဲ႔ သံုးဖူးပါတယ္။

ဥပမာအေနနဲ႔ screen မွာ စာရိုက္ဖို႔သံုးတဲ႔ WriteLine function ကိုပဲ ၾကည့္ပါ။ WriteLine function
က Console Class ထဲက member function တစ္ခုပါ။ ဒါေပမယ့္ ကြၽန္ေတာ္တို႔ WriteLine
function ကိုသံုးဖိ႔အ
ု တြက္ Console Class ကို object ေဆာက္ပါသလား။ မေဆာက္ဖူးေနာ္ class
name ကေနပဲ ေခၚသံုးသြားတာပါ Console.WriteLine() ဆိုျပီး ေလ။ အိုေက အဲ့ဒ ီလို ေခၚခြင့္ရွိတာ
WriteLine function က static member function ျဖစ္ေနလို႔ပါ။ ကဲ ကြၽန္ေတာ္တို႔ class member
ကိုသံုးျပီး program တစ္ခုေလာက္ေရးၾကည့္ရေအာင္။ အဲ့ဒ ီ program ေလးမွာ ကြၽန္ေတာ္တို႔

customer တစ္ေယာက္ အသစ္ထည့္လိုက္တိုင္း account number auto ေပၚလာခ်င္တယ္။
ျပီးေတာ့ customer စုစုေပါင္း ဘယ္ႏွစ္ေယာက္ ရွိလဲဆိုတာကို ျပန္ျပေပးခ်င္တယ္။
class Customer
{
string acno;
string name;
public Customer(string name)
{
this.acno = GetNewAcno(); //call static member function
this.name = name;
}
public override string ToString()
{
return acno + "-" + name;
}
public static int counter = 0;

public static string GetNewAcno()
{
counter++;
return "C" + counter.ToString("D3");
}
}
public class Program
{
static void Main()
{
Customer a = new Customer("Mg Mg");
Customer b = new Customer("Zw Zw");
Customer c = new Customer("Ag Ag");
Console.WriteLine("{0}", a);
Console.WriteLine("{0}", b);
Console.WriteLine("{0}", c);
Console.WriteLine("Customer Count is {0}", Customer.counter);
Console.Read();
}
}
ဒီေန႔ ကြၽန္ေတာ္တို႔ C# ရဲ႕ property ေတြ အေၾကာင္း ေျပာၾကရေအာင္။ အရင္ဆံုး property ေတြ
ဘယ္လိုေၾကာင့္ ျဖစ္ေပၚလာလဲ အရင္စေျပာပါ့မယ္။ ဟုတ္ျပီ ကြၽန္ေတာ္တို႔ class တစ္ခုထဲက instant
member data ေတြကို တျခား class ေတြကေန ေခၚသံုးမယ္ဆိုရင္ အဲ့ဒီ instant member ရဲ႕ေရွ႕မွာ
public keyword ထည့္ျပီး ေၾကျငာေပးရပါတယ္။ ဒီလိုမ်ိဳးပါ…
using System;
class Test_A
{
public int var;
}
class Program
{
static void Main()
{
Test_A obj = new Test_A();
obj.var = 1;
Console.WriteLine(obj.var);
Console.Read();
}
}
ဒီ program ေလးကိုၾကည့္ၾကည့္ပါ။ Test_A class ထဲက var ဆိုတဲ႔ variable ကို program class
ထဲကေနေခၚျပီး တန္ဖိုးထည့္တယ္။ ျပီးေတာ့ ျပန္ရိုက္ထုတ္တယ္။ ဒီလိုေခၚလို႔ ရဖိ႔အ
ု တြက္ Test_A
ထဲမွာ public ဆိုျပီး ေၾကျငာေပးရတယ္။ ဒီလို member data ေတြကို public လုပ္ျပီး အျပင္ကေန
ေခၚသံုးတာက ေရးရတာ လြယ္ပါတယ္၊ ဒါေပမယ့္ Object-oriented ဆိုျပီး ေအာ္လာၾကတဲ႔
သကာလမွာ data hiding ဆိုတဲ႔ rule ေလးတစ္ခုပါပါလာပါတယ္။ အဲ့ဒီ rule ကေတာ့ member
data ေတြကို အျပင္ကေန တိုက္ရိုက္ေခၚျပီး မသံုးရပါဘူး၊ hide လုပ္ထားပါတယ္။ ဒါဆိုရင္ အဲ့ဒီ
member ကို အျပင္ကေနဘယ္လိုေခၚမလဲ။ ဟုတ္ကဲ႔ အဲ့ဒီလိုေခၚဖို႔အတြက္ အေစာပိုင္းကာလေတြမွာ
ကြၽန္ေတာ္တို႔ member function ေတြကို သံုးရပါတယ္။ ဒီလိုမ်ိဳးပါ….
using System;
class Test_B
{
private int var;
public void SetData(int value)
{
var = value;
}
public int GetData()
{
return var;
}
}
class Program
{
static void Main()
{
Test_B obj = new Test_B();
obj.SetData(2);
Console.WriteLine(obj.GetData());
Console.Read();
}
}
ဒီ program ေလးကိုၾကည့္လိုက္ပါ။ Type_B class ထဲက member variable ကို အျပင္ကေန

ေခၚသံုးလို႔မရေအာင္ private လုပ္လိုက္ပါတယ္။ ျပီးေတာ့မွ အဲ့ဒီ member data ထဲကို တန္ဖိုးထည့္ဖို႔
SetData function နဲ႔ တန္ဖိုးျပန္ထုတ္ဖို႔ GetData function ကိုေရးေပးပါတယ္။ အဲ့ဒီ function
ေတြကိုေတာ့ public လုပ္ေပးရပါမယ္။ ဒီလိုေရးလိုက္ျခင္းအားျဖင့္ data hiding rule ကို
လိုက္နာျပီးသားျဖစ္သြားပါတယ္။ ခုလိုမ်ိဳး function ကေနတဆင့္ တန္ဖိုးအသြင္းအထုတ္လုပ္တာ
မရဘူးလားဆိုေတာ့ ရပါတယ္၊ ဒါေပမယ့္ member variable ကို ေခၚသံုးရတာေလာက္ေတာ့
မလြယ္ကူပါဘူး။ အနည္းဆံုးေတာ့ member data တစ္ခုအတြက္ function ၂ခု မွတ္ေနရပါတယ္။
ဒါေၾကာင့္ C# language မွာေတာ့ data hiding rule ကိုလည္း လိုက္နာျပီး member data
ကိုေခၚသလိုလည္း လြယ္လြယ္ကူကူ ေခၚလို႔ရေအာင္ property ဆိုတာကို သံုးလာၾကပါတယ္။ ကဲ
property ကို ဘယ္လိုေရးရလဲ….
using System;
class Test_C
{
private int var;
public int MyVar
{
get
{
return var;
}
set
{
var = value;
}
}
}
class Program
{
static void Main()
{
Test_C obj = new Test_C();
obj.MyVar = 3;
Console.WriteLine(obj.MyVar);
Console.Read();
}
}
Property ေရးတဲ႔ ပံုစံက member function နဲ႔ေတာ့ဆင္ပါတယ္။ အရင္ဆံုး

အျပင္ကေနေခၚသံုးလို႔ရေအာင္ public ေၾကျငာေပးရပါတယ္။ ျပီးရင္property ကေန return ျပန္မယ့္
data type ေၾကျငာရမယ္၊ အဲ့ဒ ီေနာက္မွာေတာ့ property ရဲ႕ name ေပါ့။ function နဲ႔မတူတဲ႔
အခ်က္ကေတာ့ property မွာ parameter လက္ခံတဲ႔ အပိုင္းမပါပါဘူး။ property ထဲကို
တန္ဖိုးထည့္ဖို႔အတြက္ set keyword နဲ႔ တန္ဖိုးထုတ္ဖို႔အတြက္ get keyword ကိုသံုးရပါတယ္။
ဆိုလိုတာကေတာ့ property မွာ get နဲ႔ set ဆိုျပီး အပိုင္း၂ ပိုင္းပါ၀င္ပါတယ္။ property ထဲက user
က တန္ဖိုးထည့္လိုက္တဲ႔ အခါ အဲ့ဒ ီ property ထဲက set အပိုင္းထဲမွာ ေရးထားတဲ႔ code ေတြကို
အလုပ္လုပ္ပါတယ္။ user ထည့္လိုက္တ႔ဲ တန္ဖိုးကေတာ့ value လိ႔ေ
ု ခၚတဲ႔ keyword
ထဲကိုေရာက္သြားပါတယ္။ အဲ့ဒီကေနတဆင္ member data ထဲကိုထည့္ေပးပါတယ္။ property
ထဲက တန္ဖိုးထုတ္တ႔အ
ဲ ခါမွာေတာ့ get ထဲမွာ ေရးထားတဲ႔ code ေတြက အလုပ္လုပ္ေပးပါတယ္။
property ကို အျပင္ကေန ေခၚတဲ႔ ပံုစံကေတာ့ ရိုးရိုး member data ကိုေခၚသလိုပဲ ေခၚရပါတယ္။
အိုေက… အခုကြၽန္ေတာ္တို႔ Property ေတြ ေရးတက္ျပီလိုထင္ပါတယ္။ property ကို member data
ေတြကို ကိုယ္စားျပဳဖိ႔ု သံုးတာမ်ားေပမယ့္ member data မရွိပဲနဲ႔လည္း property ကိုပဲေရးလို႔လည္း
ရပါတယ္။ ဒီ example program ေလး ေရးျပီး run ၾကည့္ပါဦး။
using System;
class myNumber
{
private int num;
public string Num
{
get
{
return num.ToString();
}
set
{
try
{
num = Convert.ToInt32(value);
}
catch
{
num = 0;
}
}
}
public int Square // read only property
{
get
{
return num * num;
}
}
}
class Program
{
static void Main()
{
myNumber obj = new myNumber();
obj.Num = Console.ReadLine();
Console.WriteLine("Square of {0} is {1}", obj.Num, obj.Square);
Console.Read();
}
}
ကဲ ဒီေန႔ေတာ့ database အပိုင္းေလး ခဏနားျပီး C# ဘက္ကို နည္းနည္းျပန္လွည့္ေအာင္။

ကြၽန္ေတာ္တို႔ အခုေနာက္ပိုင္း programming language မွာ အသံက်ယ္က်ယ္ေလာင္ေလာင္
ျဖစ္လာတာက OOT လို႔ ေခၚတဲ႔ Object-Oriented Technique ပဲျဖစ္ပါတယ္။ OO မွာ
ဘာေတြပါလဲ…
အေမြဆက္ခံျခင္းလို႔ ေခၚတဲ႔ inheritance၊
အသြင္ေျပာင္းျခင္း လို႔ေျပာလို႔ရတဲ႔ Polymorphism၊
Data hiding လိ႔ေ

ု ခၚတဲ႔ member data ေတြကို သို၀ွက္သိမ္းဆည္းထားျခင္း၊
Encapsulation သိမ္းဆည္းထားတဲ႔ member data ေတြကို တဆင့္ခံျဖင့္ သံုးခြင့္ေပးျခင္း၊
စသည္ျဖင့္ေပါ႔ဗ်ာ.. အဲ့ဒါေတြ ပါပါတယ္။
Inheritance အေမြဆက္ခံျခင္းဆိုတာဘာလဲ???
ဒီလိုေလးေတြးၾကည့္ရေအာင္ဗ်ာ အခုကြၽန္ေတာ္တို႔ မိဘေတြပိုင္ဆိုင္တဲ႔ ပိုင္ဆိုင္မႈေတြဟာ

ကြၽန္ေတာ္တို႔ရဲ႕ ပိုင္ဆိုင္မႈေတြပါပဲ။ ဒီလိုပါပဲ ကြၽန္ေတာ္တို႔ရဲ႕ ပိုင္ဆိုင္မႈေတြကိုလည္း ကြၽန္ေတာ္တ႔ရ
ို ဲ႕
မ်ိဳးဆက္သစ္ေတြက ပိုင္ဆိုင္ၾကဦးမွပါ။ ဒီသေဘာတရားေလးကို ယူျပီး OOမွာ inheritance
ဆိုတာေပၚေပါက္လာတာပါ။ class တစ္ခုရဲ႕ ပိုင္ဆိုင္မႈ property ေတြဟာ အဲ့ဒ ီ class ရဲ႕ child
ေတြကလည္း ပိုင္ဆိုင္နိုင္ပါတယ္။ ဒီလို ပိုင္ဆိုင္နိုင္ျခင္းအားျဖင့္ ကြၽန္ေတာ္တို႔က class ေတြအားလံုး
အတြက္ တူညီတဲ႔ property ေတြကို အၾကိမ္ၾကိမ္ေၾကျငာေပးေနစရာ မလိုေတာ့ပါဘူး။ ဥပမာဗ်ာ
ကြၽန္ေတာ္က လူတစ္ေယာက္ကို ကိုယ္စားျပဳမယ့္ class တစ္ခုေဆာက္မယ္ဆိုရင္ အဲ့ဒီ class ထဲမွာ
ဘယ္လို member ေတြပါမလဲ စဥ္းစားၾကည့္၊ နံမည္ပါမယ္၊ အသက္ပါမယ္၊ ေနရပ္လိပ္စာပါမယ္ဗ်ာ၊
စသည္ျဖင့္ေပါ့။
class People
{
string Name;
int Age;
string Address;
}
ကဲ…အခု ေနာက္တစ္ခါ ကြၽန္ေတာ္က ေက်ာင္းသားတစ္ေယာက္ကို ကိုယ္စားျပဳမယ့္ class

တစ္ခုထပ္ေဆာက္ဖို႔ လိုလာျပီဆိုရင္ေရာ ဘယ္လို member ေတြပါမလဲ၊ ေက်ာင္းသားမွာလည္း
နံမယ္ပါမယ္၊ အသက္ပါမယ္၊ လိပ္စာပါမွာပါပဲ၊ ေက်ာင္းသားမွာ ပိုပါလာတာက roll နံပါတ္ပါမယ္၊

class ပါပါမယ္။
class Student
{
string Name;
int Age;
string Address;
int Roll;
int Class;
}
ဟုတ္ျပီ ဒီလိုအေျခအေနမ်ိဳးမွာ နံမည္တို႔ အသက္တို႔ကို ထပ္ျပီး မေၾကျငာခ်င္ဘူးဆိုရင္ ကြၽန္ေတာ္တို႔

Student class ကို People class ရဲ႕ child အျဖစ္ ေၾကျငာလို႔ ရပါတယ္။ ဒီလိုမ်ိဳးပါ…
class Student : People

{
int Roll;
int Class;
}
ဒါကို inheritance လုပ္တယ္လ႔ို ေခၚပါတယ္။ inheritance လုပ္လုိက္ျခင္းအားျဖင့္ People class

ထဲက member data ကို Student class ထဲမွာ ျပန္ျပီ ေၾကျငာေပးေနစရာ မလုိေတာ့ပါဘူး။
ဒါေပမယ့္ ဒီေနရာမွာ အေရးၾကီးတဲ႔ အခ်က္တစ္ခ်က္ကို သိထားဖို႔ လိုပါေသးတယ္။ ဒီလိုဗ်ာ
ကြၽန္ေတာ္တို႔ မိဘရဲ႕ ပိုင္ဆိုင္မႈအားလံုး ကြၽန္ေတာ္တို႔ရမလား၊ မရပါဘူး သူတို႔ ကိုယ္ပိုင္အတြက္
သိမ္းထားတာေတြလည္း ရွိနိုင္ပါတယ္။ C# language မွာလဲ အဲ့ဒီလိုမ်ိဳး ခြဲျခားဖို႔အတြက္
ကြၽန္ေတာ္တို႔ Access Modifier ဆိုတာကို သိဖို႔လိုအပ္လာပါတယ္။ C# language မွာ access
modifier ၅ မ်ိဳးရွိပါတယ္။ အဲ့ဒါေတြ ကေတာ့
- public ( အမ်ားသံုး )
- protected ( မိမိႏွင့္child ေတြသံုး )
- private ( မိမိကိုယ္တိုင္သံုး )
- internal ( library တူအတြင္းသံုး )
- protected internal ( child ျဖစ္လွ်င္၄င္း၊ library တူလွ်င္၄င္း သံုး )
စသည္တ႔ို ျဖစ္ပါတယ္။ အေပၚက example People class ေလးမွာ ကြၽန္ေတာ္တို႔ access modifier
မထည့္ေပးလိုက္ပါဘူး။ ဒါဆိုရင္ default အေနနဲ႔ private ပါ။ ဒါေၾကာင့္ People class ထဲက
member data သံုးခုက people class အတြင္းမွာပဲ သံုးခြင့္ရွိပါတယ္။ Student မွာ သံုးလို႔ မရပါဘူး။
အခုကြၽန္ေတာ္တို႔က Student class ထဲကေနပါ သံုးခြင့္ရခ်င္တာျဖစ္လို႔ protected member
အျဖစ္ေၾကျငာေပးရမွာပါ။
class People
{
protected string Name;
protected int Age;
protected string Address;
}
Polymorphism အသြင္ေျပာင္းျခင္းဆိုတာကေရာ???
ကြၽန္ေတာ္တို႔ ရပ္ကြက္ေတြမွာ လုပ္ေလ့ရွိတယ္ဗ်ာ တခါတေလ ရပ္ကြက္ရံုး ကေနျပီးေတာ့

တစ္အိမ္ကို လူတစ္ေယာက္ႏႈန္း အစည္းအေ၀းတက္ရမယ္တို႔ ဘာတို႔ ၾကံဳဖူးမွာေပါ့။ ဟုတ္ကဲ႔
ရပ္ကြက္ရံုးက ေခၚတာက လူတစ္ေယာက္လို႔ ေခၚတာပါ တနည္းအားျဖင့္ people class ကို
ေခၚတာပါ။ အဲ့ဒါကို အိမ္မွာ ရွိေနတဲ႔ ေက်ာင္းသားတစ္ေယာက္က သြားတက္လို႔ မရဘူးလား၊
ရပါတယ္။ Teacher တစ္ေယာက္သြားတက္မယ္ဆိုလို႔လဲ ရပါတယ္။ Teacher ကလည္း people
တစ္ေယာက္ပဲ ျဖစ္လို႔ပါ။ ဒါေပမယ့္ Student ပဲ သြားသည္ျဖစ္ေစ၊ Teacher ပဲသြားသည္ျဖစ္ေစ၊
ဒါမွမဟုတ္ People ကိုယ္တိုင္ပဲ သြားသည္ျဖစ္ေစ၊ အားလံုးကို People လိ႔ပ
ု ဲ ျမင္ပါတယ္။ အားလံုး
အခြင့္အေရးတန္းတူပါပဲ။ Student မိ႔ု အခြင့္အေရးပိုရမလား မရပါဘူး။ အိုေက အဲ့ဒီလိုမ်ိဳး People
ကိုေခၚတာကို Stuent သြားလိုက္တာကို အသြင္ေျပာင္းလဲျခင္း ( polymorphism ) လိ႔ု ေခၚပါတယ္။
static void Main()

{
People p;
p = new Student();
}
Polymorphism မွာ သတိထားရမည့္ အခ်က္ကေတာ့ child ကို parent အသြင္ေျပာင္းနိုင္ေပမယ့္

parent ကိုေတာ့ child အျဖစ္ေျပာင္းလို႔ မရပါဘူး။ ဆိုလိုတာကေတာ ေက်ာင္းသားအားလံုး
စာေမးပြဲလာေျဖပါဆိုျပီး ေခၚတာကို အိမ္မွာ ရွိတဲ႔ လူၾကီးေတြသြားေျဖလို႔ ရမလား မရပါဘူး၊
ဒီသေဘာပါ။ Student ကိုေတာင္းရင္ေတာ့ People ေပးလို႔ မရပါဘူး၊ Student ပဲ ေပးမွ ရမွာပါ။
Data Hiding
Data hiding ဆိုတာကေတာ့ ကြၽန္ေတာ္တို႔ အိမ္မွာ မိသားစုပိုင္ဆိုင္မႈေတြကို တျခားလူေတြသိေအာင္

ထုတ္ေၾကျငာေလ့ရွိလား? မရွိပါဘူး တိတ္တိတ္ေလးပဲ သိမ္းထားေလ့ရွိပါတယ္။ ဒီသေဘာပါပဲ class
ေတြထဲမွာရွိတဲ႔ member data ေတြကိုလည္း အျပင္ကေန ေခၚလို႔မရေအာင္ private လုပ္ထားျခင္းကို
data hiding လိ႔ု ေခၚပါတယ္။ ဥပမာဗ်ာ အခု student class ထဲမွာ roll နဲ႔ class ပါတယ္မလား၊ အဲ့ဒီ
member data ေတြကို အျပင္ကေန ေခၚသံုးလို႔ မရပါဘူ။ ဘာလို႔လဲဆိုေတာ့ private member data
ေတြ ျဖစ္လ႔ပ
ို ါ။ ဒီလုိမ်ိဳး class member data ေတြကို private အျဖစ္ပဲ ေၾကျငာတာကို Data Hiding
လို႔ေခၚပါတယ္။
Encapsulation
Encapsulation ဆိုတာကေတာ့ ကြၽန္ေတာ္တို႔ hide လုပ္ထားတဲ႔ data ထဲက လိုအပ္တဲ႔ dataေတြကို

function ေတြကေနေသာ္လည္းေကာင္း၊ property ေတြကေနတဆင့္ေသာ္လည္းေကာင္း၊
အသံုးျပဳနိုင္ဖို႔အတြက္ စီမံေပးျခင္းပဲ ျဖစ္ပါတယ္။ ကြၽန္ေတာ္တို႔ C# မွာေတာ့ member data ေတြကို
ကိုယ္စားျပဳဖို႔အတြက္ property ေတြကိုသံုးေလ့ရွိပါတယ္။ ဒီလိုမ်ိဳးပါ..
class Student : People

{
int Roll;
int Class;
public int RollNo
{
get
{
return Roll;
}
set
{
Roll = value;
}
}
public int ClassID
{
get
{
return Class;
}
set
{
Class = value;
}
}
}
Chapter 9
Function Overloading Vs Function Overriding
ကြၽန္ေတာ္တို႔ ဒီေန႔ function overloading နဲ႔ function overriding အေၾကာင္းေလး

ေျပာၾကရေအာင္။ အရင္ဆံုး function overloading အေၾကာင္းေျပာရေအာင္။ overload ဆိုတာ
အလုပ္တစ္ခုထက္ပိုျပီး လုပ္တာကို ေျပာခ်င္တာပါ။ function overloading ဆိုေတာ့ ကြၽန္ေတာ္တို႔
ေရးလိုက္တဲ႔ function က တာ၀န္ တစ္ခုထက္ပိုျပီး လုပ္ေဆာင္ေပးတာကိုရည္ရြယ္တာပါ။ function
name က တစ္ခုထဲပဲ ဒါေပမယ့္ လုပ္ေဆာင္မႈအမ်ားၾကီး လုပ္နိုင္ေအာင္ေပါ့။ ဥပမာဗ်ာ.. ကြၽန္ေတာ္က
string ကေန integer ေျပာင္းတဲ႔ function ေလးတစ္ခုေလာက္ ေရးခ်င္တယ္။
static int ConvertToInteger(string st)

{
try
{
return Convert.ToInt32(st);
}
catch
{
return 0;
}
}
ကဲ.. ဒီ function ေလး ေရးလိုက္ျခင္းအားျဖင့္ ကြၽန္ေတာ္တို႔ string ကေန integer ေျပာင္းခ်င္တိုင္း

လြယ္လြယ္ကူကူ ေခၚလို႔ ရသြားမယ္။ ဒါေပမယ့္ တျခား type ေတြကေနေျပာင္းခ်င္ရင္ ဒီ function
သံုးလို႔ ရမလား။ မရပါဘူး။ ဒါဆို ကြၽန္ေတာ္က တျခားtype ေတြ အတြက္ကိုလည္း ဒီလိုမ်ိဳး function
ေတြ ထပ္ေရးေပးဖို႔ လိုပါလိမ့္မယ္။
static int ConvertToInteger(decimal dec)

{
try
{
return Convert.ToInt32(dec);
}
catch
{
return 0;
}
}
static int ConvertToInteger(long l)
{
try
{
return Convert.ToInt32(l);
}
catch
{
return 0;
}
}
ဟုတ္ျပီေနာ္.. အခုလိုမ်ိဳး function name တူျပီး parameter မတူတဲ႔ function ေတြ တစ္ခုထက္ပိုျပီး
ေရးလိုက္တာကို function overloading လုပ္တယ္လို႔ ေခၚပါတယ္။ function overloading လုပ္ျခင္း
အားျဖင့္ ဘာပိုေကာင္းလာမလဲ။ ဟုတ္ကဲ႔ ကြၽန္ေတာ္တို႔ program ေရးတဲ႔ေနရာမွာ အမ်ားၾကီးပိုျပီး
လြယ္ကူေစပါတယ္။ အကယ္လို႔သာ function overload မလုပ္ရဘူးဆိုရင္ ကြၽန္ေတာ္တို႔ string
ကေန integer ေျပာင္းဖို႔အတြက္က function name တစ္ခု၊ decimal ကေန integer
ေျပာင္းဖို႔အတြက္က function name တစ္ခု၊ long ကေန integer ေျပာင္းဖို႔အတြက္က function
name တစ္ခု စသည္ျဖင့္ name ေတြ အမ်ားၾကီး သံုးေနမွတ္ေနရမွာေပါ့။ အခု overloading
လုပ္ျခင္းအားျဖင့္ function name တစ္ခုထဲကိုပဲ သိဖို႔ လိုပါေတာ့တယ္။ Framework class library
ထဲမွာလည္း overload လုပ္ထားတဲ႔ function ေတြ အမ်ားၾကီး ေတြရမွာပါ။ ကဲ
အႏွစ္ခ်ဳပ္ျပန္ေျပာပါမယ္ function overloading ျဖစ္ဖ႔အ
ို တြက္ function name တူရပါမယ္၊
argument (parameter) မတူရပါဘူး။ parameter မတူရဘူး ဆိုတာမွာ parameter ရဲ႕ datatype
ျဖစ္ေစ၊ အရည္အတြက္ ျဖစ္ေစမတူရင္ ရပါတယ္။
ေနာက္တစ္ခုကေတာ့ function overriding။ overriding လိ႔ု ေျပာတဲ႔ အတိုင္းပါပဲ၊ function

overrideing ဆိုတာက function တစ္ခုေပၚမွာ ေနာက္ထပ္ function တစ္ခုန႔ဲ ထပ္ျပီး အုပ္လိုက္တာကို
ေျပာခ်င္တာပါ။ ဒီလိုလုပ္လိုက္ရင္ function ၂ ခု ျဖစ္သြားမလား၊ မျဖစ္ပါဘူး။ override

လုပ္ျခင္းခံရတဲ႔ function က ေပ်ာက္သြားမွာပါ။ function overrideing ကို အဓိကအားျဖင့္
polymorphism နဲ႔ တြဲျပီးသံုးေလ့ ရွိပါတယ္။ parent class ထဲမွာ ရွိျပီးသား function တစ္ခုကို child
class ထဲမွာျပန္ျပီးေရးခ်င္တယ္ ဆိုရင္ override လုပ္ဖို႔ လိုလာပါျပီ။ ဒီလို အခ်ိန္မ်ိဳးမွာ function
overriding ကိုသံုးပါတယ္။ ဥပမာေလးနဲ႔ ေျပာရရင္… ကြၽန္ေတာ္မွာ animal ဆိုတဲ႔ class ရွိတယ္ဗ်ာ၊
parent class ေပါ့၊ အဲ့ဒီ animal class ထဲမွာ eat() ဆိုတဲ႔ function ေလးပါတယ္။
class animal
{
public void eat()
{
Console.WriteLine("Eat something");
}
}
အိုေက.. အဲ့ဒီ animal class မွာ child class ၂ ခုရွိတယ္။ dog class နဲ႔ ant class ေပါ့။ အဲ့ဒီ dog
class နဲ႔ ant class က animal class ကေန inheritance လုပ္ထားတာျဖစ္တဲ႔ အတြက္ သူတို႔ဆီမွာ
eat() function အလိုအေလွ်ာက္ ပါလာပါတယ္။ အဲ့ဒီ parent class ကေနပါလာတဲ႔ eat() function
ထဲက statement ေတြကို child class မွာ မလိုခ်င္ဘူး။ ပိုျပီး detail ၾကတဲ႔ message နဲ႔
အစားထိုးခ်င္တယ္ဆိုပါေတာ့ (ဥပမာ.. Eat something အစား၊ Eat Bone တိ႔ု Eat sugur တိ႔န
ု ဲ႔
အစားထိုးခ်င္ျပီဆိုရင္)၊ ဒါဆို ဘယ္လိုလုပ္မလဲ? ေနာက္ထပ္ function တစ္ခုထပ္ေဆာက္ခ်င္တာ
မဟုတ္ဘူးေနာ္၊ parameter လည္း မေျပာင္းတဲ႔ အတြက္ overloading လည္း လုပ္လ႔ို မရဘူး။ ဒီလို
အေျခအေနမ်ိဳးမွာ ကြၽန္ေတာ္တို႔ မျဖစ္မေန function overriding လုပ္ဖ႔ို လိုလာပါျပီ။
ဒါဆို function overriding လုပ္ဖ႔ို ဘာလိုမလဲ? Parent class ထဲမွာ ဒီတိုင္းေရးထားတဲ႔ function
တိုင္းကိုေတာ့ override လုပ္လို႔ မရပါဘူး။ override လုပ္ဖ႔ို ခြင့္ျပဳထားတဲ႔ function ေတြကိုပဲ
လုပ္လို႔ရတာပါ။ ဒီလို override လုပ္ဖ႔ို ခြင့္ျပဳခ်င္တယ္ဆိုရင္ parent class ထဲက function ရဲ႕ေရွ႕မွာ
virtual ဆိုတ႔ဲ keyword ေလးထည့္ေရးေပးလိုက္ရပါတယ္။
class animal
{
public virtual void eat()
{
Console.WriteLine("Eat something");
}
}
override ျပန္လုပ္မယ့္ child class က function ေရွ႕မွာေတာ့ override ဆိုတ႔ဲ keywordကို

ထည့္ေပးရပါတယ္။
class dog : animal

{
public override void eat()
{
Console.WriteLine("Eat Bone!");
}
}
ကဲ… example program ေလး တစ္ခုေလာက္ေရးၾကည့္ပါဦး။
class animal
{
public virtual void eat()
{
Console.WriteLine("Animal: Eat something");
}
}
class dog : animal
{
public override void eat() // function overriding
{
Console.WriteLine("Dog: Eat Bone!");
}
}
class ant : animal
{
public override void eat()
{
Console.WriteLine("Ant: Eat Sugar");
}
}
class Program
{
static void Main()
{
animal obj;
obj = new animal();
obj.eat();
obj = new dog(); //polymorphism

obj.eat();
obj = new ant();

obj.eat();
Console.Read();
}
}
Basic of C# ကို ကြၽန္ေတာ္ဒီမွာပဲ ရပ္လိုက္ပါေတာ့မယ္။ အခုေလာက္ဆိုရင္ ကြၽန္ေတာ္တ႔ို C# ဆိုတာ

ဘာလဲသိေလာက္ပါျပီ။ OOP အေၾကာင္းလည္း နည္းနည္းေတာ့ နားလည္ေလာက္ျပီလ႔ို ယူဆပါတယ္။
ေနာက္ပိုဒ႔္ေတြမွာ window application အပိုင္းနဲ႔ web application အပိုင္းကို
ဆက္ေရးသြားပါ့မယ္ခင္ဗ်ာ။
Graphics And Random
Graphics Class
ကြၽန္ေတာ္တို႔ ပံုေတြဆြဲခ်င္ျပီဆိုရင္ ဘာေတြလိုအပ္မလဲ။ အရင္ဆံုး ဆြဲဖို႔အတြက္

ေနာက္ခံတစ္ခုလိုပါမယ္။ စာရြက္ေသာ္လည္းေကာင္း၊ နံရံေသာ္လည္းေကာင္း၊ ပိတ္ကား
ေသာ္လည္းေကာင္းေပါ့။ ေနာက္ျပီး ဆြဲမယ့္ ခဲတံျဖစ္ျဖစ္ စုတ္တံျဖစ္ျဖစ္လိုပါမယ္။ ဒီ ၂
ခုရွိျပီဆိုရင္ေတာ့ ကြၽန္ေတာ္တို႔ ပံုေတြ ဆြဲလို႔ရပါၿပီ။ ဒီအတုိင္းပါပဲ ကြၽန္ေတာ္တို႔ C# window
application မွာ graphic ပံုေတြ ဆြဲဖို႔ လိုအပ္လာျပီဆိုရင္လည္း ဆြဲခ်င္တဲ႔ ေနာက္ခံ object နဲ႔ ဆြဲမယ့္
pen or brush လိုအပ္ပါတယ္။ တကယ္ဆြဲတဲ႔ အလုပ္ကိုေတာ့ graphics object
ကေနတဆင့္လုပ္ေပးရပါမယ္။ အရင္ဆံုး Graphics Class ကို object ေဆာက္ရပါမယ့္။ ဒီလို
ေဆာက္တဲ႔အခါ ကြၽန္ေတာ္တို႔ ဆြဲခ်င္တဲ႔ ေနာက္ခံobject ကေနတဆင့္ CreateGraphic() ဆိတ
ု ဲ႔
function ကိုသံုးၿပီးေဆာက္ရမွာပါ။ ဒီလိုမ်ိဳးပါ..
Graphics g = this.CreateGraphics(); // form ေပၚမွာ ဆြဲရန္…
Graphics g = label1.CreateGraphics(); // label ေပၚမွာ ဆြဲရန္…
ေနာက္ခံကိုေရြးၿပီးၿပီဆိုရင္ အခုလိုအပ္တာက ဆြဲမယ့္ ခဲတံပါ။ ကြၽန္ေတာ္ဆြဲမယ့္ပံုမွာ outline

အနားသပ္ပဲ ပါမယ္ဆိုရင္ Pen class ကိုသံုးရၿပီး။ အတြင္းသား ကိုပါ အေရာင္ျဖည့္မယ္ဆိုရင္ေတာ့
Brush class ကိုသံုးရပါမယ္။ ကြၽန္ေတာ္လိုခ်င္တဲ႔ အေရာင္ကိုလည္း တခါတည္း

ေျပာေပးလိုက္ပါမယ္။
Pen p = new Pen (Color.Red); // အနီေရာင္ ခဲတံေလး တစ္ခုယူလိုက္တာပါ။
လိုင္းရဲ႕ အထူအပါးကိုပါ ခ်ိန္ေပးလို႔လည္း ရပါတယ္။ pen class မွာ width property မွာ
ျပင္ေပးလို႔ရပါတယ္။
p.Width = 2; // line အထူ 2 pixel ယူပါမယ္။
ဒါမွမဟုတ္… Pen object ေဆာက္တုန္းမွာပဲ constructor ထဲမွာတခါတည္း ထည့္ေပးလိုက္လည္း

ရပါတယ္။
Pen p = new Pen (Color.Red, 2);
Brush object ေဆာက္ရင္ေတာ့ တစ္ခ်က္သတိထားရမွာက Brush class ကိုယ္တိုင္ကို object

ေဆာက္လို႔ မရပါဘူး။ သူ႔ရ႕ဲ child class (SolidBrush, LinearGradientBrush,…) ေတြကိုပဲ object
ေဆာက္လို႔ရပါတယ္။
Brush b = new SolidBrush (Color.Green); // အစိမ္းေရာင္ စုတ္တံေလးတစ္ခုယူလိုက္တာပါ။
ကဲ.. အခုေနာက္ဆံုး ကြၽန္ေတာ္တို႔ တကယ္ဆြဲပါေတာ့မယ္။ Pen ကိုသံုးမယ္ဆိုရင္ Draw function

ေတြကိုသံုးရျပီး၊ Brush ကိုသံုးမယ္ဆိုရင္ေတာ့ Fill Function ကို သံုးရပါတယ္။ အခုကြၽန္ေတာ္ width
100, height 100 ရွိတဲ႔ အစိမ္းေရာက္ box ေလးကို အနီေရာင္အနားကြပ္ေလးနဲ႔
လိုခ်င္တယ္ဆိုရင္…..
Graphics g = this.CreateGraphics();
Pen p = new Pen(Color.Red, 2);
Brush b = new SolidBrush(Color.Green);
g.FillRectangle(b, 10, 10, 100, 100);
g.DrawRectangle(p, 10, 10, 100, 100);
ေနာက္သိဖို႔ တစ္ခုလိုေသးတာက ဒီကုဒ္ေတြေရးရမယ့္ event ပါ။ Form စေပၚလာလာခ်င္းမွာ

ေပၚခ်င္ရင္ Form_Paint event မွာ ေရးရပါမယ္။ Button တစ္ခုခုကိုႏွိပ္မွ ဆြဲမယ္ဆိုရင္ေတာ့ အဲ့ဒီ
button_click event မွာ ေရးရမွာေပါ့။ Paint event မွာ မေရးထားတာေတြ အားလံုးက form ကို
Minimax လုပ္လိုက္ရင္ အကုန္ ေပ်ာက္သြားမွာပါ။
Random Class
ကြၽန္ေတာ္တို႔ C# programming language မွာ random ေခါက္ခ်င္ၿပီဆိုရင္ Random Class

ကိုသံုးရပါတယ္။ Random ေခါက္တယ္ဆိုတာက သက္မွတ္ထားတဲ႔ range တစ္ခုအတြင္းမွာ
ျဖစ္ခ်င္တာျဖစ္ဆိုျပီး တစ္ခုကို ေရြးလိုက္တာပါ။
Random rnd = new Random();
rnd.Next(); // Integer value တစ္ခု return ျပန္ပါတယ္။
rnd.Next(10); // 0 – 9 ထဲက value တစ္ခု return ျပန္ပါတယ္။
rnd.Next(2, 6); // 2 – 5 ထဲက value တစ္ခု return ျပန္ပါတယ္။
ကဲ ဟုတ္ၿပီ အခုကြၽန္ေတာ္က ခုန rectangle ေလးရဲ႕ location ေလးကိုကို form ေပၚမွာ random
ေပၚေအာင္ ေရးၾကည့္ရေအာင္။
int x = rnd.Next(this.ClientSize.Width);
int y = rnd.Next(this.ClientSize.Height);
Graphics g = this.CreateGraphics();
Pen p = new Pen(Color.Red, 2);
Brush b = new SolidBrush(Color.Green);
g.FillRectangle(b, x, y, 100, 100);
g.DrawRectangle(p, x, y, 100, 100);
Basic Window Application (Part 1)
Event
Window Form Application ေတြမွာ အေရးၾကီးတဲ႔ အစိတ္အပိုင္း တစ္ခုအေနနဲ႔

သိဖို႔လာလိုလာတာက Event ဆိုတာေလးပါ။ ဟုတ္ျပီ… Event ဆိုတာဘာလဲ? Event ဆိုတာကို
အလြယ္ေျပာရရင္ အျဖစ္အပ်က္တစ္ခုလို႔ ေျပာရပါမယ္။ အျပင္ေလာကမွာ မိုးရြာတယ္၊ မိုးခ်ိန္းတယ္၊
ေလတိုက္တယ္၊ အုန္းသီးေၾကြတယ္ စသည္ျဖင့္ေပၚ အဲ့ဒီလို ျဖစ္သြားတာေတြ အားလံုးကို Event
လို႔ ေျပာလို႔ ရမယ္ထင္ပါတယ္။ ကြၽန္ေတာ္တို႔ Programming မွာ လည္း user ရဲ႕
လုပ္ေဆာင္မႈေပၚမူတည္ျပီး ျဖစ္ပ်က္သြားတာေတြ အားလံုးကို Event လို႔ေခၚပါတယ္။ User က
Window Form ေပၚမွာ Mouse ကို ႏွိပ္လိုက္ရင္ ႏွိပ္တယ္ ဆိုတဲ႔ အျဖစ္အပ်က္ျဖစ္ပါတယ္။ ဒီလိုပါပဲ
Form ၾကီးကို ပိတ္လိုက္ရင္လည္း Form ပိတ္တယ္ဆိုတဲ႔ အျဖစ္အပ်က္ျဖစ္သြားပါတယ္။ အဲ့ဒီလိုမ်ိဳး
User ရဲ႕ action တိုင္း အတြက္ Event ေတြျဖစ္ေနပါတယ္။ အဲ့ဒီလို Event ေတြ ျဖစ္သြားတဲ႔ အခ်ိန္မွာ
ကြၽန္ေ တာ္တို႔ programmer ေတြက user ေတြကို ျပန္ျပီး ေပးခ်င္တဲ႔ response ေတြ
ရွိလာျပီဆိုရင္ေတာ့ အဲ့ဒ ီ အတြက္ Coding ေတြ ေရးေပးရပါမယ္။ ( ဥပမာ user က form ကို click
လုပ္ရင္ Hello လိ႔ု user ကို ျပခ်င္တယ္။ ဒါမွမဟုတ္ form ေပၚမွာ mouse ေရႊ႕ရင္ mouse pointer
ရဲ႕ location ေလး ျပခ်င္တယ္။ စသည္ျဖင့္ေပါ..)။ အဲ့ဒီလို ေရးဖို႔ လုပတ
္ ာကို Event Handling
လုပ္တယ္လို႔ ေခၚပါတယ္။ Event ကို Handle လုပ္တာကလည္း အေရးၾကီးပါတယ္။ ကြၽန္ေတာ္တို႔
ကုဒ္ေတြ မေရးခင္ အရင္ဆံုး ဘယ္ event မွာ ေရးရမွာလဲ ဆိုတာကို ခြဲျခားေရြးနိုင္ဖို႔ လိုပါတယ္။
ကြၽန္ေ တာ္က Mouse_Click Event မွာ ေရးရမယ္ ကုဒ ္ကို Key_Press Event မွာ သြားေရးရင္
Mouse ႏွိပ္တ႔အ
ဲ ခါ အလုပ္လုပ္မွာ မဟုတ္ပါဘူး။
အခုကြၽန္ေတာ္တို႔ window form ရဲ႕ event ေလးေတြကို နည္းနည္း ေလ့လာလိုက္ရေအာင္။ Form

မွာ ပထမဆံုး သိဖို႔လိုတဲ႔ event က Load Event ပါ။ ကြၽန္ေတာ္တို႔ Form object ကို memory
ေပၚဆြဲတင္တဲ႔ အခ်ိန္မွာ form load event ျဖစ္ပါတယ္။ form load event က form ၾကီး screen မွာ
မေပၚခင္ျဖစ္တာ ျဖစ္တဲ႔အတြက္ေၾကာင္း form မွာ initialize လုပ္ဖ႔ို လိုတဲ႔ အပိုင္းေတြကို form load
ထဲမွာ ေရးေပးေလ့ရွိတယ္။ ဥပမာ.. ကြၽန္ေတာ္က form ေပၚလာတာနဲ႔ form background color ကို
random color ေလး ျဖစ္ေစခ်င္တယ္ဆိုရင္ form load event ထဲမွာ ဒီလိုေလး ေရးေပးရမွာပါ….
private void Form1_Load(object sender, EventArgs e)

{
this.BackColor = Color.FromArgb(rnd.Next(256), rnd.Next(256), rnd.Next(256));
}
ဒီလိုပါပဲ.. form ၾကီး ေပၚေနတဲ႔ အခ်ိန္မွာ form ေပၚမွာ click ႏွိပ္တိုင္းမွာလည္း

ကာလာေျပာင္းေနခ်င္တယ္ ဆိုရင္ Form ရဲ႕ Click Event မွာပါ သြားေရးေပးရမွာပါ။
private void Form1_Click(object sender, EventArgs e)

{
this.BackColor = Color.FromArgb(rnd.Next(256), rnd.Next(256), rnd.Next(256));
}
အခုကြၽန္ေတာ္က form ကို user က ပိတ္လိုက္တဲ႔ အခ်ိန္မွာ user ကို ပိတ္မွာ ေသခ်ာလားဆိုျပီး
confirm message ေလး ေမးခ်င္တယ္ဆိုပါေတာ့… ဒါဆိုရင္ ဘယ္မွာ ေရးရမွာလဲ ? ဟုတ္ကဲ႔ Form
ရဲ႕ FormClosing Event မွာ ေရးရပါမယ္။ ဒီလိုမ်ိဳးပါ…
Pic_1
private void Form1_FormClosing(object sender, FormClosingEventArgs e)

{
DialogResult res = MessageBox.Show("Sure to close?", "Confirm...",
MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
if (res == DialogResult.No)
e.Cancel = true;
}
MessageBox class ထဲက show function ေလးကို ေခၚလိုက္ရင္ ကြၽန္ေတာ္တို႔ form ေပၚမွာ dialog
form ေလး တစ္ခု ျပေပးပါတယ္။ dialog form ဆိုတာက အဲ့ဒ ီ form ေပၚေနရင္ တျခား form ေတြကို
အလုပ္ဆက္လုပ္လို႔ မရပါဘူး။ အဲ့ဒီ dialog form ပိတ္သြားမွ အလုပ္ဆက္လုပ္လို႔ ရပါတယ္။ အဲ့ဒီ

MessageBox form ေလးရဲ႕ Show function မွာ အဓိက parameter ၄ ခု ေပးလို႔ ရပါတယ္။
၁ – ေပၚခ်င္တဲ႔ Message ( here : Sure to close? )

၂ – Title bar Text ( here : Confirm… )
၃ – ေပၚခ်င္တဲ႔ Button အမ်ိဳးအစားေတြ ( here : Yes and No )
MessageBoxButtons ဆိုတဲ႔ enum ေလးထဲက တန္ဖိုး တစ္ခုခုေရြးေပးရပါမယ္။ default ကေတာ့
OK button ပါ။
၄ – ေပၚခ်င္တဲ႔ Icon ( here : Warning )
ဒါလည္း တူတူပါပဲ… MessageBoxIcon အမ်ိဳးအစား enum ပါ။
ဒီ parameter ၄ ခုကို နံပါတ္ ၁ တစ္ခုထဲ ေပးမယ္ဆိုလည္း ရပါတယ္။ ဒါေပမယ့္ နံပါတ္ ၂

ပဲေပးမယ္ဆိုရင္ေတာ့ မရပါဘူး။ နံပါတ္ ၃ ကိုေပးခ်င္တယ္ဆိုရင္ နံပါတ္ ၁ ေရာ နံပါတ္ ၂ ပါေပးမွ
ရပါမယ္။
Dialog form ေတြအားလံုး ပိတ္သြားတဲ႔ အခ်ိန္မွာ DialogResult အမ်ိဳးအစား enum တစ္ခု return
ျပန္ပါတယ္။ အခု ျပန္လာတဲ႔ return value ကို ကြၽန္ေတာ္က No နဲ႔ ညီလား ဆိုျပီး စစ္လိုက္ပါတယ္။
(ကြၽန္ေတာ္က MessageBoxButtons မွာ YesNo ကိုေရြးလိုက္တဲ႔အတြက္ Return value ဟာ Yes
ေသာ္လည္းေကာင္း၊ No ေသာ္လည္းေကာင္း return ျပန္ပါ့မယ္။ ) ကြၽန္ေတာ္တို႔ အခုေရးေနတဲ႔
Event က form ပိတ္တဲ႔ event ျဖစ္တဲ႔အတြက္ User က Yes ကိုႏွိပ္ရင္ ကြၽန္ေတာ္တို႔က ဘာမွ
လုပ္ေပးစရာ မလိုပါဘူး။ အဲ.. User က No ကိုႏွိပ္ရင္ေတာ့ ကြၽန္ေတာ္တို႔က Form မပိတ္ေအာင္
e.Cancel ထဲကို true value သြားထည့္ေပးရပါတယ္။ ဒါဆို form မပိတ္ေတာ့ပါဘူး။ ခုေလာက္ဆို
Event ဆိုတာကို နည္းနည္း နားလည္လာမယ္ ထင္ပါတယ္။
Event 2 (Mouse Event)
ဒီေန႔ ကြၽန္ေတာ္တို႔ window form application ရဲ႕ event ေတြ အေၾကာင္းပဲ ဆက္ရေအာင္။
အခုကြၽန္ေတာ္က program run လိုက္ျပီး form ေပၚမွာ mouse ေရႊ႕ရင္ အဲ့ဒီ mouse pointer ရဲ႕
location ေလးကို form ရဲ႕ caption မွာ ျပခ်င္တယ္ဆိုပါေတာ့။ ဒါဆိုရင္ ကြၽန္ေတာ္က ဘယ္ event
ကိုသံုးရမလဲ ဆိုရင္ Form ရဲ႕ Mouse Move Event ကိုသံုးရပါမယ္။
private void Form1_MouseMove(object sender, MouseEventArgs e)

{
this.Text = e.Location.ToString();
}
ကြၽန္ေ တာ္က form Title bar မွာ မျပခ်င္ဘူး mouse pointer ေလးရဲ႕ ေဘးမွာ ပဲ location ေလးကို
ေပၚေနေစခ်င္တယ္ဆိုရင္ေတာ့ Form ေပၚမွာ စာသားေတြ ျပဖို႔အတြက္ Label Control ကိုသံုးျပီး
အခုလိုေရးရပါမယ္။
pic1
private void Form1_MouseMove(object sender, MouseEventArgs e)

{
label1.Left = e.X + 10;
label1.Top = e.Y - 10;
label1.Text = e.Location.ToString();
}
အရင္ဆံုး Form ေပၚမွာ Label တစ္ခုထည့္ရပါမယ္။ Mouse Move event မွာ အဲ့ဒီ Label ေလးရဲ႕
Location ကိုေရႊဖ႔အ
ို တြက္ Left နဲ႔ Top ကို mouse pointer လက္ရွိေရာက္ေနတဲ႔ location(x,y)
သြားထည့္ေပးလိုက္ပါတယ္။ ဒီေနရာမွာ တစ္ခါတည္း သိလိုက္ဖို႔လိုတာက form ေပၚမွာ control ေတြ
ေနရာေရႊ႕ခ်င္ရင္ အဲ့ဒီ control ရဲ႕ left နဲ႔ top ကို ေျပာင္းျခင္းအားျဖင့္ ေရႊ႕နိုင္တယ္ဆိုတာေလးပါ။
ေဘာလံုးေလး လႈိမ့္ရေအာင္
pic1
ဒီတစ္ေခါက္ ကြၽန္ေတာ္တို႔ ေဘာလံုးေလးကို form ေပၚမွာ လႈိမ့္ၾကရေအာင္။ အရင္ဆံုး picturebox

တစ္ခုယူလိုက္ပါ။ ျပီးရင္ image property ကေန ေဘာလံုးပံုေလးကို import လုပ္ထားလိုက္ပါဦး။
picturebox ရဲ႕ property ေတြမွာ ေနာက္ထပ္ သိဖ႔ို လိုတာ တစ္ခုက sizemode property ပါ။
sizemode property ကို ေလွ်ာက္ျပီး ေျပာင္းျပီး စမ္းၾကည့္လိုက္ရင္ သိသြားမွာပါ။ ကဲ အခု
ေဘာလံုးပံုေ လး ရသြားပါျပီ၊ ေရႊ႕ဖို႔ပဲ က်န္ေတာ့တယ္။ ကြၽန္ေတာ္က ပထမဆံုး အေနနဲ႔ေတာ့
keyboard က up – down, left – right keys ေလးေတြကို အသံုးျပဳျပီး ေဘာလံုးကို ေရႊ႕ခ်င္ပါတယ္။
ဒီေတာ့ keyboard က key ႏွိပ္ပါတယ္ဆိုတဲ႔ event မွာ ႏွိပ္လိုက္တဲ႔ key ကို ျပန္ျပီး စစ္ရပါမယ္။
picturebox မွာ key နဲ႔ ပါတ္သက္တဲ႔ event မရွိပါဘူး၊ ဒီေတာ့ ကြၽန္ေတာ္တို႔ form ရဲ႕ key events
ေတြကိုပဲ သံုးရပါမယ္။ KeyDown, KeyUp နဲ႔ KeyPress event 3 ခုထဲကေနျပီး ကြၽန္ေတာ္တို႔
KeyDown or KeyUp event ကိုသံုးရပါမယ္။ ဘာလို႔လဲ ဆိုရင္ KeyPress Event မွာ Arrow keys
ေတြကို ဖမ္းလို႔ အဆင္မေျပတာေၾကာင့္ပါ။
private void Form2_KeyDown(object sender, KeyEventArgs e)

{
if (e.KeyCode == Keys.Up)
{
if(pictureBox1.Top > 0)
pictureBox1.Top -= 1;
}
else if (e.KeyCode == Keys.Down)
{
if(pictureBox1.Top+pictureBox1.Height < this.ClientSize.Height)
pictureBox1.Top += 1;
}
else if (e.KeyCode == Keys.Left)
{
if(pictureBox1.Left > 0)
pictureBox1.Left -= 1;
}
else if (e.KeyCode == Keys.Right)
{
if(pictureBox1.Left+pictureBox1.Width < this.ClientSize.Width)
pictureBox1.Left += 1;
}
}
keydown event မွာ user ရိုက္လိုက္တဲ႔ keycode ေလးကို ျပန္စစ္ရပါတယ္။ ျပီးေတာ့မွ up arrow
ဆိုရင္ picturebox ေလးကို အေပၚကို ေရြ႕ဖို႔အတြက္ picturebox ရဲ႕ top property ကို
ေလွ်ာ့ေပးလိုက္တာပါ။ ဒီအတိုင္းပဲ down arrow ဆိုရင္ေတာ့ top property ကို တိုးေပးရမွာပါ။ ဒီလို
တိုးေပး ေလွ်ာ့ေပးလုပ္တဲ႔ ေနရာမွာ form ရဲ႕ အျပင္ဘက္ကို picturebox
မေရာက္သြားရေလေအာင္ထိန္းထားေပးဖို႔လဲ လိုပါေသးတယ္။ ဒါ့ေၾကာင့္ ကြၽန္ေတာ္တို႔ up arrow
ႏွိပ္တဲ႔ ေနရာမွာ picturebox ရဲ႕ top ကို form ရဲ႕ အေပၚဆံုးေနရာထက္ၾကီးလား စစ္ရပါတယ္။
အေပၚဆံုးေနရာက 0 ပါ။ ဒီလိုပါပဲ down arrow ႏွိပ္တဲ႔ ေနရာမွာလည္း pictureboxရဲ႕ ေအာက္ေျခက
form ရဲ႕ ေအာက္ေျခထက္ ငယ္မွ ဆက္ျပီး ေရြ႕ခြင့္ေပးတာပါ။ ဒါဆိုရင္ left arrow နဲ႔ right arrow
မွာ ေရးထားတာကိုလည္း နားလည္မွာပါ။ ေဘာလံုးေလးကို ပိုျပီး ျမန္ျမန္ေရြ႕ေစခ်င္ရင္ေတာ့ ၁ တိုး၊
၁ေလွ်ာ့တဲ႔ ေနရာမွာ ၂ တို႔ ၃ တိ႔ု စသည္ျဖင့္ တိုးေပးလို႔ ရပါတယ္။
Automatic Moving the Ball
အခုကြၽန္ေတာ္က ဒုတိယ အဆင့္ေနနဲ႔ ေဘာလံုးေလး အခုလို ေရႊ႕တဲ႔ ကိစၥကို user key ႏွိပ္မွ
မဟုတ္ပဲ၊ ဒီအတိုင္းထားရင္လည္း သူဟာသူ ေရြ႕ေနေစခ်င္ပါတယ္။ ဒါဆိုရင္ ဘယ္လို လုပ္ရမွာပါလဲ။
user ရဲ႕ action အတြက္ reaction မဟုတ္ပဲ program ကေန သူဟာသူ အလိုအေလွ်ာက္
အလုပ္လုပ္ေနေစခ်င္တဲ႔ ကိစၥတိုင္းအတြက္ ကြၽန္ေတာ္တို႔ Timer Control ကို သံုးရပါမယ္။ ကဲ…
timer control ေလး form ထဲထည့္လိုက္ပါဦး။ Timer Control အေၾကာင္းကို ကြၽန္ေတာ္ Screen
Server Program ေလးမွာ ေျပာျပီးပါျပီ။ timer control ရဲ႕ interval property မွာ ၁၀ ေလာက္ထား၊
enabled ကို true ေပးၿပီး၊ Tick event ထဲမွာ ေဘာလံုး ေရြ႕ဖို႔ လိုအပ္တဲ႔ code
ေတြေရးေပးလိုက္ပါမယ္။
bool ToUp = true;

bool ToLeft = true;
private void timer1_Tick(object sender, EventArgs e)

{
if (ToUp)
pictureBox1.Top--;
else
pictureBox1.Top++;
if (ToLeft)
pictureBox1.Left--;
else
pictureBox1.Left++;
if (pictureBox1.Top <= 0)
ToUp = false;
if (pictureBox1.Top + pictureBox1.Height >= this.ClientSize.Height)
ToUp = true;
if (pictureBox1.Left <= 0)
ToLeft = false;
if (pictureBox1.Left + pictureBox1.Width >= this.ClientSize.Width)
ToLeft = true;
}
ဒီေနရာမွာ နည္းနည္း ရွင္းဖို႔ လိုတာက အခုကြၽန္ေတာ္က ေဘာလံုးေလး ေရႊ႕တဲ႔

အလုပ္ေတြအားလံုး(အေပၚ၊ေအာက္… ) ကို event တစ္ခုထဲအတြင္းမွာ ေရးမွာ ျဖစ္တဲ႔ အတြက္၊
လက္ရွိ အေျခအေနက အေပၚဖက္ကို သြားေနတဲ႔ အခ်ိန္လား၊ ေအာက္ဆင္းေနတဲ႔ အခ်ိန္လား
ဆိုတာကို မွတ္ထားဖို႔လိုပါတယ္။ ဒီလို မွတ္ထားဖို႔အတြက္ ToUp ဆိုတ႔ဲ bool variable တစ္လံုးကို
member variable အျဖစ္ေၾကာျငာထားလိုက္ပါတယ္။ အဲ့ဒီ ToUp ထဲမွာ true ဆိုရင္ အေပၚကို
ေရႊ႕ဖိ႔အ
ု တြက္ top ကို ၁ ေလွ်ာ့တယ္။ မဟုတ္ဘူး false ဆိုရင္ေတာ့ top ကို ၁ တိုးလိုက္ပါတယ္။
ျပီးေတာ့ ေဘာလံုးေလးက form ရဲ႕ အေပၚဆံုးကို ေရာက္ျပီဆိုရင္ ေအာက္ျပန္ဆင္းရမယ္ ဒါေၾကာင့္
အဲ့ဒီ ToUp ထဲကို false ထည့္ပါတယ္။ ဒီလိုပါပဲ ေအာက္ဆံုးေရာက္ျပီဆိုရင္လည္း
အေပၚျပန္တက္ဖို႔အတြက္ ToUp ထဲကို true ျပန္ထည့္ေပးလိုက္ပါတယ္။ ဒါဆို ကြၽန္ေတာ့္
ေဘာလံုးေလးက အေပၚတက္လိုက္၊ ေအာက္ဆင္းလိုက္နဲ႔ အျမဲတမ္း ေရႊ႕ေနပါလိမ့္မယ္။ ဘယ္၊ညာ
အတြက္လည္း ဒီသေဘာအတိုင္းပါပဲ။
ဒီ program ေလးမွာ ကြၽန္ေတာ္ အဓိက သိေစခ်င္တာက Key Event ေတြအေၾကာင္းနဲ႔ Timer

Control အေၾကာင္းေလးပါ။ ေနာက္ျပီး Event တစ္ခုအတြင္းမွာ ဆန္႔က်င္ဖက္ အလုပ္ ၂ ခုကို
ေရးရေတာ့မယ္ဆိုရင္ အခုလိုမ်ိဳး variable ေလးနဲ႔ ထိန္းျပီးသံုးရမယ္ဆိုလည္း သိရပါမယ္။
ေနာက္ဆံုးတစ္ခ်က္ကေတာ့ အခုလိုမ်ိဳးကိစၥေတြအတြက္ variable ေၾကာျငာမယ္ဆိုရင္ local

variable ကိုသံုးလို႔ မရပါဘူး။ member variable ကိုေၾကာျငာမွသာလွ်င္ variable ထဲက တန္ဖိုးကို
သိမ္းေပးထားနိုင္မွာပါ။
Chapter 10
ADO.NET in C# (part 1)
ကြၽန္ေ တာ္တို႔ေတြ database ထဲက record ေတြကို User Interface မွာ ရွိတဲ႔ datagrid လို၊ textbox
လို control ေတြမွာ ျပဖို႔ ျပင္ဖ႔ို ဘယ္လို ခ်ိတ္ဆက္ရမလဲ ဆိုတဲ႔ အေၾကာင္းကို
ဆက္ျပီးေလ့လာၾကရေအာင္။ C# window application မွာ database နဲ႔ ခ်ိတ္ဆက္ဖို႔အတြက္
နည္းလမ္း ၂ မ်ိဳး သံုးလို႔ရပါတယ္။ နံပါတ္ ၁ နည္းလမ္းကေတာ့ data ျပမယ့္ UI control နဲ႔ data ရွိတဲ႔
databaseကို တိုက္ရိုက္ခ်ိတ္ဆက္ျခင္း ျဖစ္ျပီး ဒီလိုေဆာင္ရြက္နိင္ဖို႔အတြက္ SQL DataSource
object ကို သံုးရပါတယ္။ နံပါတ္ ၂ နည္းလမ္းကေတာ့ database table ေတြထဲက data ေတြကို
ကြၽန္ေ တာ္တ႔ို program ရဲ႕ memory ေပၚမွာ dataset ေတြ အေနနဲ႔ သိမ္းထားျပီး၊ အဲ့ဒီ dataset
ေတြနဲ႔ UI controls ေတြနဲ႔ ခ်ိတ္ဆက္ျခင္းပဲ ျဖစ္ပါတယ္။ ဒီလို တဆင့္ခံ ခ်ိတ္ဆက္ဖို႔ အတြက္ေတာ့
OBJECT DataSource နဲ႔ dataset တို႔ကို သံုးရပါတယ္။ ကြၽန္ေတာ္ကေတာ့ dataset တဆင့္ခံျပီး
object datasource နဲ႔ သံုးရတာကို ပိုျပီးၾကိဳက္တယ္ဗ်။ ဘာလို႔လဲဆိုေတာ့ data အသြင္းအထုတ္
transaction တစ္ခုစီအတြက္ database ကို အျမဲသြားေနစရာမလိုဘူး။ dataset table ထဲမွာပဲ
လုပ္လို႔ရတယ္။ အားလံုးျပီးလို႔ စိတ္ေက်နပ္ျပီဆိုမွ database ထဲကို တစ္ၾကိမ္ထဲ update

လုပ္နိုင္တယ္။ ေနာက္ပိုျပီးေကာင္းတာက quary ေတြက dataset တစ္ေနရာထဲမွာ စုျပီး
ေရးထားတာေၾကာင့္ လိုအပ္လို႔ modify လုပ္ခ်င္တဲ႔ အခါမွာ လြယ္ကူတယ္။ sql datasource
ကိုသံုးရင္ data ျပမယ့္ေနရာ ၃ ေနရာရွိရင္ quary ကို သံုးေနရာလံုးမွာ သံုးခါေရးရမွာဗ်။ ဒါဆို
ျပင္မယ္ဆိုရင္လည္း သံုးေနရာလံုးမွာ လိုက္ျပင္ရလိမ့္မယ္။ ခ်ိတ္ဆက္ပံု ၂မ်ိဳးလံုးကို
ကြၽန္ေတာ္ရွင္းျပပါမယ္၊ ပထမဆံုး database ထဲမွာ table ေလးတစ္ခုအရင္ သြားေဆာက္လိုက္ပါဦး။
DATABASE NAME => mySaleDB

TABLE NAME => Category
Field name Data Type AllowNull
CategoryID int false PrimaryKey (auto increment)
CategoryName varchar(50) true
Description varchar(500) true
Status bit true Default vale – true
အိုေက.. ရျပီေနာ္… အခုကြၽန္ေတာ္တို႔ object datasource နဲ႔ သံုးတဲ႔ပံုစံကို အရင္စျပီး သံုးျပပါ့မယ္။

ပထမဆံုး window project တစ္ခုေဆာက္ပါမယ္။ VS2008 => File => New => Project =>
Window Form Application. Object datasource ကိုသံုးမယ္ဆိုရင္ ပထမဆံုးလိုအပ္တာက
dataset ပါ။ database table ထဲက data ေတြကို memory ေပၚမွာ သိမ္းထားဖို႔အတြက္
ကြၽန္ေတာ္တို႔ dataset ကိုသံုးရပါမယ္။ အိုေက project menu ေအာက္က Add new item
menuitem ကို ႏွိပ္လိုက္ပါ။ ဒါဆို item ေရြးဖို႔ window ေပၚလာမယ္၊ အဲ့ဒီမွာ dataset ဆိုတာကိုေရြး
CategoryDataSet လို႔ နာမည္ေပးျပီး Add လိုက္ပါ။ ဒါဆို CategoryDataSet.xsd ဆိုတဲ႔ dataset
တစ္ခုကြၽန္ေတာ္တို႔ ရပါျပီ။ database နဲ႔ ခ်ိတ္ဆက္မယ့္ dataset တစ္ခုမွာ ပံုမွာျပထားတဲ႔အတိုင္း
DataTable နဲ႔ TableAdapter ဆိုျပီး အပိုင္း ၂ ပိုင္းပါေလ့ရွိပါတယ္။ DataTable ကေတာ့ memory
ေပၚမွာ data ေတြသိမ္းေပးျပီး၊ Tableadapter ရဲ႕တာ၀န္ကေတာ့ အဲ့ဒီ table ထဲကို database ကေန
data အသြင္းအထုတ္ကို ေဆာင္ရြက္ေပးပါတယ္။ ဒီလိုေဆာင္ရြက္ဖို႔အတြက္ Query statement
ေတြကြၽန္ေတာ္တို႔ ေဆာက္ေပးရမွာပါ။ ကဲ TableAdapter စေဆာက္ရေအာင္၊ ToolBox ထဲကေန
tableadapter ကို double click လုပ္ျပီးေရြးလိုက္ပါ။ TableAdapter ေဆာက္တဲ႔ အခါမွာ ပထမဆံုး
database နဲ႔ connection ယူရပါတယ္။ လက္ရွိ project ထဲမွာ connection ယူျပီးသားရွိရင္
combobox ထဲမွာ ေရြးရျပီး၊ မရွိေသးရင္ေတာ့ new connection လုပ္ရပါမယ္။
New connection wizard မွာ ကြၽန္ေတာ္တို႔ သံုးခ်င္တဲ႔ database အမ်ိဳးအစားေရြးလို႔ရပါတယ္။

Microsoft Access သံုးမလား၊ Microsoft SQL Server ပဲသံုးမွာလား၊ Oracle Database ပဲ
ခ်ိတ္ခ ်င္လားေရြးလို႔ရပါတယ္။ ကြၽန္ေတာ္တို႔ Microsoft SQL Server ကိုပဲ ေရြးျပီး continue
လုိက္ပါမယ္။
Add Connection wizard က Server Name ေနရာမွာ ကြၽန္ေတာ္တို႔ database ရွိေနတဲ႔ computer
name ကိုထည့္ေပးရပါမယ္။ ကိုယ့္စက္ကို ခ်ိတ္မယ္ဆိုရင္ (.) ထည့္ေပးလည္းရပါတယ္။ ျပီးရင္
database login username နဲ႔ password ထည့္ေပးရပါမယ္။ မရွိဘူးဆိုရင္ေတာ့ Window
Authentication ကိုေရြးခဲ႔ပါ။ ေနာက္ဆံုးတဆင့္ကေတာ့ database name combo ထဲမွာ mySaleDB

ကိုေရြးေပးျပီး OK လိုက္ပါ။
အခု dataconnection combo ေလးမွာ ကြၽန္ေတာ္တ႔ို ေရြးခဲ႔တဲ႔ connection ေလးေတြ႔ေနရပါျပီ။ အဲ့ဒ ီ

connection မွာ password တခါတည္းထည့္မလား မထည့္ဘူးလား ေရြးလိ႔ရ
ု ပါတယ္။
ကြၽန္ေ တာ္ကေတာ့ တခါတည္းပဲ ထည့္ထားလိုက္ပါတယ္။ ျပီးရင္ Next လိုက္ပါဦး။
အခုေဆာက္ခဲ႔တဲ႔ connection ကိုသိမ္းထားမလား လာေမးပါတယ္။ သိမ္းထားလိက

ု ္ပါ။ ဒါဆိုရင္ေတာ့
connection ယူတဲ႔ အပိုင္းျပီးပါျပီ။ connection ရသြားျပီးေတာ့ Query ဆက္ေရးရပါဦးမယ္။
ပထမဦးဆံုး SQL Statement သံုးမလား၊ Store Procedure သံုးမလား ေရြးခိုင္းတာပါ။ SQL
Statement ပဲ ေရြးျပီး Next လိုက္ပါ။
ဒါဆိုရင္ Query ေရးဖို႔ ေနရာေရာက္ပါျပီ။ ကြၽန္ေတာ္က Category table ထဲက record အားလံုး
ထုတ္ျပဖို႔အတြက္ “SELECT * FROM Category” လို႔ေရးလိုက္ပါတယ္။ query ကို ကိုယ္တိုင္မေရးပဲ
design ကိုပဲ ေဆာက္ခိုင္းခ်င္တယ္ဆိုရင္ Query Builder button ကိုႏွိပ္ျပီး ေဆာက္လို႔ ရပါတယ္။
ကဲ ဆက္ျပီး Next လိုက္ပါဦး။
ေနာက္တစ္ဆင့္မွာေတာ့ ကြၽန္ေတာ္တို႔ေရးခဲ႔တဲ႔ query ကို program ထဲမွာ ျပန္ေခၚဖို႔အတြက္
function name ေပးရတာပါ။ function ၂ ခုေဆာက္ေပးပါတယ္။ Fill နဲ႔ Get ပါ။ dataset
စေဆာက္တ႔ဲ ပထမဆံုး query အတြက္ နာမည္မေျပာင္းပါနဲ႔ default အတိုင္း ပဲ ထားျပီး next
လိုက္ပါဦး။
ေနာက္ဆံုးမွာ ကြၽန္ေတာ္တို႔ရဲ႕ CategoryDataSet ၾကီးေအာင္ျမင္စြာ တည္ေဆာက္ျပီးစီးသြားပါျပီ။

compiler ေဆာက္ေပးသြားတဲ႔ result ကိုၾကည့္လိုက္ပါဦး။ ကြၽန္ေတာ္တို႔က Select query တစ္ခုထဲ
ေဆာက္ခ႔ေ
ဲ ပမယ့္ insert, update, delete အားလံုးကို compiler က auto ေဆာက္ေပးသြားပါတယ္။
Finish လိုက္ရင္ categoryDataSet ထဲမွာ Category Table ေလးရယ္၊ table ထဲမွာ ပါတဲ႔ column
name ေတြရယ္၊ CategoryTableAdapter ရယ္၊ Fill နဲ႔ GetDate Function ေတြရယ္ကို ေတြ႔ရမွာပါ။
အိုေက… နားလည္မယ္ထင္ပါတယ္။ ဒါဆိုရင္ ကြၽန္ေတာ္တို႔ Dataset ေတြ တည္ေဆာက္တက္ပါျပီ။
ေနာက္ေန႔မွ datagridview နဲ႔ ခ်ိတ္ပါ့မယ္။
ကဲ မေန႔က ကြၽန္ေတာ္တို႔ categoryDataSet ေဆာက္ခဲ႔ျပီးျပီဆိုေတာ့ အခုကြၽန္ေတာ္တို႔ datagrid မွာ

ျပဖို႔ လုပ္ရေအာင္။ အရင္ဆံုး window form တစ္ခုယူလိုက္ပါ၊ နာမည္ကိုေတာ့ CategoryList လို႔
ေပးလိုက္ပါ။ အဲ့ဒီ form ထဲကို ပံုမွာ ျပထားတဲ႔ အတိုင္း label တစ္ခု၊ button တစ္ခုနဲ႔ datagrid
တစ္ခုထည့္လိုက္ပါဦး။ control ေတြမွာ ျပင္ရမယ့္ property setting ကိုလည္း ျပထားပါတယ္။
ပံု (၁)
Datagrid ကို click ႏွိပ္လိုက္ရင္ ညာဖက္အေပၚေဒါင့္မွာ arrow icon ေလးတစ္ခုေတြ႔ရပါလိမ့္မယ္။

အဲ့ဒါေလးကို ႏွိပ္လိုက္ရင္ datasource ေရြးဖို႔ combobox ေလးကိုေတြ႔မွာပါ။ အဲ့ဒီ combobox
ေလးကို ႏွိပ္ျပီး ဒီ form ေလးမွာ ရွိေနတဲ႔ datasource ေတြကိုေရြးလို႔ရပါတယ္။ အခုကြၽန္ေတာ္တို႔က
datasource မထည့္ရေသးလိ႔ု ဘာမွ ေတြ႔ရမွာမဟုတ္ပါဘူး။ datasource တစ္ခု create
လုပ္ဖို႔နည္းလမ္း ၂ခုရွိပါတယ္။ နည္းလမ္း (၁) က ေအာက္က ပံု (၂) မွာ ျပထားသလို combobox
ထဲမွာ အဆင့္ဆင့္သြားျပီး ကြၽန္ေတာ္တို႔ ေဆာက္ထားတဲ႔ CategoryDataSet ထဲက category table
ေလးကို ေရြးေပးလိုက္ပါ။ ဒါဆိုရင္ ပံု (၃) မွာ ျပထားသလို categoryBindingSource object,
categoryDataSet object နဲ႔ categoryTableAdapter တိ႔က
ု ို ေဆာက္ေပးသြားပါလိမ့္မယ္။ datagrid
မွာလည္း category table ထဲက column ေတြ ေပၚလာတာ ေတြ႔ရမွာပါ။ ဒါဆိုရင္ datagrid နဲ႔
dataset ခ်ိတ္တဲ႔ အပိုင္းျပီးသြားပါျပီ။ အခု ဒီ program ေလးကို run လိုက္ရင္ data
ေတြေပၚလာျပီလား။ မေပၚဘူးေနာ္… ဘယ္ေပၚမလဲ category table ထဲမွာ data မွ မရွိတာကိုး
ပံု (၂)
ပံု
(၃)
ကဲ အခု ကြၽန္ေတာ္တို႔ dataset နဲ႔ ခ်ိတ္ဆက္မႈ ျပီးသြားျပီ ဆိုေတာ့။ data အသြင္းအထုတ္လုပ္လို႔

ရပါျပီ။ ဒီလိုလုပ္လို႔ ရဖို႔အတြက္ အရင္ဆံုး ပံု (၃)မွာ ျပထားသလို datagrid မွာ Enable Adding,
Enable Editing နဲ႔ Enable Deleting တိ႔က

ု ို check လုပ္ေပးခဲ႔ရပါမယ္။ အခု ကြၽန္ေတာ္တို႔
လုပ္ရမွာက program ကို run လိုက္ျပီး category ေတြထည့္ရပါမယ္။ ဒီလိုထည့္တဲ႔ အခါမွာ
categoryID ကို ထည့္ေပးစရာ မလိုပါဘူး။ primary key ျဖစ္တဲ႔ categoryID ကို autoincrement
လုပ္ထားတဲ႔ အတြက္ ကြၽန္ေတာ္တို႔ data ျဖည့္ေပးစရာ မလိုပါဘူး။ save လုပ္ရင္
အလိုလိုထည့္ေပးသြားပါလိမ့္မယ္။ အခုကြၽန္ေတာ္တို႔ data ျဖည့္ျပီးလို႔ database ထဲကို
သိမ္းေတာ့မယ္ဆိုရင္ update button ကိုႏွိပ္ပါ့မယ္။ ဒါဆို update button ရဲ႕ click event မွာ
dataset ထဲက data ေတြကို database ထဲသြားသိမ္းဖို႔ အတြက္ code ေရးေပးရပါမယ္။
ကြၽန္ေတာ္တို႔ အခု datagrid ထဲမွာ ထည့္ေနတဲ႔ data ေတြက memory ေပၚက categoryDataSet
ထဲမွာ ရွိေနပါတယ္။ အဲ့ဒီ data ေတြကို database ထဲေရာက္ဖို႔အတြက္ Adapter ကေနတဆင့္
Update function ကိုေခၚရမွာပါ။ မေခၚခင္အရင္ဆံုး datagrid နဲ႔ ခ်ိတ္ထားတဲ႔ datasource ကို
ျပင္ေနတာ ျပီးပါျပီလို႔ ေျပာေပးရပါမယ္။ ဒီလိုမ်ိဳးပါ…
private void button1_Click(object sender, EventArgs e)

{
this.categoryBindingSource.EndEdit();
this.categoryTableAdapter.Update(this.categoryDataSet.Category);
}
အခု ကြၽန္ေတာ္ေခၚလိုက္တဲ႔ update function က dataset ေဆာက္တုန္းက compiler က auto

ေဆာက္ေပးသြားတဲ႔ function ျဖစ္ပါတယ္။
ပံု (၄)
ပံု (၅)
ပံု (၄) မွာ ျပထားတဲ႔ အတိုင္း ကြၽန္ေတာ္ category ၂ေၾကာင္းျဖည့္လိုက္ပါတယ္။ categoryID က -1

နဲ႔ -2 ဆိုျပီး temporary assign လုပ္ေပးသြားပါတယ္။ update button ကို ႏွိပ္ျပီး update
လုပ္လိုက္ျပီးတဲ႔ အခ်ိန္မွာေတာ့ ပံု(၅) အတိုင္း ျဖစ္သြားမွာပါ။ categoryID က database
ထဲကအတိုင္း refresh ျဖစ္သြားပါတယ္။ program ကို ပိတ္ျပီး ျပန္ဖြင့္တဲ႔ အခါမွာလည္း ဒီအတိုင္းပဲ
ေပၚေနပါလိမ့္မယ္။ ဘာလို႔လဲဆိုေတာ့ form_load event မွာ ေရးထားတဲ႔ ဒီ code ေၾကာင့္ပါ။
private void CategoryList_Load(object sender, EventArgs e)

{
this.categoryTableAdapter.Fill(this.categoryDataSet.Category);
}
ဒီ code ကို ကြၽန္ေတာ္တို႔ datagrid နဲ႔ dataset ထဲက table နဲ႔ ခ်ိတ္လိုက္တဲ႔ အခ်ိန္မွာ auto
ေရးေပးသြားတာပါ။ dataset ထဲမွာ ရွိတဲ႔ categoryTableAdapter ထဲမွာ ကြၽန္ေတာ္တို႔ေရးခဲ႔တဲ႔ Fill
function ကိုသံုးျပီး dataset ထဲက category table ထဲကို data ျဖည့္ေပးပါတယ္။ table ထဲမွာ
dataရွိသြားတဲ႔ အတြက္ table နဲ႔ ခ်ိတ္ထားတဲ႔ datagridview မွာပါ data ေတြ ေပၚလာတာပါ။ အဲ့ဒ ီ
formload event ထဲက data fill လုပ္တ႔ဲ code ကို comment ပိတ္ျပီး ျပန္ run ရင္ data ေပၚမွာ
မဟုတ္ေတာ့ပါဘူး။ အိုေက ဒီေလာက္ဆိုရင္ object datasource သံုးျပီး datagridview နဲ႔ data
အသြင္းအထုတ္လုပ္တာ နားလည္ျပီထင္ပါတယ္။
ကဲ ဒီေန႔ေတာ့ ကြၽန္ေတာ္တို႔ မေန႔က program ေလးကိုပဲ ပိုျပီးလြယ္တဲ႔ နည္းေလးသံုးျပီး

ျပန္ေရးလိုက္ရေအာင္ဗ်ာ။ dataset ကို အရင္မေဆာက္ပဲ datagrid ကေနတဆင့္
ေဆာက္မွာျဖစ္ပါတယ္။
ပံု(၁)
ပံု(၁)မွာ ျပထားတဲ႔ အတိုင္း အဆင့္ဆင့္သြားလိုက္ပါ။ ကြၽန္ေတာ္တို႔ dataset
ၾကိဳမေဆာက္ထားတဲ႔အတြက္ choose data source ထဲမွာ ဘာမွ ေတြ႔ရမွာ မဟုတ္ပါဘူး။ ကဲ Add
Project Data Source လင့္ေလးကို click လိုက္ပါ။
ပံု(၂)
ဒါဆိုရင္ Data Source အမ်ိဳးအစားေရြးခိုင္းတဲ႔ window ေလးေပၚလာပါ့မယ္။ ကြၽန္ေတာ္က
databaseထဲကေန ယူခ်င္တာျဖစ္လို႔ Database ကိုေရြးျပီး Next ပါမယ္။
ပံု(၃)
ဒါဆိုရင္ connection ေရြးခိုင္းတဲ႔ ေနရာကိုေရာက္ပါျပီ။ အရင္က ခ်ိတ္ဖူးတဲ႔ connection ေတြရွိေနရင္
ပံု(၃)မွာ ျပထားသလို combobox ေလးထဲကေနေရြးေပးလိုက္ပါ။ မရွိဘူးဆိုရင္ေတာ့ ဟိုေန႔က
ေျပာခဲ႔သလို New Connection လုပ္ရမွာပါ။ Next ထပ္ႏွိပ္ပါဦး၊ ဒါဆို connection ကိုသိမ္းမလား
ေမးလိမ့္မယ္။ သိမ္းမယ္ေျပာျပီး Next ထပ္ႏွိပ္ပါ။
ပံု(၄)
Database object ေရြးခိုင္းတဲ႔ ေနရာေရာက္ရင္ Tables ေအာက္က Category Table
ကိုေရြးရပါမယ္။ DataSet name ေနရာမွာ CategoryDataSet လို႔ ေျပာင္းခ်င္ရင္ ေျပာင္းလို႔
ရပါတယ္။ ဒီတိုင္းထားလည္း ျပႆနာမရွိပါဘူး။ ကဲ Finished လုိက္ပါ။ ဒါဆိုရင္ေတာ့ ကြၽန္ေတာ္တို႔
datagrid နဲ႔ database ခ်ိတ္ဆက္တဲ႔ လုပ္ငန္းစဥ္ ျပီးဆံုးပါျပီ။ dataSet ကိုလည္း
ေဆာက္ေပးသြားမွာပါ။ form load event မွာလည္း data fill လုပ္ေပးသြားပါလိမ့္မယ္။ အခု
ကြၽန္ေ တာ္တို႔က data update လုပ္ဖ႔ို code ၂ ေၾကာင္းပဲ ေရးေပးစရာ လိုအပ္ပါေတာ့တယ္။ ကဲ…
ဘယ္လိုလဲ…
ပံု(၅)
private void CategoryList_Load(object sender, EventArgs e)

{
this.categoryTableAdapter.Fill(this.mySaleDBDataSet.Category);
}
private void button1_Click(object sender, EventArgs e)
{
categoryBindingSource.EndEdit();
this.categoryTableAdapter.Update(mySaleDBDataSet.Category);
}
Question & Answer 1
ကြၽန္ေ တာ္ သူငယ္ခ်င္းတို႔ရဲ႕ comment ထဲမွာ ေမးတဲ႔ ေမးခြန္းေလးေတြကို အလွ်င္းသင့္သလို

ျပန္ေျဖနိုင္ေအာင္ဆိုျပီး Question and Answer ဆိုတ႔ဲ အပို္င္းေလး ထည့္ဖို႔ စဥ္းစားမိတယ္။ ဒါနဲ႔ ဒီ
category ေလးကို စလိုက္ပါတယ္။ သူငယ္ခ်င္းတို႔ C# နဲ႔ ပတ္သက္ျပီး သိခ်င္တာေလးေတြ
ေမးနိုင္ပါတယ္။ ကြၽန္ေတာ္ သိသေလာက္ ေျဖေပးပါ့မယ္။ အဲ မသိရင္လည္း ၾကိဳးစား ရွာဖတ္ျပီး
ေျဖေပးနိုင္ေအာင္ ၾကိဳးစားပါ့မယ္။
အရင္ဆံုး Ko Thet ေမးတဲ႔ ေမးခြန္းေလးနဲ႔ စလိုက္ရေအာင္….
Q : How to populate data in text box by using combo box.Says, Chose ID in Combo Box,
then Name, Add, City, Contact no and etc will be shown in respective text box control. If
you have time, please show me.
Comment by Ko Thet — October 22, 2009
A : ဒီေမးခြန္းေလးအတြက္ ကြၽန္ေတာ္ example program ေလး တစ္ခု ေရးျပပါမယ္။ အရင္ဆံုး

ေအာက္မွာ ျပထားတဲ႔ ပံု(၁) အတိုင္း database ထဲမွာ table ေလး တစ္ခုေဆာက္လိုက္ပါတယ္။
Database name => Course_DB
Table name => EmployeeTable
pic_1
Note: EmployeeID ကို ကြၽန္ေတာ္တ႔ို ထည့္စရာ မလိုပဲ database မွာ auto တိုးသြားခ်င္လို႔ အဲ့ဒီ
column properties မွာ (Is Identity) ကို Yes လိ႔ု ေပးလိုက္ပါတယ္။ Identity Seed (1) ကေနစျပီး
Identity Increment (1) စီ တိုးသြားမယ္လို႔ ေျပာတာပါ။
ျပီးရင္ အဲ့ဒီ EmployeeTable ထဲကို Sample Data နည္းနည္း ျဖည့္ေပးထားလိုက္ပါမယ္။ ပံု(၂) နဲ႔
ပံု(၃)မွာ ၾကည့္ပါ။
pic_2
pic_3
database ေဆာက္ျပီးေတာ့ အခုကြၽန္ေတာ္တို႔ program ဘက္အပိုင္းကို ဆက္ပါမယ္။ New

Window Application တစ္ခုယူျပီး ပံု(၄) အတိုင္း design ခ်လိုက္ပါတယ္။
pic_4
Database ထဲက data ကို window form မွာ ခ်ိတ္ျပဖို႔အတြက္ ကြၽန္ေတာ္ အခု ပံု(၅)
မွာျပထားသလို အဆင့္ဆင့္ လုပ္သြားလိုက္ပါ။
pic_5
pic_6
Data Source Configuration Wizard မွာ ‘DataBase’ ကိုေရြးျပီး Next ထပ္ႏွိပ္လိုက္ပါ။ ဒါဆိုရင္
ပံု(၇) မွာ ျပထားသလို database connection ေရြးခိုင္းတဲ႔ ေနရာကိုေရာက္ပါမယ္။ ကြၽန္ေတာ္တ႔က
ို
အခုမွ connection အသစ္ေဆာက္မွာ ျဖစ္လ႔ို New Connection button ကိႏ
ု ွိပ္လိုက္ပါ။ Add
connection wizard ေရာက္ရင္ ပံု(ဂ) မွာ ျပထားသလိုမ်ိဳး connection တစ္ခု ေဆာက္လိုက္ပါ။
pic_7
pic_8
pic_9
ပံု(၉) မွာ ျပထားတဲ႔ အတိုင္း ကြၽန္ေတာ္တို႔ database connection တစ္ခုရပါျပီ။ အဲ့ဒီ connection
string ထဲမွာ password ထည့္သိမ္းထားမယ္ဆိုရင္ ဒုတိယ radio button ေလးကို ေရြးေပးရပါမယ္။
pic_10
ေနာက္တစ္ဆင့္မွာ connection setting ေလးကို သိမ္းမလားလို႔ ေမးပါတယ္။ အိုေက

သိမ္းထားလိုက္ပါ… နာမည္ကိုလည္း မေျပာင္းတာေကာင္းပါတယ္။
pic_11
အခုကြၽန္ေတာ္တို႔ combobox ကေနတဆင့္ dataset ေဆာက္တဲ႔ အဆင္ျပီးသြားပါျပီ။ အခု

ေျပာသလိုမေဆာက္ခ်င္ဘူး ဒါမွမဟုတ္လည္း ကြၽန္ေတာ္တို႔ form ထဲမွာ combobox
မပါဘူးဆိုရင္လည္း dataset ၾကီး ပဲ ဒီတိုင္း ယူျပီး ေဆာက္လို႔လည္း ရပါတယ္။ (Project Menu ->
Add New Items -> DataSet )
pic_12
Code file ထဲမွာလည္း Form_Load event ကို auto ေဆာက္ေပးသြားပါလိမ့္မယ္။
private void Form1_Load(object sender, EventArgs e)

{
this.employeeTableTableAdapter.Fill(this.course_DBDataSet.EmployeeTable);
}
Database ထဲက data ေတြကို ကြၽန္ေတာ္တို႔ program ရဲ႕ memory ေပၚမွာ ယူျပီး သိမ္းေပးထားတဲ႔
အလုပ္ကို DataSet က လုပ္ေပးပါတယ္။ အဲ့ဒီ dataset ထဲကို data ေတြ ပိ႔ေ
ု ဆာင္ေပးတဲ႔
အလုပ္ကိုေတာ့ tableadapter က တာ၀န္ယူပါတယ္။ Form Load event ထဲမွာ ေရးေပးသြားတဲ႔
အလုပ္က အဲ့ဒီ data fill လုပ္ေပးတဲ႔ အလုပ္ပါ။ DataSet ထဲက data ေတြကို UI Controls ေတြမွာ
ျပဖို႔ အတြက္ကိုေတာ့ BindingSource ကိုသံုးရပါတယ္။
pic_13
အခု program ေလးကို အခုေန run လိုက္ရင္ combobox ထဲမွာ employee no

ေတြကိုေတြ႔ေနရမွာပါ။ ဒါေပမယ့္ textbox ေတြမွာေတာ့ ေပၚမွာ မဟုတ္ေသးပါဘူး။ ကြၽန္ေတာ္တို႔
textbox ေတြနဲ႔ မခ်ိတ္ေပးရေသးဘူးေလ။ အိုေက အခု textbox ေတြန႔ဲ bindingsource နဲ႔
ခ်ိတ္ေပးပါ့မယ္။
pic_14
Textbox နဲ႔ databind ဖို႔အတြက္ textbox ရဲ႕ properties window ကိုသြားလိုက္ပါ။

အေပၚဆံုးနားမွာ (DataBindings) ဆိုတဲ႔ property ေလးကို ဖြင့္လိုက္ျပီး၊ Text property
ကိုႏွိပ္လိုက္ပါ။ အဲ့ဒီမွာ ကြၽန္ေတာ္တို႔ form မွာ ရွိေနတဲ႔ employeeTableBindingSource
ကိုေတြရပါမယ္။ အဲ့ဒီ bindingsource ထဲကေန ကြၽန္ေတာ္တို႔ textbox မွာ ျပခ်င္တဲ႔ column name
ကိုေရြးေပးလိုက္ရံုပါပဲ။ ကဲ… က်န္တဲ႔ textbox ေတြအားလံုးမွာလည္း ဒီတိုင္းပဲ လိုက္လုပ္လိုက္ပါ။
အခုဆိုရင္ေတာ့ Ko Thet လိုခ်င္တဲ႔ Program ပံုစံေလး ရျပီထင္ပါတယ္။
Chapter 11
create your database
ကိုေက်ာ္စြာရဲ႕ cbox ထဲက ေမးခြန္းေလးကို ေျဖေပးရင္းနဲ႔ ကြၽန္ေတာ္ SQL Server 2005 မွာ
database တည္ေဆာက္ပံုေလး ေျပာျပေပးခ်င္ပါတယ္။ အရင္ဆံုး SQL Server 2005 ကို run
ု တြက္ START-> ALL PROGRAM -> MICROSOFT SQL SERVER 2005 -> SQL SERVER
ဖိ႔အ
MANAGEMENT STUDIO ကို click လိုက္ပါ။ ဒါဆိုရင္ sql server management studio ပြင့္လာျပီး
database server login ေတာင္းပါလိမ့္မယ္။ server name ေနရာမွာ ကြၽန္ေတာတို႔က
ကိုယ့္စက္ကိုယ္ ဖြင့္မွာျဖစ္လို႔ computer name ဒါမွမဟုတ္ local ဒါမွမဟုတ္ (.)
ေလးထည့္ေပးရပါမယ္။ authentication အေကာင့္ အတြက္ေတာ့ ၂ မ်ိဳးေရြးလို႔ရပါတယ္၊ window
authentication နဲ႔ ၀င္မယ္ဆိုရင္ login name နဲ႔ password ေပးစရာမလိုပါဘူး။ SQL Server
Authentication နဲ႔ ၀င္ရင္ေတာ့ default login name က (sa) ပါ၊ password ကေတာ့ ကြၽန္ေတာ္တို႔
SQL Server install လုပ္တုန္းက ေပးထားခဲ႔တဲ႔ password ကိုသံုးရပါမယ္။ တကယ္လို႔ SQL Server
install လုပ္တုန္းက မေပးခဲ႔ဘူး ဆိုရင္ေတာ့ window authentication ကိုပဲ ေရြးျပီး ၀င္လိုက္ပါ။
အခုကြၽန္ေတာ္တို႔ server ထဲကို ေရာက္ပါျပီ။ အဲ့ဒီမွာ object explorer ကိုေတြ႔ရမွာပါ။ မေတြ႔ရင္

View Menu -> object explorer ကိုေရြးလိုက္ပါ။ object explorer ထဲမွာ Databases, Security,
Replication စသည္ျဖင့္ tree nodes ေလးေတြ ေတြ႔ရပါမယ္။ အဲ့ဒီ ထဲက Databases nodes
ေလးထဲကို ထပ္၀င္လိုက္ရင္ ကြၽန္ေတာ္တို႔ လက္ရွိ တည္ေဆာက္ထားတဲ႔ databases ေတြကို
ေတြ႔ရပါလိမ့္မယ္။ အခုကြၽန္ေတာ္တို႔ database တစ္ခု အသစ္ေဆာက္ဖို႔အတြက္ Databases node
ေလးကို right click လုပ္ျပီး new database ဆိုတာကို ေရြးလိုက္ပါ။ new Database window ေလး
ေပၚလာပါမယ္။ အဲ့ဒီက database name textbox ထဲမွာ ကြၽန္ေတာ္တို႔ တည္ေဆာက္ခ်င္တဲ႔
database အမည္ေလးထည့္ပါ။ owner ကေတာ့ default ပဲထားလိုက္ပါ။ database တစ္ခုအတြက္
.mdf file နဲ႔ .ldf file ဆိုျပီး file ၂ ခု ေဆာက္ေပးပါလိမ့္မယ္၊ ေဆာက္ေပးမယ့္ default location က
C:\ ေအာက္က Sql server သြင္းထားတဲ႔ location မွာပါ။ ဒါကို ကြၽန္ေတာ္တို႔ ၾကိဳက္တဲ႔ location မွာ
သြားေဆာက္လို႔လည္း ရပါတယ္၊ database files ဇယားကြက္ထဲက Path ဆိုတဲ႔ ေနရာမွာ
သြားေရြးေပးလိုက္ပါ။ ျပီးရင္ေတာ့ OK လုပ္လိုက္ပါ၊ ဒါဆိုရင္ အခု ကြၽန္ေတာ္တို႔ ကိုယ္ပိုင္ database
ေလးေဆာက္လို႔ ျပီးပါျပီ။
ဒီ database ေလးထဲမွာ data ေတြသိမ္းဖို႔အတြက္ table ေတြ ထပ္ေဆာက္ေပးဖို႔

လိုအပ္ပါေသးတယ္။ အဲ့ဒီ အတြက္ databases node ေလးထဲက ကြၽန္ေတာ္တို႔
အသစ္ေဆာက္လိုက္တဲ႔ database အမည္ေလးကို ထပ္ဖြင့္လိုက္ရင္ Database Diagrams, Tables,
Views စသည္ျဖင့္ ထပ္ေတြ႔ရပါမယ္။ အဲ့ဒီမွာ Tables nodes ေလးကို right click လုပ္ျပီး new table
ကို ေရြးလိုက္ပါ။ ဒါဆို ကြၽန္ေတာ္တို႔ table အသစ္ေဆာက္ဖို႔ ေနရာကို ေရာက္ပါမယ္။ အဲ့ဒီ ေနရာမွာ
ကြၽန္ေတာ္တို႔ table ထဲမွာ သိမ္းခ်င္တဲ႔ record ေတြအတြက္ သိမ္းမယ့္ column(field)
ေတြေၾကျငာေပးရပါမယ္။ column name ေနရာမွာ ကိုယ္ၾကိဳက္တယ္ အမည္ေပးရမယ္၊ တခု
သတိထားဖို႔က အဲ့ဒီ အမည္အတြက္ space ေတြ မထည့္ေပးပါနဲ႔။ ထည့္ေပးလို႔ မရဘူးမဟုတ္ဘူးေနာ္၊
မထည့္ေပးတာက program ေတြကေန ျပန္ေခၚသံုးမယ့္ အခါ ပိုျပီး အဆင္ေျပေစပါတယ္။ ျပီးရင္ အဲ့ဒီ

column အတြက္ သိမ္းမယ့္ data type ကို ေၾကျငာေပးရပါမယ္။ allow null ဆိုတဲ႔ checkbox
ေလးကေတာ့ ကြၽန္ေတာ္တို႔ အခုေဆာက္လိုက္တဲ႔ column ေလးမွာ data မထည့္လ႔ို မရဘူး၊ ထည့္ကို
ထည့္ရမယ္လို႔ သက္မွတ္ခ်င္ရင္ off လုပ္ရျပီး၊ မထည့္လည္း ရမယ္ဆိုရင္ on ေပးရမွာပါ။
ဒီနည္းအားျဖင့္ ကြၽန္ေတာ္တို႔ စိတ္ၾကိဳက္ ေကာ္လံေတြ ေဆာက္ေပးရပါမယ္။
ဥပမာ အားျဖင့္
column name data type allow nulls
CategoryID int off
CategoryName varchar(50) on
စသည္ျဖင့္ေပါ့။
columns ေတြ ေဆာက္လို႔ ျပီးျပီဆိုရင္ table တစ္ခုမွာ လိုအပ္တဲ႔ primary key

ကိုသက္မွတ္ေပးရပါမယ္။ ကိုယ္ သက္မွတ္ခ်င္တဲ႔ column ေလးကို ေရြးျပီး toolbar ေပၚက ေသာ့ပံု
icon ေလးကို ႏွိပ္လိုက္ရံုပါပဲ။ ျပီး အဲ့ဒီ primary key ကို auto တိုးသြားေစခ်င္ရင္ေတာ့ ေအာက္နားက
column properties ထဲမွာ Identity Specification ဆိုတာ ေနရာမွာ (Is Identity) ကို Yes
လုပ္ေပးရပါမယ္။ အားလံုးျပီးသြားျပီဆိုရင္ ကြၽန္ေတာ္တို႔ အခုေဆာက္လိုက္တဲ႔ table ေလးကို save
လုပ္လိုက္ပါေတာ့။ အိုေက ဒါဆိုရင္ အခုကြၽန္ေတာ္တို႔ table ေတြ ေဆာက္တက္ပါျပီ။
Database Replication (part 1)
Database Replication (Synchronization)
ဒီေန႔ ကြၽန္ေ တာ္တို႔ database synchronization နဲ႔ ပတ္သက္တဲ႔ အေၾကာင္းေလး နည္းနည္း

ေျပာၾကရေအာင္ဗ်ာ။ database ကို synchronize လုပ္တယ္ဆိုတာဘာလဲ? တစ္ခုထက္ပိုတဲ႔
database ေတြထဲမွာ data ေတြကိုအတူတူရွိေနေအာင္ ျပဳလုပ္ျခင္းလို႔ ေျပာရမယ္ထင္တယ္။
ဒီလဗ
ို ်ာ.. ကြၽန္ေတာ္မွာ database 2 ခုရွိတယ္ db_A နဲ႔ db_B ဆိုပါေတာ့။ အဲ့ဒ ီ database ၂ ခုကို
synchronization လုပ္ခ်င္တယ္။ db_A ထဲကို ထည့္လိုက္တဲ႔ data ေတြကို db_B ထဲမွာပါ
ေရာက္သြားေစခ်င္တာေပါ့။ ဒီလို လုပ္ထားျခင္း အားျဖင့္ အေၾကာင္း တစ္ခုခုေၾကာင့္ database
တစ္ခုပ်က္သြားခဲ႔ရင္ တျခား တစ္ခုကေန data ေတြကို ျပန္ရေစနိုင္မယ္ေလ။ ေနာက္ တျခား
အသံုး၀င္တဲ႔ ေနရာေတြ အမ်ားၾကီး ရွိဦးမယ္ဗ်။
Database replication မွာ publisher, distributor နဲ႔ subscriber ဆိုျပီး အဓိက ဇာတ္လိုက္ ၃
ေယာက္ရွိတယ္ဗ်။
pic_1
Publisher ဆိုတ ာက replication မွာ dataေတြ ပို႔လႊတ္မယ့္ database ပါ။
Subscriber ဆိုတာကေတာ့ publisherက ပို႔လိုက္တ႔ဲ data ေတြကို လက္ခံမယ့္ database ပါ။
Distributor ဆိုတာကေတာ့ data ေတြကို သယ္ယူပို႔ေဆာင္ေပးတဲ႔သူလ႔ို ေျပာရမယ္ထင္တယ္။

replication နဲ႔ သက္ဆိုင္တဲ႔ replication status data ေတြကို သိမ္းထားေပးတဲ႔ database ပါ။
အိုေက အေပၚမွာ ေျပာခဲ႔သလို db_A ကေန db_B ကို replication လုပ္မယ္ဆိုရင္။ db_A က
publisher, db_B က subscriber ပါ။ publisher နဲ႔ subscriber က ကြန္ပ်ဴတာ တစ္လံုးထဲမွာ
ျဖစ္နိုင္သလို၊ local area network ထဲမွာလည္း ျဖစ္နိုင္ပါတယ္။ ဒါ့အျပင္ internet ထဲမွာ ရွိတဲ႔
server ၂ လံုးမွာလည္း ျဖစ္နိုင္ပါတယ္။ distributor database ကိုလည္း publisher computer
ထဲမွာ ျဖစ္ျဖစ္၊ subscriber computer ထဲမွာ ျဖစ္ျဖစ္၊ ဒါမွမဟုတ္လည္း တျခား ကြၽန္ပ်ဴတာ
တစ္လံုးမွာပဲ ျဖစ္ျဖစ္ ထားလို႔ ရပါတယ္။ အခုကြၽန္ေတာ္ေျပာမယ့္ example ေလးမွာေတာ့ publisher
ေရာ၊ subscriber ေရာ၊ distributor ေရာ ကို ကြန္ပ်ဴတာ တစ္လံုးထဲမွာ
ထားမွာပါ(ဒီတစ္လံုးပဲရွိတာေလ)
ကဲ အရင္ဆံုး Replication လုပ္မယ့္ database ၂ ခုကို အရင္ေဆာက္လိုက္ပါ။ publisher

လုပ္မယ့္စက္မွာ db_A နဲ႔ subscriber စက္မွာ db_B ကိုေဆာက္လိုက္ပါ။ ျပီးရင္ အဲ့ဒီ database
ေတြထဲမွာ table လည္းေဆာက္ရဦးမယ္ေနာ္။ table ေဆာက္တ႔ေ
ဲ နရာမွာ database 2 ခုလံုးမွာ
table အေရအတြက္ အတိအက် တူစရာမလိုပါဘူး။ ဒါေပမယ့္ replicate လုပ္မယ့္ table ေတာ့
တူရမယ္။ အခု sample အေနနဲ႔ ဒီလိုေလး ေဆာက္ေပးလိုက္ပါ။
Column Name Data Type Allow Nulls

ID int Unchecked
Name varchar(50) Checked
Remark varchar(250) Checked
ဒီေနရာမွာ မွတ္ထားဖို႔ လိုတာက replicate လုပ္မယ့္ table မွာ primary key ပါကိုပါရွိရမယ္။
ဒါေၾကာင့္ ID column ကို primary key အျဖစ္သက္မွတ္ေပးလိုက္ပါ။ database ေဆာက္ table
ေတြ create လုပ္ျပီးရင္ေတာ့ replication လုပ္မယ့္ အပိုင္းေရာက္ျပီ။ replication လုပ္ဖ႔အ
ို တြက္
publisher computer ထဲမွာ Distributor configuration အရင္ လုပ္ေပးရပါမယ္။
ပံု(၂) မွာ ျပထားတဲ႔အတိုင္း SQL Server Management Studio ထဲက replication folder ကို right
click လုပ္ျပီး Configure Distribution ကိုေရြးပါ။
pic_2
ဒါဆိုရင္ ပံု(၃)မွာ ျပထားတဲ႔အတိုင္း Configure Distribution Wizard ေလး ေပၚလာပါလိမ့္မယ္။

Next ကို ဆက္ႏွိပ္လိုက္ပါ။
Pic_3
Pic_4
ပံု(၄) ကေတာ့ distributor database location ေရြးခိုင္းတာပါ။ distributor ကို publisher စက္မွာ
ထားမွာလား။ ဒါမွမဟုတ္ တျခားစက္တစ္လံုးလံုးမွာ ထားမွာလားဆိုတာကို ဒီအဆင့္မွာ
ေရြးနိုင္ပါတယ္။ အခုကြၽန္ေတာ္ကေတာ့ publisher စက္မွာပဲ distributor ကိုထားမွာ
ျဖစ္တဲ႔အတြက္ေၾကာင့္ default အတိုင္းပဲ ထားျပီး Next ဆက္ႏွိပ္ပါမယ္။ replication လုပ္ဖ႔အ
ို တြက္
ကြၽန္ေ တာ္တို႔ computer မွာ SQL Server Agent Run ေနဖို႔လိုတယ္ဗ်။ အဲ့ဒီ agent မrun
ရေသးဘူးဆိုရင္ ပံု(၅) မွာျပထားတဲ႔အတိုင္း ေပၚလာလိမ့္မယ္။ run ထားျပီးသာဆိုရင္ေတ့ ေပၚမွာ
မဟုတ္ပါဘူး။
Pic_5
Pic_6
ပံု(၆)-ဒီအဆင့္မွာေတာ့ snapshot folder location ေရြးခုိင္းပါတယ္။ snapshot folder ဆိုတာက

publisher database မွာ changes လုပ္သမွ်ကို သိမ္းထားေပးတဲ႔ transaction log folder လို႔
ေျပာလို႔ရမယ္ထင္တယ္။ ဒီ folder ကို subscriber computer ကေန လွမ္းျပီး ဖတ္မွာ ျဖစ္လို႔
subscriber computer ကေန access လုပ္လ႔ရ
ို တဲ႔ location မွာ ျဖစ္ရပါမယ္။
ကြၽန္ေ တာ္အခုလုပ္သလိုမ်ိဳး publisher နဲ႔ subscriber က same computer ဆိုရင္ေတာ့
ဒီအတိုင္းထားလိုက္လည္း ရပါတယ္။ same computer မဟုတ္ဘူးဆိုရင္ေတာ့ ဒီေနရာမွာ netword
share folder location ကိုထည့္ေပးရပါမယ္။ ဒီလိုမ်ိဳးေပါ့ \\pub_computer\ReplData.
Pic_7
ပံု(၇)-ဒီအဆင့္မွာ ကြၽန္ေတာ္တ႔ို distribution database ရဲ႕ name နဲ႔ ူlocation ကို ရိုက္ေပးရမွာပါ။
default ဒီအတိုင္းေလးပဲ ထားလိုက္ျပီး Next ပါမယ္။ ပံု(ဂ)- ပံု(၉)- ပံု(၁၀)-မွာ Next ေတြနွိပ္ျပီး
Finished လိုက္ပါ။
Pic_8
Pic_9
Pic_10
Pic_11
ဒါဆို ကြၽန္ေတာ္တို႔ ပံု(၁၁) မွာ ျပထားတဲ႔အတိုင္း Distributor ကို configure လုပ္တာ ေအာင္ျမင္စြာ
ျပီးဆံုးသြားပါျပီ။
အခုကြၽန္ေတာ္ Publisher စေဆာက္ပါမယ္။ ပံု(၁၂) မွာ ျပထားတဲ႔အတိုင္း Publications Folder ကို

right click လုပ္ျပီး New Publication ကိုေရြးပါ။ ဒါဆို ပံု(၁၃) မွာ ျပထားသလို ေပၚလာပါလိမ့္မယ္။
Next ကိုႏွိပ္ပါ။
Pic_12
Pic_13
Pic_14
ပံု(၁၄)-အဆင့္မွာေတာ့ ကြၽန္ေတာ္တို႔ publication လုပ္ခ်င္တဲ႔ database ကိုေရြးေပးရမွာပါ။

အခုကြၽန္ေတာ္တို႔ db_A ကိုေရြးလိုက္ပါတယ္။ ပံု(၁၅)-အဆင့္မွာေတာ့ ကြၽန္ေတာ္တို႔ publication
type ကိုေရြးေပးရမွာပါ။ publication type အဓိက ၃ မ်ိဳးရွိပါတယ္။
- Snapshot publication
- Transactional publication
- Merge publication
ကြၽန္ေ တာ္အခု Transactional publication ကိုေရြးျပီး Next ပါမယ္။
Pic_15
Pic_16
ပံု(၁၆)-အဆင့္မွာ ကြၽန္ေတာ္တို႔ publish လုပ္ခ်င္တ႔ဲ Articles(table) ေတြကိုေရြးရပါတယ္။ ျပီးရင္

Article Properties ထဲကို ၀င္ျပီး၊ ပံု(၁၇) မွာ ျပထားတဲ႔အတိုင္း “Keep existing object
unchanged” ကိုေရြးေပးလိုက္ပါမယ္။ ဆိုလိုတာကေတာ့ အကယ္လ႔ို subscriber table ထဲမွာ data
ေတြ ရွိေနရင္ ဒီအတိုင္းပဲ ထားမယ္လို႔ ေျပာတာပါ။
Pic_17
Pic_18
ပံု(၁၈)-အဆင့္မွာ ကြၽန္ေတာ္တို႔ article ေတြအတြက္ row filter ေပးလို႔ရပါတယ္။ table ထဲမွာ ရွိသမွ်
row ေတြအားလံုးကို publish မလုပ္ပဲ condition စစ္ျပီးမွ လုပ္ခ်င္ရင္ ဒီေနရာမွာ Add button ႏွိပ္ျပီး
filter ထည့္လ႔ို ရပါတယ္။ အခုကြၽန္ေတာ္ကေတာ့ မထည့္ေတာ့ပါဘူး။
Pic_19
ပံု(၁၉)-ဒီအဆင့္မွာေတာ့ အေပၚcheckbox ေလးကို check လုပ္ျပီး Next ဆက္ႏွိပ္ပါ။ ဒါဆို

ေနာက္အဆင့္မွာ ပံု(၂၀)- မွာ ျပထားတဲ႔အတိုင္း Agent Security setting လုပ္ေပးရပါမယ္။
Pic_20
Pic_21
ပံု(၂၁)-မွာ ျပထားတဲ႔အတိုင္း SQL Server Agent service account နဲ႔ run မယ္လို႔
ေျပာလိုက္ပါတယ္။ ေနာက္ျပီး Publisher database ကို ၀င္ဖို႔အတြက္ SQL Server login account
ထည့္ေပးရပါတယ္။ ကြၽန္ေတာ္တို႔ SQL Server install လုပ္တုန္းက password
မေပးခဲ႔ဘူးဆိုရင္ေတာ့၊ By impersonation the process account ဆိုတာကို ေရြးလိုက္ပါ။
Pic_22
Pic_23
Pic_24
ပံု(၂၂)- မွာ Next ႏွိပ္၊ ပံု(၂၃)- မွာ နံမည္ေပးျပီး Finished လိုက္ပါ။ ဒါဆို ပံု(၂၄)-မွာ ျပထားသလိုမ်ိဳး
publisher ေဆာက္တ႔ဲ ကိစၥ အဆင္ေျပသြားပါျပီ။
အခု ေနာက္ဆံုး ကြၽန္ေတာ္တို႔ Subscriber ေဆာက္ဖ႔ပ

ို ဲ က်န္ပါေတာ့တယ္။ ပံု(၂၅) မွာ
ျပထားတဲ႔အတိုင္း ခုနကြၽန္ေတာ္တို႔ ေဆာက္လိုက္တဲ႔ publisher ကို right click ႏွိ္ပ္ျပီး New
Subscription ကိုေရြးလိုက္ပါ။
Pic_25
Pic_26
ပံု(၂၆) ကို Next လိုက္ရင္ ပံု(၂၇) မွာ ျပထားတဲ႔အတိုင္း ကြၽန္ေတာ္တို႔ အခုေရြး လိုက္တဲ႔ publisher
ေလးကို ေတြ႔ရပါမယ္၊ Next ထပ္ႏွိပ္ပါ။ ဒါဆို ေနာက္တဆင့္(ပံု-၂၈)မွာ Distribution Agent location
ေရြးရပါတယ္။ Distribution Agent ဆိုတာက Transactional Replication မွာ publisher ထဲက
data ေတြ ဆြဲေပးတဲ႔ process ကို ေျပာတာပါ။ Transaction Replication မွာ PUSH နဲ႔ PULL ဆိုျပီး
type ၂ မ်ိဳးရွိပါတယ္။ PUSH ကိုသံုးရင္ distribution agent က publisher computer ေပၚမွာေနျပီး
subscriber ကို replicate data ေတြ တြန္းပို႔ေပးပါတယ္။ PULL ကိုေရြးလိုက္ရင္ေတာ့ distribution
agent က subscriber computer ေပၚမွာေနျပီး publisher ဆီကေန replication data ေတြကို
ဆြဲခ်ေပးပါတယ္။ အခုကြၽန္ေတာ္ကေတာ့ PUSH ကိုပဲေရြးလိုက္ပါတယ္။
Pic_27
Pic_28
ပံု(၂၉)-အဆင့္မွာေတာ့ ကြၽန္ေတာ္တို႔ subscriber database ကိုေရြးေပးရပါတယ္။ အကယ္၍

subscriber က တျခားစက္မွာဆိုရင္ “Add Subscriber” button ေလးကိုႏွိပ္ျပီး ေရြးေပးရပါမယ္။
အခုကြၽန္ေတာ္က db_B database ကိုေရြးျပီး Next လိုက္ပါမယ္။
ပံု(၃၀)-အဆင့္မွာေတာ့ Subscriber အတြက္ Distribution Agent Security Setting

လုပ္ေပးရပါတယ္။ ပံု(၃၁) မွာ ျပထားတဲ႔အတိုင္း ေရြးျပီး Next လိုက္ပါဦး။
Pic_29
Pic_30
ပံု(၃၃)၊ ပံု(၃၄)၊ ပံု(၃၅) အဆင့္ဆင့္ Next ေတြ ႏွိပ္သြားလိုက္ရင္ ေနာက္ဆံုး ကြၽန္ေတာ္တို႔

Subscription process အဆင္ေျပေျပနဲ႔ ျပီးဆံုးသြားမွာပါ။
Pic_31
Pic_32
Pic_33
Pic_34
Pic_35
အခုကြၽန္ေတာ္တို႔ database ၂ ခု(db_A and db_B)ကို replication လုပ္လ႔ို ျပီးသြားပါျပီ။ ဒီ

replication တကယ္ေရာ အလုပ္လုပ္ျပီလား စမ္းၾကည့္ရေအာင္။ Databases folder ေအာက္က
db_A database ကို right click လုပ္ျပီး new query ေခၚလိုက္ပါ။ ျပီး ပံု(၃၆)မွာ ျပထားတဲ႔အတိုင္း
အဲ့ဒီ query ထဲမွာ INSERT STATEMENT တစ္ေၾကာင္းေရးျပီး Run လိုက္ပါမယ္။
Pic_36
ျပီးရင္ db_B ထဲမွာ ၀င္မ၀င္သြားစစ္ဖို႔အတြက္ db_B database အတြက္လည္း ေနာက္ထပ္ query

ထပ္ယူပါမယ္။ ျပီး SELECT STATEMENT ေလး ေရးလိုက္ျပီး run လိုက္ပါ။ ကဲ.. db_A ထဲကို
ကြၽန္ေ တာ္ထည့္လိုက္တဲ႔ record ကို db_B ထဲမွာပါ ေတြ႔ေနရပါျပီ။
Pic_37
အခုကြၽန္ေတာ္ ေျပာသြားတာက database replication မွာ အရိုးရွင္းဆံုး၊ အလြယ္ဆံုး အပိုင္းေလးပါ။

အားလံုး နားလည္ၾကမယ္လို႔လည္း ေမွ်ာ္လင့္ပါတယ္။ ေနာက္မွာ ပိုျပီး ရႈပ္ေထြးတဲ႔ replication ေတြ
အေၾကာင္း ဆက္ေရးပါဦးမယ္။
Chapter 12
basic of SQL Statement (part 1)
SQL Statement ေလးေတြနဲ႔ ပတ္သက္ျပီး ကြၽန္ေတာ္သိသေလာက္ basic knowledge ေလးေတြကို

ျပန္ျပီး မွ်ေ၀ေပးခ်င္လို႔ပါ။ ညီေလး ညီမေလးေတြ အတြက္ပဲေပါ့။ ကြၽန္ေတာ္တို႔ programming
လုပ္တဲ႔ သူေတြအားလံုး တခ်ိန္မဟုတ္တခ်ိန္ေတာ့ SQL Statement ေတြန႔ဲ ပတ္သက္ရမွာ မလြဲပါဘူး။
C# နဲ႔ပဲေရးေရး VB နဲ႔ပဲေရးေရး PHP နဲ႔ပဲေရးေရး java ပဲျဖစ္ျဖစ္ေပါ့ ဘယ္ language ကိုပဲ
သံုးသည္ျဖစ္ေစ data ေတြကို database တစ္ခုခုမွာ သိမ္းေတာ့မယ္၊ ျပန္ထုတ္ျပေတာ့မယ္ဆိုတာနဲ႔
ကြၽန္ေ တာ္တို႔ SQL Statement ေတြကို သံုးရေတာ့မွာပါ။ ဒီေနရာမွာ Database လိ႔ု ေျပာလိုက္ေတာ့
Microsoft platform က သူေတြက MS SQL Server ကို ေျပးျမင္ၾကမွာပါ။ ဟုတ္ပါတယ္
ကြၽန္ေ တာ္လည္း MS SQL Server 2005 ကို သံုးေနတာပါပဲ။ ဒါေပမယ့္ ဘယ္လို DBMS ကိုပဲ
သံုးသည္ျဖစ္ေစ Basic SQL Statement ေတြကေတာ့ အတူတူပါပဲ။ ဒါေၾကာင့္ ကြၽန္ေတာ္တို႔ အဲ့ဒီ

basic SQL Statement ေလးေတြအေၾကာင္း ေလ့လာၾကည့္ရေအာင္ဗ်ာ။
ဟိုးအရင္ Turbo C သံုးျပီး program ေတြ ေရးၾကတဲ႔ ေခတ္တုန္းကေတာ့ ကြၽန္ေတာ္တို႔ေတြ data

ေတြသိမ္းဖို႔အတြက္ harddisk ထဲမွာ file ေတြကိုယ္တိုင္ ေဆာက္ျပီး ကိုယ္တိုင္ပဲ
အသြင္းအထုတ္လုပ္ခဲ႔ၾကတယ္။ ေနာက္ပိုင္းမွာ DBMS(Database Management Software) ေတြ
ေပၚလာေတာ့ ကြၽန္ေတာ္တို႔ကိုယ္တိုင္ မလုပ္ေတာ့ပဲ အဲ့ဒီ DBMS ေတြကိုပဲ ခိုင္းစားလာခဲ႔ၾကတယ္။
အဲ့ဒီလို ခိုင္းဖို႔အတြက္ ကြၽန္ေတာ္တို႔က SQL လို႔ေခၚတဲ႔ Structured Query Language ကို
သံုးၾကရပါတယ္။ အဲ့ဒီ SQL မွာ အဓိက အပိုင္း ၄ ပိုင္းပါပါတယ္။
INSERT ( database ထဲကို data အသစ္ေတြထည့္ဖို႔ )
UPDATE ( database ထဲက data ေတြကို ျပင္ဖို႔ )
DELETE ( database ထဲက data ေတြကို ဖ်က္ဖို႔ )
SELECT ( database ထဲက data ေတြကို user ကို ျပန္ထုတ္ျပဖို႔ )
ဒီ command ေတြ စမ္းၾကည့္ရေအာင္အတြက္ ကြၽန္ေတာ္ database ထဲမွာ table ၂

ခုေဆာက္လိုက္မယ္။ ကြၽန္ေတာ္လက္ရွိသံုးေနတာက SQL Server 2005 ဆိုေတာ့ အဲ့ဒါနဲ႔ပဲ
ေျပာမယ္ေနာ္။ ညီတို႔က တျခား DBMS ေတြ သံုးရင္လည္း အရမ္းေတာ့ ကြာမယ္မထင္ပါဘူး။
Category Table Design
CategoryID int Primary key

CategoryName varchar(50)
Status varchar(50)
Item Table Design
ItemID int Primary key

ItemName varchar(50)
CategoryID int
Price int
Balance int
Description varchar(250)
Insert Statement
insert into tablename

(column1name,column2name...columnxname)
values (value1,value2...valuex);
Database ထဲကို data record အသစ္တခုထည့္ေတာ့မယ္ဆိုရင္ ကြၽန္ေတာ္တို႔ Insert Command

ကိုသံုးရပါမယ္။ အခု အရင္ဆံုး Category Table ထဲကို record တစ္ခု ထည့္ၾကည့္ရေအာင္။ Insert
Command ရဲ႕ အေနာက္မွာ into ဆိုတဲ႔ keyword ေလးထည့္ေရးရတယ္။ ျပီးရင္ ကိုယ္ data
ထည့္ခ်င္တဲ႔ table name ေပးရတယ္။ ျပီးေတာ့မွ ကိုယ့္ထည့္မယ့္ data ေတြကို values ဆိုတဲ႔
keyword ရဲ့ ေနာက္မွာ ထည့္ေရးေပးရမယ္။ ဥပမာ…
*** SQL SERVER 2005 တြင္ character ႏွင့္ datetime မ်ားကို single code ( ‘ )
ထည့္ေပးရပါသည္။ ***
INSERT INTO Category

VALUES (1, ‘Computer’, ‘Active’)
အေပၚက example query ေလးအတိုင္း ေရးမယ္ဆိုရင္ category table ထဲမွာ ရွိတဲ႔ field
ေတြအားလံုးအတြက္ data ထည့္ကိုထည့္ေပးရမယ္။ အစဥ္လိုက္လည္း ျဖစ္ရပါမယ္။ တခါတေလမွာ
ကြၽန္ေတာ္တို႔က column ေတြအားလံုးကို data ထည့္မေပးခ်င္တာတို႔၊ အစဥ္လိုက္မျဖစ္တာတို႔ဆိုရင္
query ေရးတဲ႔အခါ table name ရဲ့ ေနာက္မွာ ကိုယ္ထည့္ခ်င္တဲ႔ column name
ကိုပါထည့္ေရးေပးရမွာပါ။ ဥပမာ…
INSERT INTO Category (CategoryID, CategoryName)

VALUES (2, ‘Stationary’)
တခါတေလမွာ ကြၽန္ေတာ္တို႔ table တစ္ခုထဲက data ေတြကို တျခား table တစ္ခုထဲကို copy
ကူးထည့္ခ်င္တဲ႔ အခါမ်ိဳးမွာ Insert command ကို Select command နဲ႔လည္း
တြဲသံုးနိုင္ပါေသးတယ္။ ဒီလိုမ်ိဳးပါ…
INSERT INTO Temp_Category

SELECT * FROM Category
*** ဒီ query run ဖိ႔အ

ု တြက္ Temp_Category table ေလးကိုအရင္ ေဆာက္ေပး ရမယ္ေနာ္။
Category table ရဲ့ structure အတိုင္းေဆာက္လုိက္ေပါ့ ***
Update Statement
update tablename
set columnname = newvalue [,columnxname = newvaluex...]
where columnname OPERATOR value [and|or columnnamex OPERATOR valuex];
ကြၽန္ေတာ္တို႔ရဲ့ table ထဲက data ေတြကို ျပန္ျပီး ျပင္ခ်င္တယ္ဆိုရင္ေတာ့ SQL Update Command
ကိုသံုးပါတယ္။ Update Command ကို Set keyword နဲ႔ တြဲျပီး သံုးပါတယ္။ ဥပမာအေနနဲ႔
ခုနတုန္းက insert quary 2 မွာ ကြၽန္ေတာ္က categoryid နဲ႔ categoryname ၂
ခုပဲထည့္လိုက္တယ္၊ status ကိုမထည့္ေပးလုိက္ဘူး။ ဒါဆိုရင္ status က NULL value အေနနဲ႔
ရွိေနမွာပါ။ ဒါကို အခု ကြၽန္ေတာ္က Active လို႔ထည့္ေပးခ်င္တယ္ဆိုပါေတာ့… ဒါဆိုရင္
ဒီလိုေရးရပါမယ္။
UPDATE Category
SET Status = ‘Active’
WHERE CategoryID = 2
ဒီ update quary ေလးမွာ ေရးလုိက္တာေတြကေတာ့ UPDATE command ရဲ႕ အေနာက္မွာ

ကိုယ္ျပင္ခ်င္တဲ႔ tablename ထည့္ေပးရမယ္။ ျပီးရင္ SET keyword ရဲ႕ ေနာက္မွာ ကိုယ္ျပင္ခ်င္တဲ႔
column name = value ကို comer(,) ေလးခံျပီး ၾကိဳက္သေလာက္ထည့္ေပးလို႔ရပါတယ္။ အခု
example မွာေတာ့ ကြၽန္ေတာ္က Status column တစ္ခုထဲျပင္ခ်င္တာမို႔တခုထဲေပးတာပါ။
ျပီးေနာက္မွာမွ WHERE keyword ကိုသံုးျပီး ကြၽန္ေတာ္ျပင္ခ်င္တဲ႔ report ကိုေရြးထုတ္ပါတယ္။
CategoryID 2 နဲ႔ ညီတဲ႔ record ကိုပဲျပင္မယ္ဆိုတဲ႔ သေဘာပါ။ WHERE မပါပဲလည္း
ေရးလို႔ရပါတယ္။ အဲ့လိုေရးလိုက္မယ္ဆိုရင္ေတာ့ Category table ထဲက record ေတြအားလံုးကို
ျပင္သြားမွာျဖစ္ပါတယ္။ ဒါေၾကာင့္ update statement ေရးရင္ WHERE ထည့္ေရးဖို႔
လိုေလ႔ရွိပါတယ္။
Delete Statement
delete from "tablename"

where columnname OPERATOR value [and|or
columnnamex OPERATOR valuex];
Delete statement ကိုေတာ့ ကြၽန္ေတာ္တို႔ table ထဲက record ေတြကိုျပန္ဖ်က္ခ်င္ရင္ သံုးရမွာပါ။

တခုသိထားဖို႔လိုတာက delete command ကိုသံုးရင္ record (row) တခုလံုးဖ်က္မွာ ျဖစ္ပါတယ္။
column value တစ္ခုထဲကို ဖ်က္ခ်င္တယ္ဆိုရင္ေတာ့ delete command မသံုးရပါဘူး။ update
command ကိုပဲသံုးရပါမယ္။ ကဲ ကြၽန္ေတာ္က category table ထဲက record ေတြအားလံုးကို

မသံုးခ်င္ေတာ့ဘူး ဆိုပါေတာ့…
DELETE FROM Category
Delete command ကို From နဲ႔ တြဲသံုးပါတယ္၊ ေနာက္မွာေတာ့ ဖ်က္မယ့္ table name
ထည့္ေပးရမွာပါ။ record အားလံုးဖ်က္ခ်င္တာမဟုတ္ဘူးဆိုရင္ေတာ့ update command
တုန္းကလိုမ်ိဳး Where statement ကိုသံုးျပီး ကိုယ္ဖ်က္ခ်င္တဲ႔ record ရေအာင္ျပန္စစ္ထုတ္ရပါမယ္။
Insert, Update နဲ႔ Delete Statement ေတြဟာ ေရးရတာရွင္းလင္းလြယ္ကူပါတယ္။
တကယ္ရႈပ္တာကေတာ့ Select Statement ပါ။ အခုကြၽန္ေတာ္တို႔ select statement ကိုမသြားခင္
ကြၽန္ေတာ္တို႔ေဆာက္ထားတဲ႔ category နဲ႔ item table ေတြထဲကို data ေလးေတြထည့္ေပးပါဦး။ ဒါမွ
select ျပန္လုပ္လို႔ရမွာပါ။ insert command ကိုသံုးေနာ္။
Category Table
CategoryID CategoryName Status
1 Computer Active
2 Stationary Active
3 Electronic Active
4 Clothes Inactive
5 Kitchen wares Inactive
Item Table
ItemID ItemName CategoryID Price Balance Description
1 Sony Optical Mouse 1 2500 10 -
2 A4 Tech Keyboard 1 5000 1 -
3 ViewSonic 17” Flat CRT 1 150000 5 -
4 First Eleven Book 2 500 15 -
5 SONY 32” TV 3 900000 1 -
6 Moon 16” Stand Fan 3 20000 3 -
Select Statement
SELECT [ALL | DISTINCT] columnname1 [,columnname2]

FROM tablename1 [,tablename2]
[WHERE condition] [ and|or condition...]
[GROUP BY column-list]
[HAVING "conditions]
[ORDER BY "column-list" [ASC | DESC] ]
SQL Statement ၄ မ်ိဳးမွာျဖင့္ ဒီ select က အရွဳပ္ဆံုးပါပဲဗ ်ာ။ user ၾကည့္ခ်င္တဲ႔ result ရဖိ႔အ
ု တြက္
ကြၽန္ေတာ္တို႔ select command ကို နည္းလမ္းမ်ိဳးစံုနဲ႔ သံုးရမွာပါ။ အရႈပ္ဆံုးဆိုလို႔လည္း
လန္႔မသြားနဲ႔ဦးေနာ္၊ ဘယ္အရာမဆို မသိရင္ခက္ျပီး သိသြားရင္ေတာ့ လြယ္ပါတယ္။ ကဲ..
အလြယ္ဆံုးကေန စလိုက္ရေအာင္။ ပထမဆံုး ကြၽန္ေတာ္က Category Table ထဲက record
ေတြအားလံုးကို user ကို ထုတ္ျပခ်င္တယ္ ဆိုပါေတာ့။ ဒါဆိုရင္ ဒီလိုေရးရမွာပါ။
SELECT * FROM Category
Result :
1 Computer Active
2 Stationary Active
3 Electronic Active
4 Clothes Inactive
5 Kitchen wares Inactive
Select command ရဲ႕ ေနာက္မွာ ကိုယ္ထည့္ၾကည့္ခ်င္တဲ႔ column name ေတြေပးရမွာပါ။ ရွိသမွ်

ေကာ္လံအားလံုးကို ထုတ္ျပမယ္ဆိုရင္ ကြၽန္ေတာ္အခုေရးလိုက္သလို (*) ကို သံုးလို႔လည္း ရပါတယ္။
ဒါဆို အခုကြၽန္ေတာ္က CategoryID နဲ႔ CategoryName ၂ ခုပဲ ၾကည့္ခ်င္တယ္ဆိုရင္
ဒီလိုျဖစ္သြားမယ္။
SELECT CategoryID,CategoryName FROM Category
Result :
CategoryID CategoryName
1 Computer
2 Stationary
3 Electronic
4 Clothes
5 Kitchen wares
ဘယ္လိုလဲ လြယ္ပါတယ္ေနာ္။ လြယ္မွာေပါ့ ဒါက အရိုးရွင္းဆံုး select ပံုစံကို။ ကဲ အခုကြၽန္ေတာ္က

category table ထဲက record အားလံုးမၾကည့္ခ်င္ဘူး Status က Active ျဖစ္တဲ႔ Category ေတြပဲ
ၾကည့္ခ်င္တယ္ ဆိုရင္ Condition ျပန္စစ္ဖို႔လိုလာပါျပီ။ select command မွာ condition
စစ္ဖ႔အ
ို တြက္ where ရယ္၊ having ရယ္ ၂ ခု ၾကိဳက္တာသံုးခြင့္ရွိပါတယ္။ ဒီ ၂ ခုဘာကြာလဲဆိုတာ
ေနာက္မွေျပာျပပါမယ္။ ေလာေလာဆယ္ေတာ့ ကြၽန္ေတာ္က where ကိုပဲ သံုးျပီး စစ္လုိက္ပါမယ္။
SELECT * FROM Category WHERE Status = ‘Active’
Result :
1 Computer Active
2 Stationary Active
3 Electronic Active
ဒါဆိုရင္ေတာ့ record ၃ ေၾကာင္းပဲ ျပပါေတာ့မယ္။
ဒီေန႔ Select Statement အေၾကာင္းပဲ ဆက္ရေအာင္ဗ်ာ။ WHERE အေၾကာင္းပဲ ဆက္ေျပာပါ့မယ္။

အခုကြၽန္ေတာ္က ကုန္လက္က်န္ ၁၀ ခုထက္နည္းျပီး ေစ်းႏႈန္းကလည္း ၁၀၀၀၀ အထက္ရွိတဲ႔ item
ေတြရဲ့ list ကိုၾကည့္ခ်င္တယ္။ ဒါဆိုရင္ ဒီလိုေရးရမွာေပါ့…
SELECT * FROM item

WHERE balance < 10 AND price > 10000
Result :
ViewSonic 17” Flat

3 11 15000 5 -
CRT
5 SONY 32” TV 3 900000 1 -
6 Moon 16” Stand Fan 3 20000 3 -
ဒီ query ေလးမွာ ကြၽန္ေတာ္စစ္ခ်င္တဲ႔ condition က ၂ ခုရွိေနတယ္။ balance ၁၀

ခုထက္နည္းရမွာရယ္၊ price ၁၀၀၀၀ ထက္မ်ားရမွာရယ္။ အဲ့ဒီ condition ၂ ခုလံုးမွန္တာကိုပဲ
လိုခ်င္တာ ျဖစ္ေတာ့ Where ေနာက္မွာ condition ၂ ခုကို AND နဲ႔ဆက္ျပီးေရးရပါတယ္။
ကြၽန္ေတာ္တို႔ စစ္ခ်င္တဲ႔ condition ေတြ ၁ခုထက္ပိုမ်ားလာျပီဆိုရင္ အဲ့ဒီ condition ေတြၾကားမွာ
AND ဒါမွမဟုတ္ OR ဆိုတဲ႔ keyword ေလးေတြထည့္ေရးေပးရမယ္။ အေပၚက query လိုမ်ိဳး
condition ၂ ခုလံုးမွန္မွ result ထြက္ခ်င္တယ္ဆိုရင္ AND ကိုသံုးရျပီး။ condition တစ္ခုမဟုတ္
တစ္ခုမွန္ရံုနဲ႔ result ထြက္ခ်င္တယ္ဆိုရင္ေတာ့ OR ကိုသံုးရမွာပါ။ ဥပမာ အေနနဲ႔ ကြၽန္ေတာ္က
electronic ပစၥည္းေတြနဲ႔ computer ပစၥည္းေတြကိုပဲ ၾကည့္ခ်င္တယ္ ဆိုပါစို။ ဒါဆို ဒီလိုေရးရမွာပါ…
SELECT * FROM item

WHERE CategoryID = 1 OR CategoryID = 3
Result :
5 SONY 32” TV 3 900000 1 -
6 Moon 16” Stand Fan 3 20000 3 -
တခါတေလမွာ ကြၽန္ေတာ္တို႔စစ္ခ်င္တဲ႔ condition က value ၂ ခုၾကားျဖစ္ခဲ႔ရင္ BETWEEN ကိုလည္း

သံုးလို႔ရပါတယ္။ ဥပမာ balance ၂ ခုကေန ၁၀ ခု ၾကားထဲက record ေတြ လိုခ်င္တယ္ဆိုရင္…
SELECT * FROM item

WHERE balance BETWEEN 2 AND 10
Result :
3 ViewSonic 17” Flat 11 15000 5 -

CRT
6 Moon 16” Stand Fan 3 20000 3 -
ထြက္လာတဲ႔ result ရဲ့ ဆန္က်င္ဘက္ ေျပာင္းျပန္ကို လိုခ်င္တယ္ ဆိုရင္ေတာ့ NOT ကို တြဲသံုးလို႔
ရပါတယ္။
SELECT * FROM item

WHERE balance NOT BETWEEN 2 AND 10
Result:
5 SONY 32” TV 3 900000 1 -
တစ္ခါတစ္ေလ ကြၽန္ေတာ္တို႔ လိုခ်င္တဲ႔ record ေတြက အစီအစဥ္လိုက္မဟုတ္ဘူး ဆိုရင္ေတာ့

condition စစ္တဲ႔အခါ OR ေတြအမ်ားၾကီးသံုးရမယ့္ အေနအထားေတြ ရွိလာနိုင္ပါတယ္။ ဥပမာ
ကြၽန္ေတာ္က ItemID 1,3,5 ကိုထုတ္ၾကည့္မယ္ဆိုရင္ OR သံုးျပီးစစ္ရင္ ဒီလိုမ်ိဳးျဖစ္ပါမယ္။
SELECT * FROM item

WHERE ItemID = 1 OR ItemID = 3 OR ItemID = 5
ဒီလို အေျခအေနမ်ိဳးမွာ ကြၽန္ေတာ္တို႔ IN ကိုသံုးျပီးေရးရင္ ပိုလြယ္မွာပါ။
SELECT * FROM item

WHERE ItemID IN ( 1,3,5 )
Result:
3 ViewSonic 17” Flat 11 15000 5 -

CRT
5 SONY 32” TV 3 900000 1 -
ItemID 1,3,5 ကလြဲျပီး က်န္တာေတြ ျပမယ္ဆိုရင္ေတာ့
SELECT * FROM item

WHERE ItemID NOT IN ( 1,3,5 )
Result:
6 Moon 16” Stand Fan 3 20000 3 -
ဒီေလာက္ဆိုရင္ေတာ့ ကြၽန္ေတာ္တို႔ WHERE Condition ေတာ္ေတာ္ေလးစစ္တက္ျပီလို႔

ေျပာလို႔ရပါျပီ။ အခုေနာက္ထပ္ ORDER BY အေၾကာင္း ဆက္ေျပာပါ့မယ္။ Select Query
ကေနထြက္လာတဲ႔ result record ေတြကို sorting လုပ္ခ်င္ရင္ Order By keyword ကိုသံုးရမွာပါ။
အိုေက အခုကြၽန္ေတာ္ Item table ထဲက record ေတြအားလံုးၾကည့္ခ်င္တယ္။
ကုန္လက္က်န္အနည္းဆံုးက အေပၚဆံုးမွာျပခ်င္တယ္ဆိုရင္….
SELECT * FROM item

ORDER BY balance
Result:
2 A4 Tech Keyboard 1 5000> 1 -
5 SONY 32” TV 3 900000 1 -
6 Moon 16” Stand Fan 3 20000 3 -
3 ViewSonic 17” Flat 11 15000 5 -

CRT
Order by keyword က default အားျဖင့္ ငယ္စဥ္ၾကီးလိုက္(Ascending) စီေပးပါတယ္။

ၾကီးစဥ္ငယ္လိုက္(Descending) စီခ်င္တယ္ဆိုရင္ေတာ့ ကိုယ္စီခ်င္တဲ႔ column name ေနာက္မွာ
DESC ဆိုျပီးထည့္ေပးရပါမယ္။ ဥပမာ ကုန္လက္က်န္အမ်ားဆံုးကို အေပၚဆံုးကေန ျပခ်င္ရင္…
SELECT * FROM item

ORDER BY balance DESC
Result:
3 ViewSonic 17” Flat 11 15000 5 -

CRT
6 Moon 16” Stand Fan 3 20000 3 -
5 SONY 32” TV 3 900000 1 -
အခုလို sorting စီတဲ႔ေနရာမွာ Column တစ္ခုထက္ပိုျပီး စီခ်င္ရင္ comer(,) ေလးေတြ

ျခားသြားရံုပါပဲ။ ကုန္လက္က်န္ အနည္းဆံုးကို အရင္စီမယ္၊ ကုန္လက္က်န္ အေရအတြက္ခ်င္း တူရင္
ေစ်းႏႈန္းအမ်ားဆံုးကို အေပၚကထားခ်င္တယ္ဆိုရင္….
SELECT * FROM item

ORDER BY Balance ASC, Price DESC
(*** ASC ကို ထည့္ေရးေရး၊ မေရးေရး ရပါ၏ ***)
Result:
5 SONY 32” TV 3 900000 1 -
6 Moon 16” Stand Fan 3 20000 3 -
3 ViewSonic 17” Flat 11 15000 5 -

CRT
ဒီေလာက္ဆိုရင္ေတာ့ ကြၽန္ေတာ္တို႔ Simple Select Query ေတြ ေရးတက္ပါျပီ။
Chapter 13
အခု ကြၽန္ေတာ္တို႔ Select quary ေတြမွာ count တိ႔ု sum တို႔ စသည့္ျဖင့္ function
ေတြထည့္သံုးၾကည္ရေအာင္။ အဲ့ဒီ function ေတြကို aggregate function ေတြလ႔ို ေခၚတယ္။ ဒီလို
aggregate function ေတြပါတဲ႔ query ေတြကိုလည္း aggregate query လိ႔ေ
ု ခၚပါတယ္။
Aggregate Functions List
AVG MIN
CHECKSUM SUM
CHECKSUM_AGG STDEV
COUNT STDEVP
COUNT_BIG VAR
GROUPING VARP
MAX
ဒီ function ေတြကို ကြၽန္ေတာ္တို႔ Select ရဲ့ ေနာက္မွာ ျဖစ္ေစ၊ Having ရဲ့ေနာက္မွာ ျဖစ္ေစ၊
သံုးနိုင္ပါတယ္။ ဥပမာ အခုကြၽန္ေတာ္က ItemTable ထဲမွာ ရွိတဲ႔ record အေရအတြက္ကို
သိခ်င္တယ္ဆိုပါစို႔။ ဒါဆိုရင္ Count ဆိုတ႔ဲ aggregate function ကိုသံုးျပီး ခုလိုေရးရမွာပါ။
SELECT count(*) AS ItemCount FROM item
Result:
ItemCount
Count ဆိုတဲ႔ function က ကြၽန္ေတာ္တို႔ Table ထဲမွာ ရွိတဲ႔ record အေရအတြက္ကိုစစ္ေပးပါတယ္။

အဲ့ဒီ function ထဲမွာ * ဒါမွမဟုတ္ ၾကိဳက္ရာ column name ထည့္ေပးရပါမယ္။ ဒီ function
ေတြကိုသံုးရင္ ထြက္လာတဲ႔ result မွာ column name မရွိပါဘူး။ ဒါေၾကာင့္ ကြၽန္ေ တာ္က column
name ထည့္ေပးဖို႔အတြက္ AS keyword ကိုသံုးပါတယ္၊ AS ေနာက္မွာ ကြၽန္ေတာ္ေပးခ်င္တဲ႔
ItemCount ဆိုတဲ႔ နံမည္ေလးထည့္ေပးလိုက္ပါတယ္။ တျခား Function ေတြကိုလည္း
စမ္းၾကည့္ရေအာင္။ ကြၽန္ေတာ္အခု စုစုေပါင္းကုန္လက္က်န္ကို သိခ်င္တယ္ဆိုရင္။
SELECT sum(balance) AS TotalBalance FROM item
Result:
TotalBalance
35
အခုကြၽန္ေတာ္တို႔ aggregate function ေတြကိုသံုးတဲ႔အခါမွာ table ထဲက record အားလံုးအတြက္

result တစ္ခုထဲထြက္တာကို ေတြ႔ရလိမ့္မယ္။ ဟုတ္ျပီ ဒါဆိုရင္ အခုကြၽန္ေတာ္က Category
တစ္ခုစီအတြက္ ကုန္လက္က်န္ကို ၾကည့္ခ်င္တယ္ဆိုရင္ေရာ။ ဒီလိုလုပ္ဖို႔ဆိုရင္ေတာ့ ကြၽန္ေတာ္တို႔
Group By keyword နဲ႔ တြဲသံုးေပးဖို႔လိုလာပါျပီ။
SELECT categoryid,sum(balance) AS TotalBalance

FROM item
GROUP BY categoryid
Result:
categoryID TotalBalance
1 16
2 15
3 4
*** မွတ္ထားစရာ အခ်က္တစ္ခ်က္ရွိေသးတယ္ဗ်။ select ထဲမွာ aggregate function ေတြ

ပါျပီဆိုရင္၊ Group By လုပ္ထားတဲ႔ column ေတြကလြဲျပီး တျခား column ေတြကို ထည့္ေရးခြင့္
မရွိပါဘူး***
အခု Having keyword အေၾကာင္းဆက္ေျပာရေအာင္။ ကြၽန္ေတာ္တို႔ေရးတဲ႔ query မွာ condition
စစ္စရာေတြ ရွိရင္ where ကိုသံုးရတယ္ဆိုတာ သိျပီးၾကျပီေနာ္။ ဟုတ္ျပီ အဲ့ဒီ where keyword က
database ထဲမွာ ရွိတဲ႔ column name ေတြကိုပဲ စစ္လို႔ရပါတယ္။ တခါတေလကြၽန္ေတာ္တို႔က
aggregate function ကထြက္လာတဲ႔ result ေတြကို စစ္ဖို႔လိုလာျပီဆိုရင္ေတာ့ Having
ကိုသံုးရေတာ့မွာပါပဲ။ ဥပမာ ကုန္လက္က်န္ စုစုေပါင္း ၁၀ ခုထက္နည္းနဲ႔ category
ကိုၾကည့္ခ်င္တယ္ဆိုရင္။

FROM item
GROUP BY categoryid
HAVING sum(balance) < 10
Result:
3 4
Having ကို where လိုမ်ိဳးလဲ column ေတြစစ္ဖို႔အတြက္ သံုးလို႔လည္း ရပါတယ္။ category id 1 ရဲ႕
totalbalance ကိုျပဖိ႔အ
ု တြက္

FROM item
GROUP BY categoryid
HAVING categoryid = 1
Result:
1 16
Sql statement ေတြဘက္ကိုေတာ့ မလွည့္ျဖစ္တာ ေတာ္ေတာ္ၾကာသြားျပီ။ ကြၽန္ေတာ္လည္း

ေရးခ်င္တာေတြကေတာ့ အမ်ားၾကီး အခ်ိန္ကမရွိဘူး ျဖစ္ေနတာနဲ႔ ေရွ႕မဆက္နိုင္ဘူးျဖစ္ေနတာ။
ဘာဘဲျဖစ္ျဖစ္ ရတဲ႔အခ်ိန္ေလးလုျပီး ကြၽန္ေတာ္သိသေလာက္ေတာ့ ထပ္ေရးေနဦးမွာမို႔
အားေပးၾကပါဦးဗ်ာ။ ကဲ… ကြၽန္ေတာ္တို႔ select statement ကို ေျပာလက္စ ဆက္ပါဦးမယ္။ table
တစ္ခုထဲက data ကို ထုတ္ၾကည့္တာကိုေတာ့ နားလည္ေလာက္ျပီထင္ပါတယ္။ အခု ကြၽန္ေတာ္တို႔
တစ္ခုထက္ပိုတဲ႔ table ေတြထဲက data ေတြကို ထုတ္ၾကည့္ရေအာင္။ ဥပမာဗ်ာ… item table ထဲက
record အားလံုးျပမယ္ဆိုပါေတာ့။ ဒါေပမယ့္ categoryid အစား categoryname
ကိုျပခ်င္တယ္ဆိုရင္၊ item table နဲ႔ category table ၂ ခုကို ခ်ိတ္ရေတာ့မွာပါ။ ဟုတ္ျပီ… ဒါဆိုရင္
table ေတြ ခ်ိတ္ဖို႔အတြက္ ဘာေတြလိုလဲ… ?
ဟုတ္က႔ဲ table တစ္ခုနဲ႔ တစ္ခုခ်ိတ္ဆက္တာကို join လုပ္တယ္လို႔ ေခၚပါတယ္။ join နည္း ၃

မ်ိဳးရွိပါတယ္။
၁) cross join
Cross join ကေတာ့ table ၂ ခုကို comer(,) ခံျပီး join တာပါ။ ဒီလိုမ်ိဳးပါ
select item.*, category.categoryName

from item, category
result
ItemID ItemName CategoryID Price Balance Remark CategoryName

1 Sony Optical Mouse 1 2500 10 - Computer
2 A4 Tech Keyboard 1 5000 1 - Computer
3 ViewSonic 17” Flat CRT 1 15000 5 - Computer
4 First Eleven Book 2 500 15 - Computer
5 SONY 32” TV 3 900000 1 - Computer
6 Moon 16” Stand Fan 3 20000 3 - Computer
1 Sony Optical Mouse 1 2500 10 - Stationary
2 A4 Tech Keyboard 1 5000 1 - Stationary
3 ViewSonic 17” Flat CRT 1 15000 5 - Stationary

4 First Eleven Book 2 500 15 - Stationary
5 SONY 32” TV 3 900000 1 - Stationary
6 Moon 16” Stand Fan 3 20000 3 - Stationary
1 Sony Optical Mouse 1 2500 10 - Electronic
2 A4 Tech Keyboard 1 5000 1 - Electronic
3 ViewSonic 17” Flat CRT 1 15000 5 - Electronic
4 First Eleven Book 2 500 15 - Electronic
5 SONY 32” TV 3 900000 1 - Electronic
6 Moon 16” Stand Fan 3 20000 3 - Electronic
1 Sony Optical Mouse 1 2500 10 - Clothes
2 A4 Tech Keyboard 1 5000 1 - Clothes
3 ViewSonic 17” Flat CRT 1 15000 5 - Clothes
4 First Eleven Book 2 500 15 - Clothes
5 SONY 32” TV 3 900000 1 - Clothes
6 Moon 16” Stand Fan 3 20000 3 - Clothes
1 Sony Optical Mouse 1 2500 10 - Kitchen wares
2 A4 Tech Keyboard 1 5000 1 - Kitchen wares
3 ViewSonic 17” Flat CRT 1 15000 5 - Kitchen wares
4 First Eleven Book 2 500 15 - Kitchen wares
5 SONY 32” TV 3 900000 1 - Kitchen wares
6 Moon 16” Stand Fan 3 20000 3 - Kitchen wares
cross join လိ႔ု ဆိုတဲ႔ အတိုင္းပါပဲ။ ဒီပံုစံက table ၂ ခုကို ေျမွာက္လို႔ရတဲ႔ အတိုင္း result
ထြက္ပါတယ္။ item ထဲမွာက record ၆ ေၾကာင္း၊ category ထဲမွာက record ၅ ေၾကာင္း ရွိပါတယ္။
ဒါေၾကာင့္ အေပၚက query ကို run လိုက္ရင္ record စုစုေပါင္း အေၾကာင္း ၃၀ ထြက္ပါလိမ့္မယ္။
item table ထဲက record ၁ေၾကာင္းစီ အတြက္ category table ထဲမွာ record ရွိသေလာက္ကို
ထုတ္ျပသြားတာပါ။ ကြၽန္ေတာ္က ့ အကုန္မထုတ္ပဲ item table ထဲမွာ ပါတဲ႔ categoryID နဲ႔
category table ထဲမွာပါတဲ႔ categoryID တူတဲ႔ record ေတြပဲ ထုတ္ျပခ်င္တယ္ဆိုရင္ေတာ့
ထြက္လာတဲ႔ result ကို condition ျပန္စစ္ဖို႔ လိုပါတယ္။ ဒါေၾကာင့္ ကြၽန္ေတာ္တို႔ where ကို သံုးျပီး
အခုလို ေရးရပါမယ္။
from item, category where item.categoryID = category.categoryID
result

၂) inner join
Inner join က cross join ကို where ထည့္ထားတဲ႔ ပံုစံန႔ဲ တူပါတယ္။ table ၂ ခုကို join ဖိ႔အ
ု တြက္
On keyword ကိုသံုးပါတယ္။ ဒီလိုမ်ိဳးပါ..

from item inner join category
on item.categoryID = category.categoryID
result

inner join နဲ႔ေရးထားတဲ႔အတြက္ item table ထဲက categoryID က category table ထဲမွာ
ရွိမေနဘူးဆိုရင္ အဲဒီ record ကို ထုတ္ျပေပးမွာမဟုတ္ပါဘူး။ ဟုတ္ျပီ တစ္ခါတေလမွာ ကြၽန္ေတာ္က
item table ထဲက အားလံုးထုတ္ျပခ်င္တယ္၊ category table ထဲမွာ ရွိရင္ category name ျပျပီး၊
မရွိရင္ေတာ့ null ပဲေပၚလာခ်င္တယ္ဆိုရင္။ တနည္းအားျဖင့္ table တခုခုကို မူတည္ျပီး
ျပခ်င္တယ္ဆိုရင္ ကြၽန္ေတာ္တို႔ inner join ကိုသံုးလို႔ မရေတာ့ပါဘူး။ ဒီအခါမွာ outer join

ကိုသံုးရေတာ့မွာပါ။
၃) outer join
Outer join ကို ၂ ပိုင္းထပ္ခြဲနိုင္ပါတယ္။ Left outer join နဲ႔ Right outer join ပါ။ join keyword ရဲ႕
ဘယ္ဖက္က table ကို အကုန္ျပမယ္ဆိုရင္ left join နဲ႔ ေရးရျပီး။ join keyword ရဲ႕ ညာဖက္က
table ကို အကုန္ျပခ်င္ရင္ေတာ့ right join နဲ႔ ေရးပါမယ္။

from item left join category
result

from item right join category
result

3 ViewSonic 17” Flat 1 15000 5 - Computer
CRT
NULL NULL NULL NULL NULL NULL Clothes

NULL NULL NULL NULL NULL NULL Kitchen wares
left join လိ႔ေ

ု ရးေရး left outer join လို႔ပဲ ေရးေရး တူတူပါပဲ။ right join နဲ႔ right outer join လည္း
တူတယ္ေနာ္။ ေနာက္ဆံုး query result မွာ null ေတြထြက္လာတာ ေတြ႔ရတယ္ေနာ္၊
ဘာလို႔လဲဆိုေတာ့ category table ကို မူတည္ျပီး ယူလိုက္ေတာ့ item table ထဲမွာ
မရွိတာေတြအတြက္ null ေတြထြက္လာတာပါ။
ဒီေန႔လည္း ကြၽန္ေတာ္တို႔ SQL statement ေတြအေၾကာင္းပဲ ဆက္ေျပာရေအာင္ဗ်ာ။ subquery

အေၾကာင္းေျပာခ်င္လို႔ဗ်။ ကြၽန္ေတာ္က category table ထဲက categoryID 1, 3, 5 နဲ႔ တူတာေတြ
ထုတ္ခ်င္တယ္ဆိုရင္… OR ကိုသံုးရင္ ဒီလိုေရးရမယ္…
select * from category

where categoryid = 1 or categoryid = 3 or categoryid = 5
result:

1 Computer Active
2 Stationary Active
3 Electronic Active
categoryID အမ်ားၾကီး ကိုခုလိုမ်ိဳး စစ္မယ္ဆိုရင္ OR ကိုသံုးရတာ အဆင္မေျပေတာ့ပါဘူး။ ဒီအခါမွာ

In keyword ကိုသံုးျပီး ခုလိုေရးလို႔ရပါတယ္…

where categoryid in ( 1, 2, 3 )
result:

1 Computer Active
2 Stationary Active
3 Electronic Active
အခုကြၽန္ေတာ္က စုစုေပါင္း ကုန္လက္က်န္ ၅ခု ထက္မ်ားတဲ႔ category ေတြကို

ထုတ္ျပခ်င္တယ္ဆိုရင္…

where categoryid in (
select categoryid from item
group by categoryid
having SUM(balance)>5
)
result:

1 Computer Active
2 Stationary Active
အေပၚက ေရးထားတဲ႔ query ကို တစ္ပိုင္းခ်င္း အရင္ run ၾကည့္လိုက္

select categoryid from item
group by categoryid
having SUM(balance)>5
ကို run ရင္ အေျဖက 1,2 ဆိုျပီးထြက္လာမယ္၊ အဲ့ဒီ result ကိုမွ ေပၚက query က in နဲ႔
ျပန္စစ္ယူသြားတာ။ ဒီလို query တစ္ခုထဲမွာပါတဲ႔ ေနာက္ထပ္ query ကို subquery ဒါမွမဟုတ္
inner query လို႔ေခၚပါတယ္။ အခု where ေနာက္မွာ ေရးတဲ႔ subquery မွာ column
အမ်ားၾကီးထုတ္လို႔မရဘူး။ where ေနာက္က condition စစ္ထားတဲ႔ column
တစ္ခုကိုပဲထုတ္ေပးရတယ္။ select ေနာက္မွာ column တစ္ခုအေနနဲ႔လည္း subquery
ကိုသံုးလို႔ရပါေသးတယ္။ ဥပမာဗ်ာ.. ကြၽန္ေတာ္က category အားလံုးနဲ႔ သူတို႔ရဲ႕
ကုန္လက္က်န္စုစုေပါင္းကိုပါ ျပခ်င္တယ္ဆိုရင္….။
select *, (
select sum(balance)
from item
where category.categoryid = item.categoryid
group by item.categoryid
) as totalbalance
from category
result:
CategoryID CategoryName Statius totalbalance

1 Computer Active 16
2 Stationary Active 15
3 Electronic Active 4
4 Clothes Inactive NULL
5 Kitchen wares Inactive NULL
ဒီ query ေလးမွာ အဓိက ထုတ္တာကေတာ့ category table ပဲ၊ totalbalance column အတြက္မွ
ေနာက္ထပ္ query ကိုထပ္ေခၚသြားတာ။ ဒီေနရာမွာ သတိထားရမွာက subquery ထဲကေန
ထြက္လာမယ့္ value က only one row ပဲျဖစ္ရမယ္။ ဒါေၾကာင့္ where category.categoryid =
item.categoryid ဒီအပိုင္းေလး ထည့္ေရးေပးရတယ္။ ဟုတ္ျပီ… ဒါဆိုရင္ ကြၽန္ေတာ္တို႔ subquery
ဘယ္လိုေရးရလဲဆိုတာ နည္းနည္း သိေလာက္ပါျပီ။ အခု အေပၚက query ကိုပဲ ၾကည့္ပါ select
ထဲမွာ ေနာက္ထပ္ select ေတြ ထပ္ေရးေတာ့ query ကိုၾကည့္လိုက္ရင္ ရႈပ္ေနသလို ျဖစ္ေနလိမ့္မယ္။
ဒီအခါမ်ိဳးမွာ ပိုျပီး ရွင္းသြားဖို႔အတြက္ ကြၽန္ေတာ္တို႔ ကိုယ္ပိုင္ function ေတြေဆာက္ျပီး
ေရးလို႔ရပါတယ္။ အိုေက.. function ေတြအေၾကာင္းကို ေနာက္မွ ဆက္ေျပာရေအာင္။
ဒီေန႔ ကြၽန္ေတာ္တို႔ SQL Server 2005 မွာ function ေတြကိုယ္တိုင္ ေဆာက္ျပီး သံုးတဲ႔ ပံုစံေလး
ေလ့လာလိုက္ရေအာင္ဗ်ာ။ function ၂ မ်ိဳးေဆာက္လို႔ရတယ္ဗ်။ Table-valued function နဲ႔ Scalar-
valued function တိုျဖစ္ပါတယ္။ Table-valued function ရဲ႕ return type က table တစ္ခုလိုမ်ိဳး
column တစ္ခုထက္ပိုတဲ႔ data ေတြကို return ျပန္ပါတယ္။ Scalar-valued function ကေတာ့
return value အေနနဲ႔ column တစ္ခုပဲ return ျပန္ပါတယ္။ အရင္ဆံုး scalar-valued function
ေလး တစ္ခုေလာက္ ေရးၾကည့္ရေအာင္။ မေန႔တုန္းက ေရးခဲ႔တဲ႔ category ေတြနဲ႔ total balance
ထုတ္တ႔ဲ query ေလးကို ျပန္ေရးပါ့မယ္။
select category.*,
(
select sum(balance)
from item
where item.categoryid = category.categoryid
) as totalbalance
from category
result:
CategoryID CategoryName Status totalbalance

အိုေက ဒီquery ထဲမွာ ေရးထားတဲ႔ subquery ေလးကို ကြၽန္ေတာ္က function ေလးခြဲျပီး

ေရးခ်င္တာပါ။ အဲ့ဒီလိုေရးလိုက္ျခင္းအားျဖင့္ query ေရးတဲ႔ ေနရာမွာ ပိုျပီးရွင္းသြားမယ္။ ဒီေနရာမွာ
ကြၽန္ေတာ္လိုခ်င္တာက totalbalance တစ္ခုထဲျဖစ္တဲ႔ အတြက္ scalar-valued function
ေဆာက္ပါမယ္။ ဒီလိုပါ…
CREATE FUNCTION GetTotalBalance (@CategoryID int)

RETURNS int
AS
BEGIN
DECLARE @TotalBalance int
SELECT @TotalBalance = SUM(balance)
FROM Item
WHERE CategoryID = @CategoryID
RETURN @TotalBalance
END
Function ေဆာက္ဖို႔ CREATE FUNCTION keyword ကိုသံုးပါတယ္။ ျပန္ျပင္ဖ႔အ

ို တြက္ေတာ့
ALTER FUNCTION နဲ႔
ALTER FUNCTION GetTotalBalance (@CategoryID int)

RETURNS int
AS
BEGIN
DECLARE @TotalBalance int
SELECT @TotalBalance = SUM(balance)
FROM Item
WHERE CategoryID = @CategoryID

RETURN @TotalBalance
END
ဖ်က္ဖို႔အတြက္ေတာ့ DROP FUNCTION keyword တို႔ကို သံုးပါတယ္။
DROP FUNCTION GetTotalBalance
ဒီ function မွာ CategoryID ကို parameter လက္ခံျပီး item table ထဲမွာ အဲ့ဒီ categoryID ရဲ႕
totalbalance ကို return ျပန္ပါတယ္။ အိုေက အခုကြၽန္ေတာ္တို႔ ဒီ function ကို create
လုပ္ျပီးသြားျပီဆိုရင္ ကြၽန္ေတာ္တို႔ ရဲ႕ query ေတြမွာ ျပန္ေခၚသံုးလို႔ ရပါျပီ။
select category.*, dbo.GetTotalBalance(categoryID)

from category
result:
CategoryID CategoryName Status totalbalance

ကဲ ေနာက္ထပ္ FUNCTION တစ္မ်ိဳးက Table-valued function. အခုကြၽန္ေတာ္ categoryname,

totalbalance နဲ႔ totalamount တို႔ကို ထုတ္ျပခ်င္ပါတယ္။ အဲ့ဒီ အတြက္ Table-value function
ေလး ေဆာက္ရေအာင္။ သူလည္းပဲ Create function keyword ကိုပဲ သံုးပါတယ္။
CREATE FUNCTION GetItemByCategory()

RETURNS TABLE
AS
RETURN
(
SELECT categoryname,
sum(balance) as totalBalance,
sum(price * balance) as totalamount
FROM Item inner join category
ON item.categoryID = category.categoryID
GROUP BY categoryname
)
ျပီးရင္ အဲ့ဒီ function ေလးကို ဒီလို ေခၚပါမယ္
select * from GetItemByCategory()
result:
Categoryname totalBalance totalamount

Computer 16 105000
Electronic 4 960000
Stationary 15 7500
မွတ္ခ်က္။ ကၽြန္ေတာ္ ကိsု evenlamp ဆီက ခြင္႔ေတာင္းဖိ႔ု အေျခအေနမေပးလို႔ မေျပာျဖစ္ေပမဲ႔

အခုတစ္ခါတည္း ခြင္႔ေတာင္းလိုက္တာပါ..ကၽြန္ေတာ္႔လို အခုမွ စတင္ေလ႔လာသူေတြ တစ္ေနရာတည္းမွာ
အကုိ႔ပ႔စ
ို ္ေတြကုိစုစည္းဖတ္နိုင္ေစဖိ႔က
ု ၽြန္ေတာ္ေလ႔လာရင္းနဲ႔တစ္ခါတည္းစုစည္းေပးလိက
ု ္တာပါ..အကုိနားလည္
နိုင္မယ္ထင္ပါတယ္…အကုိေရးထားတာေတြကို ဖတ္ရင္း အတိုင္းအတာတစ္ခုအထိ ကၽြန္ေတာ႔္အတြက္
အက်ဳိးရွိခ႔ပ
ဲ ါတယ္…ေနာင္ဒီပ႔စ
ို ္ေတြကုိ ဖတ္မဲ႔ ညီငယ္ညီမငယ္ေတြလည္း အက်ဳိး ရွိမွာပဲလ႔ို ခံယူၿပီး
အကို႔ပ႔စ
ုိ ္ေတြကို စုစည္းေပးခ်င္တ႔ဲ ရည္ရြယ္ခ်က္ျဖစ္လာၿပီး စာအုပ္ေလးအျဖစ္ အမ်ားသူငါ ဖတ္နိုင္ေစရန္
လုပ္ေပးလုိက္ပါတယ္အကုိ….
ခင္မင္စြာျဖင္႔….
ေဇာ္ရဲပိုင(္ ျမန္မာမိသားစု ဖိုရမ္)

Basic of Csharp

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Basic of Csharp

Uploaded by

Copyright:

Available Formats

1

အရင္ဆံုး C# ဆိုတာ ဘာလဲ စေျပာရေအာင္။ ကြၽန္ေတာ္သိတာကို ေျပာမွာေနာ္။

C# ဆိုတာ Microsoft က ထုတ္လိုက္တဲ႔ programming language တစ္ခုေပါ့။ C# ျဖစ္ေပၚလာရတဲ႔

ကဲ ဒါကေတာ့ C# language ေမြးဖြားလာပံုေပါ့ဗ်ာ။

CLR က ကြၽန္ေတာ္တို႔ .NET Platform မွာ ေရးတဲ႔ ဘယ္language codeကိုမဆို Microsoft

အရင္ဆံုးကြၽန္ေတာ္တို႔ Programတစ္ခုေရးလိုက္တယ္ဗ်ာ။ အဲ့ဒ ါကို source code လိ႔ု ေခၚတယ္။

ဆိုျပီး ရိုက္တယ္ဗ်ာ။ အဲ့ဒီကုဒ္ထဲမွာ ေရးလိုက္တဲ႔ printf ဆိုတဲ႔ဟာေလးကို function လိ႔ေ

ကဲ ဒီဇယားေလးကေတာ့ .NET Framework version history ပါဗ်ာ။

Version Release Visual Studio Default in Window

1.1 2003 Visual Studio .NET 2003 Window Server 2003

2.0 2005 Visual Studio 2005 -

3.0 2006 - Window Vista, Window Server 2008

4.0 Beta1 2009 Visual Studio 2010

Hello World from C#

ကဲ အခုကြၽန္ေတာ္တို႔ C# programming language နဲ႔ program တစ္ခုေလာက္

C# program ေတြ ေရးခ်င္တယ္ဆိုရင္ Microsoft Visual Studio(IDE) ကို သံုးျပီးေရးမွာလား။

ေရးျပီးျပီေနာ္… အိုေက ျပန္ရွင္းရေအာင္။ C တိ႔ု java တိ႔လ

နားလည္ေစခ်င္တာ။ ကဲ ကြၽန္ေတာ္တို႔ ေရးလို႔ ျပီးျပီဆိုေတာ့ ဒီ source code ေတြကို သိမ္းရမယ္။

ခဏေတာ့ ေစာင့္ရမယ့္ထင္တယ္။ ရွာလိုေတြ႔ျပီဆိုရင္ အဲ့ဒ ီ compiler ေလးရွိတဲ႔ ေနရာကို path

ခုလို compile လုပ္လုိက္ေတာ့ compiler က exe file ထုတ္ေပးတယ္ဗ်။ ရွာရင္ ရွာၾကည့္လိုက္ဦး။

ကဲ႔ ဒါဆိုရင္ ခင္ဗ်ားတို႔ရဲ့ ပထမဆံုး C# program ရဲ့ output ကို ေတြ႔ရျပီေပါ့။

ကြၽန္ေတာ္ video training ေလးပါ တင္ေပးလိုက္တယ္။ ဒီမွာ ယူဗ်ာ။

Compile လုပ္ရင္ program မွာမွားနိုင္တာေလးေတြလည္း ရွိတယ္ဗ်။

၁ – using, class, static, void အဲ့ဒါေတြကို စာလံုး အေသးနဲ႔ေရးရမယ္။

၂ – System, Console, Write, Main အဲ့ဒါေတြကိုေတာ့ အစစာလံုးကို အၾကီးနဲ႔ ေရးရမယ္။

၃ – write function အဆံုးမွာ ( ; ) ထည့္ရမယ္။

၄ – Hello World ဆိုတဲ႔ စာသားကို (“ နဲ႔ “) ထဲထည့္ေရးရမယ္။

ဒီေလာက္ဆို အားလံုး run လိ႔ု ရၾကမွာပါ။ စမ္းၾကည့္ျပီး တစ္ခုခုျပန္ေျပာၾကဗ်ာ။

အခု C# data type ေတြ အေၾကာင္း ဆက္ေျပာရေအာင္ဗ်ာ။ Data type ဆိုတာဘာလဲ။

ဒီလိုပါပဲ abc ဆိုတ႔ဲ စာသားကို သိမ္းဖို႔အတြက္ st ဆိုတ႔ဲ variable ကို ေၾကျငာလိုက္ပါတယ္။

value type ထဲမွာ integral type ေတြ၊

Type Range Size

int -2,147,483,648 to 2,147,483,647 Signed 32-bit

floating point typeေတြ၊

Type Approximate range Precision

Type Approximate Range Precision

reference type ထဲမွာေတာ့

variable declaration အပိုင္းမွာ ကြၽန္ေတာ္တို႔ သိဖို႔လိုတ ာတခုရွိတယ္ဗ်။ ကြၽန္ေတာ္တို႔ variable

ဆိုတာကေတာ့ဗ်ာ compiler က နားလည္ျပီးသား စကားလံုးေတြေပါ့။ သူတို႔ကို reserved words

abstract event new struct

ဒီဇယားထဲက keyword ေတာ္ေတာ္မ်ားမ်ားကို ကြၽန္ေတာ္တို႔ သိျပီးသားျဖစ္မွာပါ။

Data Type Conversation

Data Type ေတြနဲ႔ ပတ္သက္ျပီး ေနာက္ထပ္ သိထားစရာေလးေတြ ေျပာခ်င္ေ သးတယ္ဗ်။

3.0 or 3.0D => double

3.0F => float

3.0M => decimal

’3′ => char

“3″ => string

အေပၚမွာ ျပထားတာကိုၾကည့္မယ္ဆိုရင္ တကယ့္ value က 3 ျဖစ္ေပမယ့္ သူ႔ကို data type

ဆိုရင္ output က 34 ဆိုျပီး ျပေနလိမ့္မယ္ဗ်ာ။ ဆိုလိုတာကေတာ့ဗ်ာ 3 နဲ႔ 4 ကို number အေနနဲ႔

numeric type အခ်င္းခ်င္း ေျပာင္းမယ္ဆိုရင္ type conversation မွာ ၂ မ်ိဳးရွိပါတယ္။

int int_var1 = 123;

long long_var1 = int_var1; // implicit conversation (widening)

long long_var2 = (long) int_var1; // explicit conversation (widening)

int int_var2 = (int) long_var1; // explicit conversation (narrowing)

*** narrowing မွာ implicit မရွိပါဘူး ***

string type ကေနေျပာင္းခ်င္တယ္ဆိုရင္ေတာ့ အဲ့ဒီလို type casts လုပ္လ႔ို မရေတာ့ပါဘူး။ ဒါဆိုရင္

အခု ကြၽန္ေတာ္တို႔ program ေလးတခုေလာက္ ေရးၾကည့္ရေအာင္။ ကြၽန္ေတာ္က

အရင္ဆံုး C# မွာ Main function ကေန စေရးရမယ္ဆိုေတာ့…

static void Main()

ဟုတ္ျပီး ဒါဆိုရင္ integer တန္ဖိုးေတြ သိမ္းဖို႔အတြက္ ေနရာေလးရျပီး။ အခု user ကို

Console.Write(“Enter a number : “);

ဒါဆိုရင္ user က number တစ္ခုရိုက္ထည့္ေတ့မယ္။ အဲ့ဒီ number ကို လက္ခံဖို႔ အတြက္ C#

ဒါဆုိရင္ ကြၽန္ေတာ္တို႔ memory ေပၚမွာေၾကျငာထားတဲ႔ integer variable ထဲကို ဒီတိုင္းတန္းျပီး

* narrowing မွာ implicit မရွိပါဘူး *