basic of C# (part 24)

ကဲ ဒီေန႔ေတာ့ 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;
		}
	}
}

basic of SQL Statement (part 8)

ဒီေန႔ ကြၽန္ေတာ္တို႔ 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
1	Computer	Active	16
2	Stationary	Active	15
3	Electronic	Active	4
4	Clothes	Inactive	NULL
5	Kitchen wares	Inactive	NULL

အိုေက ဒီ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
1	Computer	Active	16
2	Stationary	Active	15
3	Electronic	Active	4
4	Clothes	Inactive	NULL
5	Kitchen wares	Inactive	NULL

ကဲ ေနာက္ထပ္ 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

basic of SQL Statement (part 7)

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

select * from category
where categoryid = 1 or categoryid = 3 or categoryid = 5

result:

CategoryID	CategoryName	Status
1	Computer	Active
2	Stationary	Active
3	Electronic	Active

categoryID အမ်ားၾကီး ကိုခုလိုမ်ိဳး စစ္မယ္ဆိုရင္ OR ကိုသံုးရတာ အဆင္မေျပေတာ့ပါဘူး။ ဒီအခါမွာ In keyword ကိုသံုးျပီး ခုလိုေရးလို႔ရပါတယ္…

select * from category
where categoryid in ( 1, 2, 3 )

result:

CategoryID	CategoryName	Status
1	Computer	Active
2	Stationary	Active
3	Electronic	Active

အခုကြၽန္ေတာ္က စုစုေပါင္း ကုန္လက္က်န္ ၅ခု ထက္မ်ားတဲ႔ category ေတြကို ထုတ္ျပခ်င္တယ္ဆိုရင္…

select * from category
where categoryid in (
	select categoryid from item
	group by categoryid
	having SUM(balance)>5
)

result:

CategoryID	CategoryName	Status
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 ေတြအေၾကာင္းကို ေနာက္မွ ဆက္ေျပာရေအာင္။

basic of SQL Statement (part 6)

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 ကို သံုးျပီး အခုလို ေရးရပါမယ္။

select item.*, category.categoryName
from item, category where item.categoryID = category.categoryID

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	-	Stationary
5	SONY 32” TV	3	900000	1	-	Electronic
6	Moon 16” Stand Fan	3	20000	3	-	Electronic

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

select item.*, category.categoryName
from item inner join category
on item.categoryID = category.categoryID

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	-	Stationary
5	SONY 32” TV	3	900000	1	-	Electronic
6	Moon 16” Stand Fan	3	20000	3	-	Electronic

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 နဲ႔ ေရးပါမယ္။

select item.*, category.categoryName
from item left join category
on item.categoryID = category.categoryID

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	-	Stationary
5	SONY 32” TV	3	900000	1	-	Electronic
6	Moon 16” Stand Fan	3	20000	3	-	Electronic

select item.*, category.categoryName
from item right join category
on item.categoryID = category.categoryID

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	-	Stationary
5	SONY 32” TV	3	900000	1	-	Electronic
6	Moon 16” Stand Fan	3	20000	3	-	Electronic
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 ေတြထြက္လာတာပါ။

basic of C# (part 23)

ဒီေန႔ ကြၽန္ေတာ္တို႔ 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();
        Console.Write("Enter a number : ");
        obj.Num = Console.ReadLine();
        Console.WriteLine("Square of {0} is {1}", obj.Num, obj.Square);
        Console.Read();
    }
}

ADO.NET in C# (part 3)

ကဲ ဒီေန႔ေတာ့ ကြၽန္ေတာ္တို႔ မေန႔က 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);
}

ADO.NET in C# (part 2)

ကဲ မေန႔က ကြၽန္ေတာ္တို႔ 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 အသြင္းအထုတ္လုပ္တာ နားလည္ျပီထင္ပါတယ္။

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 နဲ႔ ခ်ိတ္ပါ့မယ္။

basic of C# (part 22)

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();
        Console.WriteLine();
        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();
    }
}

basic of C# (part 21)

ဟိုေန႔က ကြၽန္ေတာ္တို႔ 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.WriteLine(Constant.DeveloperName);
        Console.WriteLine(Constant.DeveloperName);
        Console.Read();
    }
}

Program run လိုက္ရင္ “Sevenlamp” ဆိုတဲ႔ စာသားကို မရိုက္ျပခင္မွာ “print from static constructor” ဆိုတဲ႔ စာသားကိုအရင္ ရိုက္သြားတာ ေတြ႔ရမွာပါ။ ဒါေပမယ့္ တစ္ခုသိထားရမွာက static constructor က static member ေတြကို မေခၚခင္ ပထမဆံုး တစ္ၾကိမ္ပဲ အလုပ္လုပ္ပါတယ္။ ဒါေၾကာင့္ ကြၽန္ေတာ္က developername ကို ၂ ၾကိမ္ရိုက္ျပထားေပမယ့္  “print from static constructor” ကေတာ့ တစ္ၾကိမ္ပဲ ေပၚလာမွာျဖစ္ပါတယ္။ ကဲ ဒီေလာက္ဆို ကြၽန္ေတာ္တို႔ constructor ေတြ အေၾကာင္း နည္းနည္းနားလည္လာျပီ ထင္ပါတယ္။

ေနာက္ပိုဒ့္မွာ static member နဲ႔ instant member အေၾကာင္း ဆက္ေျပာပါ့မယ္။