virtual Intelligence: 2008

Wednesday, October 1, 2008

for … in Statement

ဒီ for.. in ကို javascript array ရဲ ့ element တစ္ခုခ်င္းစီကို ပတ္ခ်င္တဲ့ အခါမွာ သံုးပါတယ္။

ဥပမာ

<html>
<body>
<script type="text/javascript">

var x;
var mygreeting= new Array();

mygreeting[0] = "Hello";
mygreeting[1] = "World";
mygreeting[2] = "Greeting by Akela.";

for (x in mygreeting)
{
alert(mygreeting[x]);
}

</script>
</body>
</html>

အထက္ပါ ကုဒ္ေလးကို ခ်ခိုင္းတဲ့ အခါ ေအာက္ပါပံုအတိုင္း ၿမင္ရပါလိမ့္မယ္။

အာေကလာ

၂၇ စက္တင္ဘာ ၂၀၀၇

Thursday, September 18, 2008

Array တစ္ခု တည္ေဆာက္ၿခင္း

Javascript Array Object

Array တစ္ခုဆိုတာ variable တစ္ခုၿဖစ္ၿပီး တန္ဖိုးေတြ အမ်ားၾကီး သိမ္းဆည္းထားလို ့ ရပါတယ္။ javascript ရဲ ့ array ဟာ တၿခား programming ဘာသာရပ္ေတြ က array ေတြ လိုပါပဲ။
ေအာက္ပါအခ်က္မ်ားကို javascript မွာ array ကိုသံုးတဲ့ အခါ သိမွတ္ထားသင့္ပါတယ္။

၁။ ။ တန္းဖိုးေတြဟာ array တစ္ခုထဲကို သိမ္းဆည္းေတာ့မယ္ဆိုရင္ array နာမည္နဲ ့ ေနရာကို ေဖာ္ၿပၿပီး သိမ္းဆည္းႏုိင္ပါတယ္။ ဥပမာ - myFirstArray[2] = “Hello JS Array”;

၂။ ။ သိမ္းထားတဲ့ တန္းဖိုးေတြကို ၿပန္ၿပီးထုတ္ယူ သံုးစြဲၿခင္တဲ့ အခါမွာလည္း array နာမည္နဲ ့ ေနရာကို ေဖာ္ၿပၿပီး ၿပန္ထုတ္ႏိုင္ပါတယ္။ ဥပမာ - var varlue = myFirstArray[2]; (ဒါဆို ခုနက Hello JS Array ဆိုတဲ့ တန္ဖိုးကို ၿပန္ရပါမယ္။)

ေအာက္ပါ နည္းလမ္းနဲ ့ Array တစ္ခုကို တည္ေဆာက္လုိ ့ရပါတယ္။

 Var myFirstArray = new Array(3);

ဒါဆိုရင္ ကၽြန္ေတာ္တို႔ရဲ႕ myFirstArray ရဲ႕ length property ဟာ ၃ ျဖစ္သြားပါပီ။
myFirstArray ကို value ေတြထပ္ျဖည့္ရေအာင္.....


myFirstArray[0] = "This is first Item"; // Javascript ရဲ႕ Array က index 0 ကေနစတာပါ
myFirstArray[1] = new Object();
myFirstArray[2] = new Date();

ေနာက္တစ္မ်ိဳးစမ္းၾကည့္ရေအာင္


var myFirstArray = new Array();
myFirstArray.push("This is first Item");
myFirstArray.push(new Object());
myFirstArray.push(new Date());

Array ရဲ႕ push method ကိုသံုးရင္ Array object က Array ရဲ႕ length ကို auto increment လုပ္ေပးသြားပါတယ္။
အခုအခ်ိန္ myFirstArray.pop() ဆိုပီး Array object ရဲ႕ pop method ကိုေခၚလုိက္ရင္ myFirstArray ရဲ႕ length က ၁ ေလ်ာ့သြားပါပီ။
အဲဒီလိုပဲ myFirstArray ရဲ႕ အႀကီးဆံုး index က value (ဥပမာ ထဲက အတိုင္းဆိုရင္ new Date()) ကပ်က္သြားပါတယ္။
var lastVar = myFirstArray.pop() ဆိုရင္ myFirstArray ရဲ႕ ေနာက္ဆံုး index က value က lastVar ဆိုတဲ့ variable ထဲကိုေရာက္သြားပါမယ္။
myFirstArray ထဲကလည္း ပ်က္သြားပါပီ။ myFirstArray ရဲ႕ length property ကလည္း 2 ျဖစ္သြားပါမယ္။
(myFirstArray.length)

အာေကလာ၊ အဇူရီ
၁၄ စက္တင္ဘာ ၂၀၀၈

Fundamental concept of WCF (Microsoft Window Communication Foundation )

(ဒီပိုစ္ကို ၁၈ စက္တင္ဘာ ၂၀၀၇ အမွတ္တရ ဂုဏ္ၿပဳ ေရးပါသည္။)

အခုေနာက္ပုိင္း business solution အတြက္ software ေတြ ကိုေရးတဲ့အခါမွာ stand alone application ေတြ ေတာ္ေတာ္ရွားပါးသြားပါၿပီ။ distributed application ေတြပဲ ေရးလာၾကပါတယ္။ Microsoft ကလည္း .net framework 2.0 နဲ ့ ေနာက္ပိုင္းေတြမွာ ဒီအတြက္ အထူးတလည္ ၿပင္ဆင္ေပးခဲ့ပါတယ္။ စစခ်င္း .net remotnig ေနာက္ပိုင္းေတာ့ Window Communication Foundation (WCF) ဆိုၿပီးလုပ္လာပါတယ္။ အခုကၽြန္ေတာ္ ေရးမွာက WCF ရဲ ့အေၿခခံပါပဲ။ Fundamental Concepts ေတြပါ။ High-level View ပါပဲ။ ဒါေပမယ့္ ဒါေတြ သိထားမွ ဘယ္လို အလုပ္လုပ္လည္း ဆိုတာသိႏိုင္မွာၿဖစ္တယ္။ ဆက္ေလ့လာလို ့လြယ္ကူေစမွာၿဖစ္တဲ့ အတြက္ေၾကာင့္ပါ။ ၾကည့္ၾကစို ့ရဲ ့။

Windows Communication Foundation (WCF)

(၁) High-level Overview
(၁.၁) Messaging and Endpoints

WCF ဆိုတာ runtime တစ္ခု၊ ေနာက္ၿပီး services နဲ ့ clients ေတြၾကား messages ေတြ ပို ့တဲ့ စနစ္ (system) ေတြဖန္တီးဖို ့့ APIs ေတြစုစည္းထားတဲ့ ေနရာတစ္ခုပါ။ အဲဒါကို သံုးၿပီးေတာ့ တစ္ခုနဲ ့တစ္ခု ဆက္သြယ္လို ့ရတဲ့ application ေတြကို တည္ေဆာက္ယူလို ့ရပါတယ္။ အဲဒီ applications ေတြဟာ ကြန္ၿပဳတာတစ္လံုးထဲမွာလည္း ၿဖစ္ခ်င္ၿဖစ္မယ္၊ ဒါမွမဟုတ္ တၿခားတေနရာ၊ တၿခားႏိုင္ငံ၊ တၿခားကုမဏီတစ္ခု က ကြန္ၿပဳတာတစ္လံုးေပၚ မွာလည္းၿဖစ္ခ်င္ၿဖစ္မယ္။ ဒါေပမယ့္ WCF က services ေတြ၊ APIs ေတြ သံုးၿပီး ဆက္သြယ္လုပ္ရတယ္။ အတူတူ လုပ္ေဆာင္လို ့ရတယ္။

WCF ဟာ Messaging ေပၚမွာ အေၿခခံထားတဲ့ ေမာ္ဒယ္တစ္ခုပါပဲ။ အဲဒီထဲမွာ clients လို ့ေခၚတဲ့ ဆက္သြယ္မွဳ ့ (communication) ကို စမဲ့ application ေတြ၊ ေနာက္ services လို ့ေခၚတဲ့ clients ေတြ ဆက္သြယ္လာမွာကို ေစာင့္ဆိုင္းေနၿပီး တုန္ၿပန္ေပးမဲ့ application ေတြပါပါတယ္။ သတိၿပဳရမွာက application တစ္ခုတည္းက လည္း client ေရာ service ပါၿဖစ္ႏိုင္တယ္ဆိုတာပါပဲ။

Message ေတြဟာ endpoints ေတြၾကားမွာ ေပးပို ့ခံရပါတယ္။ endpoints ဆိုတာ message ေတြပို ့တဲ့ ေနရာ (send) ဒါမွမဟုတ္ လက္ခံတဲ့ေနရာ (receive) ပါ။ အဲဒီ endpoints ေတြကပဲ message ပို ့တဲ့၊ လက္ခံတဲ့ အခါမွာ လိုအပ္မဲ့ Information ေတြအားလံုးကို သတ္မွတ္ၿပဒါန္းေပးပါတယ္။ service တခုက တစ္ခု ဒါမွမဟုတ္ တစ္ခုထက္ပိုတဲ့ endpoints ေတြကို တည္ေဆာက္ေေပးထားတက္ပါတယ္။ client ေတြကေတာ့ services ေတြတည္ေဆာက္ေပးထားတဲ့ endpoint တစ္ခုခုနဲ့ ကိုက္ညီတဲ့ endpoint တစ္ခုကို တည္ေဆာက္ရပါတယ္။

Service တစ္ခုဟာ message ေတြကို ဘယ္လို ပို ့ရတယ္၊ ဘယ္လို ပံုစံရိွရမယ္၊ ဘယ္ကို ပို ့ရမယ္ဆိုတာေတြ၊ အၿခားလိုအပ္တဲ့ အရာေတြ အားလံုးကို metadata (data about data) အေနနဲ ့ေဖၚၿပထားတယ္။ အဲဒီအခါ client က အဲဒီ metadata ေတြ သံုးၿပီး သင့္ေတာ္တဲ့ WCF client နဲ ့ Communication stack ေတြကို တည္ေဆာက္ပါတယ္။

(WCF client, Communication stack ေတြ ဘာလဲဆိုတာ နားမလည္ရင္လည္းဆက္ဖတ္ပါ ေအာက္မွာ အကုန္ၿပန္ပါပါတယ္။)

(၁.၂) Communication Protocols

WCF ရဲ ့အဓိကအခ်က္က ေနရာမေရြး (ေနရာမ်ိဳးစံုက client ေတြက) service ေတြကို ဆက္သြယ္ႏိုင္တာဆိုေတာ့၊ network လိုလာပါတယ္။ အဲဒီ network ေပၚမွာ သံုးမဲ့ protocols ေတြဟာလည္း လိုအပ္လာပါတယ္။ ဒါေၾကာင့္
Communication stacks ေတြရဲ ့ လိုအပ္ခ်က္ တစ္ခုကေတာ့ transport protocol ေတြပါပဲ။ Messages ေတြကို ကၽြန္ေတာ္တို ့က intranets, Internet ေပၚကေန HTTP, TCP လို common transport protocol ေတြ သံုးၿပီး ေေနရာမ်ိဳးစံုကေန ေပးပို ့ ဆက္သြယ္ႏိုင္ပါတယ္။ ေနာက္ထပ္ transport ေတြကေတာ့ Microsoft Message Queuing (MSMQ) တုိ ့၊ Peer Networking mesh တို ့ပါပဲ။ တၿခား transport mechanisms ေတြကိုလည္း WCF ရဲ ့ ပါၿပီးသား (build-in) extension points ေတြသံုးၿပီး ထပ္ထည့္ႏိုင္ပါတယ္။

(၁.၃) Message Patterns

WCF မွာ အမ်ိုးမ်ိဳးေသာ message patterns ေတြကို သံုးႏိုင္ပါတယ္။ request-reply၊ one-way၊ duplex communication စသည္ၿဖင့္အသံုးၿပဳႏိုင္ပါတယ္။ ကြဲၿပားတဲ့ transports ေတြက ကြဲၿပားတဲ့ message patterns ေတြကို သံုးပါတယ္။ WCF APIs နဲ ့ runtime ေတြက message ေတြရဲ ့လံုၿခံဳမွဳကိုလည္းလုပ္ေပးပါတယ္။

(၂) WCF Terms

(၁) message
Message ဆိုတာ data ေတြပါ၀င္ဖြဲ ့စည္းထားတဲ့ အစုတခု။ သူမွာ body ၊ header စတာေတြအပါအ၀င္ တၿခားအစိတ္အပိုင္း ေတြလည္းပါ၀င္တယ္။

(၂) service
Service ဆိုတာကေတာ့ endpoint တစ္ခု ဒါမွမဟုတ္ တစ္ခုထက္ပိုၿပီး တည္ေဆာက္ေပး ထားတဲ့ ေနရာပါပဲ။ အဲဒီ endpoint တစ္ခုစီဟာ service operation တခု ဒါမွမဟုတ္ တစ္ခုထက္ပို ၿပီးရိွတက္တယ္။

(၃) endpoint
Endpoint ဆိုတာ message ေတြ ပို ့ရမဲ့၊ လက္ခံတဲ့ ေနရာတခုပါပဲ။ တခ်ိဳ ့ endpoint ေတြ
ကလက္ခံတဲ့ ဒါမွမဟုတ္ ပို ့တဲ့ အလုပ္တမ်ိဳးကိုပဲလုပ္ၿပီး ၊တခ်ိုဳ ့ကေတာ့ ႏွစ္မ်ိဳး လံုးကိုလုပ္ပါတယ္။ endpoint ေတြူက message ေတြ ပို ့ဖို ့အတြက္ လိပ္စာ (address) တစ္ခု ထုတ္ေပးတားတယ္။ ေနာက္ ဘယ္လိုနည္းနဲ ့ဆက္သြယ္လို ့ရတယ္ (communication mechanism) ဆိုတဲ့ အေၾကာင္းအရာ သတ္မွတ္ခ်က္ေတြ (specification) ကိုလည္း ထုပ္ေပးထားတယ္္။ ေနာက္ဆံုး ဘယ္လို message ေတြပို ့လို ့ ရတယ္ဆိုတာေတြပါ ေဖာ္ၿပေပးထားပါတယ္။ WCF service တစ္ခုဆိုတာဟာ endpoint ေတြ စုစည္းထားတဲ့ ေနရာတစ္ခုပါပဲ။ (is a world as a collection of service.)

(၄) address
Address တခုဟာ message ေတြကို ဘယ္မွာလက္ခံမယ္ဆိုတဲ့ ေနရာတခုကို ေၿပာၿပေပးပါတယ္။ သူကို Uniform Resource Identifier (URI) အေနနဲ ့သတ္မွတ္ေလ့ရိွတယ္။ ဒါေၾကာင့္ endpoint address ေတြဟာ ထပ္တူမရိွတဲ့ address (Unique Address) ေတြပါ။

(၅) binding
endpoint တခုဟာ ၿပင္ပ နဲ ့ဘယ္လို ဆက္သြယ္လုပ္ေဆာင္မလဲဆိုတာကို binding ကသတ္မွတ္ေပးပါတယ္။ Communication Infrastructure ၿဖစ္လာဖို ့အတြက္ binding element ေတြလို ့ေခၚဆိုတဲ့ components အစုေလးေတြ တခုေပၚတခု (stack on top of the other) တည္ေဆာက္ထားတယ္။ အႏိွမ့္ဆံုးအေနနဲ ့ binding က ဘယ္လို transports ေတြသံုးမယ္( HTTP , TCP/IP) ၊ ဘယ္လုိ encoding ေတြသံုးမယ္ (text or binary) စတာေတြကို သတ္မွတ္ေပးပါတယ္။ security နဲ ့ဆိုင္တဲ့ ကိစၥေတြ၊ endpoint ကသံုးမယ့္ message pattern ေတြကိုလည္း သတ္မွတ္ေပးပါတယ္။

(၆) binding element
Binding element တခုဟာ binding လုပ္ခ်င္းကိစၥရဲ ့အစိတ္အပိုင္းတခုကို ကိုယ္စားၿပဳပါတယ္။ transport တခု၊ encoding တခု စသည္အားၿဖင့္။ ဒါမွမဟုတ္ communication stack ေပၚမွာ ရိွတဲ့ ဘယ္ component မဆို binding element ေတြပါပဲ။

(၇) behaviors
Behavior ဆိုတာ client တခု၊ operation တခု၊ ဒါမွမဟုတ္ endpoint တခု၊ service တခု ကို run-time မွာ ဘယ္လို လုပ္သလဲဆိုတာကို ထိန္းတဲ့ component တခုပါပဲ။ behavior ေတြကို သူတို ့ရဲ ့ scope ေပၚမူတည္ၿပီး အဖြဲ ့ေလးေတြ ဖြဲ ့ထားပါတယ္။ common behaviors လို ့ဆိုရင္ endpoint အားလံုးနဲ ့ဆိုင္ပါတယ္။ globally ေပါ့။ service behavior ဆိုရင္ service နဲ ့ ဆက္ႏြယ္ေနတဲ့ကိစၥ ေတြနဲ ့ဆိုင္ပါတယ္။ endpoint behavior လို ့ဆိုရင္ endpoint နဲ ့ဆက္ႏြယ္ေနတဲ့ အသံုးၿပဳမွဳ ေတြနဲ ့ ဆိုင္ပါတယ္။ operation-level behaviors ဆိုရင္ေတာ့ operation တစ္ခုခ်င္းစီနဲ ့ သက္ဆိုင္ပါတယ္။ ဥပမာ- endpoint behaviors ဆိုပါစို ့။ သူက endpoint နဲ ့ပဲဆိုင္တဲ့ အရာေတြကို ၿပဥာန္းေပးပါတယ္။ security credential ကိုဘယ္မွ သြားရွာရမလဲဆိုတာမ်ိဳးေပါ့။

(၈) configuration နဲ ့ coding
Application တခုကို ထိန္းခ်ဳပ္တဲ့ ကိစၥမွာ coding ကေနတဆင့္ ၊ ဒါမွမဟုတ္ configuration file ကေနတဆင့္ ၊ (၀ါ) ႏွစ္ခုလံုး ကို သံုးၿပီး လုပ္ႏိုင္ပါတယ္။ configuration ကေန လုပ္တာက programmer (developer) မဟုတ္တဲ့ သူေတြကိုပါ client (၀ါ) service မွာ လိုတဲ့ အရာေတြကို coding ေရးၿပီးေပ့မယ့္ ၿပဳၿပင္ခြင့္၊ ထိန္းခ်ဳပ္ခြင့့္ ေပးတဲ့ အားသာခ်က္ရိွပါတယ္။ အဲဒီလုိလုပ္တဲ့ ကိစၥမွာ program coding ကို ၿပန္ၿပီး recompile လုပ္စရာမလိုပဲ သံုးလို ့ရပါတယ္။ coding ကေတာ့ programmer (developer) ေတြကို client (၀ါ) service ေတြ အေပၚမွာ တိက်တင္းက်ပ္တဲ့ ထိန္းခ်ဳပ္မွဳေတြ လုပ္ဖို ့ ခြင့္ၿပဳပါတယ္။ configuration ဖိုင္ကေန စီစဥ္ထိန္းခ်ဳပ္ထားတဲ့ ဘယ္အရာကိုမဆို လိုအပ္တယ္ဆိုရင္ coding ကေန ေၿပာင္းလဲ ႏိုင္ပါတယ္။

(၉) service operation
Service operation တခုက service တခု လုပ္ေဆာင္မဲ့ ကိစၥတခု (operation) ကို service code ေတြကတဆင့္ သတ္မွတ္ထားတဲ့ ဟာကို ေၿပာတာပါ။ ဒီ service တခုကလုပ္ေဆာင္ေပးမဲ့ အရာေတြကို WCF Client ေတြဆီ method ေတြအေနနဲ ့ ထုတ္ေပးထားတယ္။ အဲဒီ method ေတြက တန္ဖိုး တခုကို ၿပန္ရင္ ၿပန္မယ္။ သူဆီကို arguments ေတြ လက္ခံရင္ လက္ခံမယ္။ ဒါမွမဟုတ္ ဘာတန္ဖိုးမွ မၿပန္တာ၊ ဘာ argument မွ လက္မခံတာ။ ဒီလိုလည္းၿဖစ္ႏိုင္ပါတယ္။

(၁၀) service contract
Service contract ဆိုတာကေတာ့ ခုနက service operation ေတြကို စုစည္းေပးထားတဲ့ အစုတစ္ခုပါပဲ။ Contract တခုကို အမ်ိဳးမ်ိဳးေသာ အဆင့္ေတြ သတ္မွတ္လို ့ရတယ္။ ဥပမာ- namespace အဆင့္မွာ သတ္မွတ္တဲ့ contract။ အမ်ားဆံုးလုပ္ေလ့ရိွတာကေတာ့ ကိုယ္ၾကိဳက္တဲ့ program ဘာသာရပ္ (C#, VB, J#) နဲ ့ interface တခုေဆာက္ၿပီး အဲဒီမွာ ServiceContractAttribute ဆိုတဲ့ attribute ကို ေၾကညာေပးလိုက္တာပဲ။ တကယ္ အလုပ္လုပ္မဲ့ service code ေတြက အဲဒီ interface ကို အေမြဆက္ခံ (inherit) လိုက္တာပါပဲ။

(၁၁) operation contract
operation contract ဆိုတာကေတာ့ operation တစ္ခုဆီကို ပို ့ေပးရမယ့္ parameters ေတြ၊ ဒါမွမဟုတ္ အဲဒီ operation ကေန ၿပန္မဲ့ အမ်ိဳးအစားေတြ ကို သတ္မွတ္ေပးပါတယ္။ ကၽြန္ေတာ္တို ့ service contract နဲ ့ တည္ေဆာက္ထားတဲ့ (အေပၚကအဆင့္) interface တစ္ခုမွာ operation contract ကို OperationContractAttribute ဆိုတဲ့ attribute ေလးကို method ရဲ ့ အေပၚမွာ ထည့္ေပးလိုက္ရံုနဲ ့ တည္ေဆာက္ႏိုင္ပါတယ္။ အဲဒါဆို အဲဒီ method ေလး (WCF အေနနဲ ့ဆို operation ေလးဟာ) ဟာ operation contract နဲ ့ ၿဖစ္သြားပါၿပီ။

(၁၂) message contract
message contract ဆိုတာက ကၽြန္ေတာ္တို ့အသံုးၿပဳမဲ့ မက္ေဆ့ (message) ရဲ ့ ပံုစံ (format) ပါပဲ။ ဥပမာ - မက္ေဆ့ (message) ေတြဟာ headers ထဲမွာ ရိွရမလား။ ဒါမွမဟုတ္ body ထဲမွာပဲ ရိွရမလား။ မက္ေဆ့ ေတြအတြက္ ဘယ္လို လံုၿခံဳေရး နည္းလမ္း (security) ေတြ အသံုးၿပဳမလဲ စတာေတြကို သတ္မွတ္ေပးတဲ့ contract ပါ။

(၁၃) fault contract
fault contract ေတြဟာ service တစ္ခုမွာ အမွား (error) ေတြၿဖစ္လာတဲ့ အခါ ေခၚတဲ့သူဆီ၊ service ကို သံုးတဲ့သူဆီကို အဲဒီ အမွား ေတြ ပို ့ေဆာင္ေပးႏိုင္ေအာင္လို ့ service operation နဲ ့ ေပါင္းစပ္ထားႏုိင္ပါတယ္။ Operation တစ္ခုမွာ အမွား ေတြ မရိွတာလည္းၿဖစ္ႏိုင္သလို ့ အမ်ားၾကီးရိွေနတာလည္း ၿဖစ္နိုင္ပါတယ္။ ဒီ အမွားေတြ ကို SOAP (Simple Object Application Protocols) ရဲ ့ အမွားေတြၿဖစ္ၿပီး programming မွာေတာ့ Exception ေတြ အေနနဲ ့ ကိုင္တြယ္ပါတယ္။

(၁၄) data contract
Service တစ္ခုက အသံုးၿပဳမဲ့ ေဒတာ အမ်ိဳးအစား (data types) ေတြကို ေဒတာ၂ (metadata – data about data) ေတြမွာ ေၾကညာေပးရပါတယ္။ ဒါမွ service ကို အသံုးၿပဳမဲ့ အရာေတြက ဆက္သြယ္အသံုး ၿပဳႏိုင္မွာၿဖစ္တယ္။ အဲဒီ လို ေဒတာ အမ်ိဳးအစားေတြကို ေဖာ္ၿပေပးတာကို data contract လို ့ေခၚပါတယ္။ အဲဒီ ေဒတာအမ်ိဳးအစားေတြကို မက္ေဆ့ ရဲ ့ အစိတ္အပိုင္းတစ္ခုအေနနဲ ့ ထည့္ေပးႏိုင္ပါတယ။္ ဥပမာ - parameter အေနနဲ ့ ဒါမွမဟုတ္ return type အေနနဲ ့။ တကယ္လို ့ service က ရိုးရွင္းတဲ့ ေဒတာ အမ်ိဳးအစား (int, string,lone စသည္) ကို ပဲ အသံုးၿပဳမယ္ဆိုရင္ေတာ့ data contract ကို အထူးတလည္ ေၾကညာေပးစရာမလိုပါဘူး။

(၁၅) hosting
Service တစ္ခုဟာ process တစ္ခုေပၚမွာ လုပ္ေဆာင္ရပါတယ္။ အခံ process မရိွပဲ မရပါဘူး။ host တစ္ခုဆိုတာ application တစ္ခုၿဖစ္ၿပီး သူက service ရဲ ့ သက္တမ္း (lifetime) ကို သတ္မွတ္ ၿပဥာန္းေပးပါတယ္။ Service ေတြဟာ ကိုယ့္ကိုယ္ အခံ (host) လုပ္ထားတာလဲ ၿဖစ္ႏိုင္ပါတယ္။ ဒါမွမဟုတ္ အၿခား process တစ္ခုကို အခံ (host) လုပ္တာလည္းၿဖစ္ႏိုင္ပါတယ္။

(၁၆) self-hosted service
Self-hosted service ဆိုတာ developer တစ္ေယာက္က တည္ေဆာက္ထားတဲ့ process တစ္ခု ထဲမွာ လုပ္ေဆာင္ (run) ေနတဲ့ service ကို ေခၚတာၿဖစ္တယ္။ developer က အဲဒီ service ရဲ ့ သက္တမ္းကို ထိန္းခ်ဳပ္ထားတယ္၊ service ရဲ ့ properties ေတြကို ကိုင္တြယ္တယ္၊ service ကို ဖြင့္တယ္ ( service ဆီ ကို client က အ၀င္ message လာတာကိုေစာင့္ၿခင္း) ၊ ၿပီးေတာ့ service ကို ပိတ္တယ္။

(၁၇) hosting process
Hosting process ဆိုတာကေတာ့ application တစ္ခုၿဖစ္ၿပီး သူရဲ ့ ရည္ရြယ္ခ်က္က service တစ္ခုအတြက္ အခံ (host) လုပ္ေပးဖို ့ပါပဲ။ ဘာေတြပါလည္းဆိုေတာ့ - Internet Information Service (IIS), Window Activation Service (WAS), Windows Services ေတြပါပဲ။ ဒီနည္းလမ္းမွာ အခံ (host) ေတြက service ရဲ ့သက္တမ္းကို ထိန္းခ်ဳပ္ပါတယ္။ ဥပမာ - IIS ကိုသံုးၿပီး service assemblyနဲ ့ configuration file ပါတဲ့ virtual directory တစ္ခု တည္ေဆာက္ႏိုင္တယ္။ ၿပီးေတာ့ message ေတြ ေရာက္လာတဲ့ အခါ၊ IIS က service ကို စတင္ၿပီး သူရဲ ့ သက္တမ္းကို ထိန္းခ်ဳပ္ပါတယ္။

(၁၈) instancing
Service တစ္ခုမွာ instancing model တစ္ခုရိွပါတယ္။ instancing model ၃မ်ိဳးရိွတယ္။ single - ဒီမွာ single CLR (Common Language Runtime) object တစ္ခုကပဲ client အားလံုးကို လက္ခံ လုပ္ေဆာင္ေပးပါတယ္။ per call – ဒီမွာ CLR object အသစ္တစ္ခုကို client တစ္ခုဆီကို လက္ခံလုပ္ေဆာင္ဖို ့ အတြက္ ဖန္တီးေပးပါတယ္။ per session - ဒီမွာေတာ့ CLR object အစု တစ္စု ကို သီၿခား session တစ္ခုစီ အတြက္ ဖန္တီးေပးပါတယ္။ ဘယ္ ပံုစံကို သံုးမလဲဆိုတာကေတာ့ service ရဲ ့ အမ်ိဳးအစား အသံုးၿပဳမဲ့အေနအထားေပၚမူတည္ပါတယ္။

(၁၉) client application
Client application တစ္ခုဟာ program တစ္ခုၿဖစ္ၿပီး သူက မက္ေဆ့ (message) ေတြကို endpoints တစ္ခုကေန တစ္ခုကို ပို ့ေပး လက္ခံ ေပးတာကို လုပ္တယ္။ ဒီ client application ေတြဟာ WCF client instance တစ္ခုကို တည္္ေဆာက္ၿပီး WCF client method ကို ေခၚၿပီး အသံုးၿပဳတဲ့ အခါမွာ စတင္ၿဖစ္တည္ပါတယ္။ အေရးၾကီးတာ တစ္ခုကို သတိၿပဳရမွာက application တစ္ခုတည္းကပဲ client ေရာ service ေရာ ၿဖစ္ႏိုင္တယ္ဆုိတာပါ။

(၂၀) WCF client
WCF client ဆိုတာ service operation ေတြကို methods ေတြအၿဖစ္ တင္ၿပေပးတဲ့ client-application တစ္ခုပါပဲ။ ဘယ္ application ေတြမဆို service ကို အခံ (host) လုပ္ေပးတဲ့ ဟာ အပါအ၀င္ WCF client ေတြကို အခံ (host) အၿဖစ္လုပ္္ေပးႏိုင္ပါတယ္။ ဒါေၾကာင့္ service တစ္ခုဟာ အၿခား service တစ္ခုရဲ ့ WCF Client ေတြပါရိွႏိုင္ပါတယ္။
WCF client ကို ServiceModel Metadata Utility Tool (Svcutil.exe) ကို သံုးၿပီး အလိုအေလၽႊွ်ာက္ ထုတ္ယူႏိုင္ပါတယ္။
.
(၂၁) metadata
Service တစ္ခုရဲ ့ metadata ေတြက အဲဒီ service ရဲ ့ အခ်က္အလက္ေတြကို ေဖာ္ၿပေပးပါတယ္။ အဲဒီ အခ်က္အလက္ေတြကို သံုးၿပီးမွာ အၿပင္က client ေတြက service ကို ဆက္သြယ္လုပ္ေဆာင္ႏိုင္မွာ ၿဖစ္တယ္။ အဲဒီ metadata ကိုေတြကို ရယူအသံုးၿပဳၿပီး serviceModel Metadata Utility Tool (svcutil.exe) က WCF client ေတြနဲ ့ လိုအပ္တဲ့ configuration file ေတြကို service နဲ ့ ဆက္သြယ္လုပ္ကိုင္ဖို ့ ထုတ္ေပးႏိုင္တာၿဖစ္တယ္။ service တစ္ခုအတြက္ metadata က ထုတ္ေပးတဲ့ ေဒတာက XML Schema documents ရယ္၊ WSDL document တို ့ ၿဖစ္တယ္။

(၂၂) Security
WCF ရဲ ့ Secuity ဆိုတာ confidentiality ရိွၿခင္း၊ (မက္ေဆ့ ေတြကို ပံုဖ်တ္ (encryption) လုပ္ၿခင္း)၊ integrity ရိွၿခင္း၊ (မက္ေဆ့ေတြ ပ်က္ဆီးတာမ်ိဳးကို နားလည္ၿခင္း)၊ authentication (serviers နဲ ့ clients တို ့မွာ ၀င္ႏိုင္ခြင့္ ရိွၿခင္း)၊ authorization (အရင္းအၿမစ္ (resource) ေတြကို သံုးခြင့္ ရိွၿခင္း) စတာေတြကို ေၿပာတာၿဖစ္တယ္။ ဒီ လို လုပ္ေဆာင္ခ်က္ေတြကို လက္ရိွ ရိွၿပီးသား လံုးၿခံဳေရး (security) ေတြၿဖစ္တဲ့ TLS ၊ HTTP (HTTPS)၊ တို ့ကေနလုပ္ေဆာင္ႏိုင္သလို၊ အသစ္ၿဖစ္တဲ့ WS-* ရဲ ့ လံဳၿခံဳးေရး စံညြန္းသတ္မွတ္ခ်က္ (security specification) ကေနလည္းလုပ္ေဆာင္ႏိုင္ပါတယ္။

WS-*

ဒါကေတာ့ Web Service (WS) ရဲ ့ စံညြန္းသတ္မွတ္ခ်က္ေတြကို ညြန္းပါတယ္။ WS-Security WS-ReliableMessaging စသည္ၿဖင့္ WCF မွာ သံုးရမဲ့ သတ္မွတ္ခ်က္ေတြပါ။

ဒါေလးကေတာ့ မိတ္ဆက္ သေဘာပါပဲ။
အခ်ိ္န္ရရင္ ဆက္ၿပီးေရးပါမယ္။
ဆက္ၿပီး ေလ့လာႏိုင္ၾကပါေစဗ်ာ။

ရည္ညြန္း။ ။ MSDN

အာေကလာ
၁၈ စက္တင္ဘာ ၂၀၀၈

Saturday, September 13, 2008

Javascript toLocaleString() Method

အဓိပၸါယ္ဖြင့္ဆိုခ်က္

toLocaleString method ေလးက Date object တခုကို လက္ရိွ စက္ရဲ ့ အခ်ိန္ ေပၚမူတည္ၿပီး String အၿဖစ္ ၿပန္ေပးပါတယ္။

အသံုးၿပဳပံု

ေအာက္က နမူနာမွာ (စက္ထဲမွာရိွေနတဲ့) လက္ရိွ ဒီေန ့အခ်ိန္ကို stirng အၿဖစ္ ၿပန္ထုတ္ရိုက္ၿပပါလိမ္မယ္။


<script type="text/javascript">
 var todayDateObj = new Date();// var dobDateObj = new Date('Feb 23, 1983');
 var todayDateStr = todayDateObj.toLocaleString();// var dobStr = dobDateObj.toLocaleString();
 document.write(todayDateStr);//document.write(dobStr);
 alert(todayDateStr);//alert(dobStr);
</script>

ေအာက္မွာ ၿပထားသလိုမ်ိဳး (သံုးေနတဲ့ စက္ရဲ ့ ပံုစံခ်ပံု (setting) ေပၚမူတည္ပါတယ္။) ဘေရာက္ဇာ ကေနၾကည့္ရင္ ၿမင္ရပါလိမ့္မယ္။

ရည္ညြန္း။ ။ w3school

အာေကလာ။

Wednesday, August 27, 2008

XML Schemas
(XML သဒၵါ (၀ါ) XML အဓိပၸါယ္ သတ္မွတ္မွဳ) - အပိုင္း ( ၅ )

အပိုင္း ( ၁ ) ၊ ( ၂ ) ၊ (၄) ႏွင့္ ( ၅) ကို အရင္ဖတ္ၾကည့္ေစခ်င္ပါသည္။

Content model ေတြဖန္တီးဖို ့အတြက္ <simpleType> element ကိုအသံုးၿပဳပါတယ္။ ဒါေပမယ့္ အဲဒီ content model ေတြဟာ simple content ၿဖစ္ေနဆဲပါပဲ။ simple content ဆိုတာ data ပဲပါၿပီး child elements ဒါမွမဟုတ္ mixed contents ေတြ မပါတဲ့ ဟာပါ။ simple content ၿဖစ္ေနဆဲေပမယ့္ <simpleType> က ၿပဳလြယ္ၿပင္လြယ္၊ ေၿပာင္းလဲလြယ္တဲ့ အဆင့္တစ္ခုကို ၿဖစ္ေစပါတယ္။ (a level of flexibility) လက္ရိွ ရိွေနတဲ့ ေဒတာ အမ်ိဳးအစား ေတြမွာ ကန္ ့သတ္ခ်က္ေတြ ၿပဳလုပ္ႏိုင္တာမ်ိဳးေပါ့။

ဘာေၾကာင့္ အဲဒီ ကန္ ့သတ္ခ်က္ေတြက အသံုး၀င္ရတာလဲလို ့ ေမးခဲ့ရင္ ဒါေလးကို ေတြးၾကည့္ၾကမယ္။ ကၽြန္ေတာ္တို ့ပစၥည္း တစ္ခုအတြက္ ကုန္စရင္း (inventory) ကို element တစ္ခုေၾကညာၾကမယ္။ ဒီေတာ့ <inventory> ဆိုတဲ့ element ေလးကို ကၽြန္ေတာ္တုိ ့ ဖန္တီးမယ္ေပါ့။ ဒါေပမယ့္ ကၽြန္ေတာ္တို ့ ၾကိဳသိေနတယ္။ ဒီ ပစၥည္း ဟာ အခု ၂၀၀ ထက္ပိုၿပီး သိုေလွာင္ရံုထဲမွာမရိွႏိုင္ဘူးဆိုပါစို ့။ လံုး၀မရိွတာက်ေတာ့ ၿဖစ္ႏိုင္တယ္။ ဒီလို ကန္ ့သတ္ခ်က္ေလးေတြ ပါလာၿပီဆိုရင္၊ ေနာက္ၿပီး ဒီလုိ ဟာေလးေတြက မၾကာခဏ သံုးရေတာ့မယ္၊ ထပ္ခါထပ္ခါသံုးရေတာ့မယ္ဆိုရင္ ကၽြန္ေတာ္တို ့ဟာ <simpleType> ကို သံုးၿပီး XML သဒၵါ (Schema) ကုိေၾကညာသင့္ၿပီေပါ့။ ေအာက္မွာၾကည့္မယ္။

<xs:element name="inventory">
<xs:simpleType>
<xs:restriction base="xs:integer">
 <xs:minInclusive value="0"/>
 <xs:maxInclusive value="200"/>
</xs:restriction>
</xs:simpleType>
</xs:element>

အဲဒီ ေၾကညာခ်က္ေလးက <inventory> လို ့ေခၚတဲ့ element တစ္ခုကို ၿဖစ္ေစတယ္။ သူမွာ တန္ဖိုး (value) က 0 ကေန ၂၀၀ အထိအၿမင့္ဆံုးပါႏိုင္ပါတယ္။
(တခု သတိၿပဳပါ။ ကၽြန္ေတာ္တို ့သံုးတဲ့ ေဒတာအမ်ိဳးအစားဟာ XML မွာ ရိွၿပီးသား ေဒတာအမ်ိုးအစား ဆိုတာပါပဲ။ interger အမ်ိဳးအစားေပါ့။ ဒါကို ကၽြန္ေတာ္တို ့က restriction ဆိုတာနဲ ့ကန္ ့သတ္ရံုပဲ ကန္ ့ သတ္လိုက္တာပါ။)

ဒီလိုေၾကညာခဲ့တဲ့ အတြက္ တကယ္လို ့ XML Document ဖိုင္ထဲမွာ ဒီလို တက္(tag) ကေလးေတြပါလာရင္ အိုေကၿပီး

<inventory>190</inventory>
<inventory>0</inventory>
<inventory>49</inventory>

ဒီလိုေလးေတြေတာ့ ပါလို ့မရဘူးေပါ့။

<inventory>201</inventory>
<inventory>250</inventory>

<simpleType> element ကို ေၾကညာတဲ့ အခါေတြမွာ restriction ရယ္၊ list ရယ္၊ union ရယ္ပဲ ပါလို ့ ရပါတယ္။

ထပ္သိထားရမွာက <simpleType> element မွာ id နဲ ့ name ဆိုတဲ့ စြမ္းရည္ၿပစကားလံုး (attributes) ေလးေတြပါလို ့ရတယ္။ ဒီလို simple type တစ္ခုကို name သတ္မွတ္ေပးလို ့ရတဲ့ အတြက္ အက်ိဳးေက်းဇူးကေတာ့ ကၽြန္ေတာ္တို ့ဟာ အၿခား element ေတြေၾကညာတဲ့ အခါမွာ အဲဒီ type ကို အဲဒီ name ကိုအသံုးၿပဳ ၿပီး ၿပန္ေခၚသံုးလို ့ ရၿခင္းပါပဲ။ ထပ္ခါထပ္ခါ အသံုးၿပဳႏိုင္ၿခင္း ( reusable) ၿဖစ္တာေပါ့။

<xs:simpleType name="currency">
<xs:restriction base="xs:decimal">
<xs:fractionDigits value="2"/>
</xs:restriction>
</xs:simpleType>

<xs:element name="price" type="currency"/>

အေပၚက နမူနာမွာ ကၽြန္ေတာ္တို ့ဟာ price လို ့ေခၚတဲ့ element တခုရိွတယ္။ အဲဒီ price ဟာ decimal အမ်ိဳးအစားၿဖစ္ၿပီး ေတာ့ ဒသမဂဏန္း ၂ လံုးပဲ ပါလို ့ရမယ္။

ဒီေတာ့ ကၽြန္ေတာ္တို ့ဟာ decimal ကို base ေဒတာအမ်ိဳးအစားအေနနဲ ့ယူလိုက္ၿပီး သူ ရဲ ့ဒသမဂဏန္းကို xs:fractionDigits တက္(tag)က တန္းဖိုး 2 ဆိုၿပီး ေၿပာင္းလိုက္တယ္။ တကယ္ decimal ေဒတာအမ်ိဳးအစားဟာ ဒသမ ၂ လံုးပဲ ပါတာမဟုတ္ဘူး။ ဒါေၾကာင့္ ကၽြန္ေတာ္တုိ ့က ဒီလို ေၿပာင္းၿပီးေတာ့ မွ ကၽြန္ေတာ္တို ့ေၿပာင္းထားတဲ့ အမ်ိုးအစား (type) ကို currency လို ့ simpleType ရဲ ့ name မွာ ေၾကညာလိုက္တယ္။ ဒသမဂဏန္း ၂ လံုးနဲ ့ဟာကို currency လို ့ နာမည္ေပးလိုက္တယ္ေပါ့ဗ်ာ။

ၿပီးေတာ့ XML Document ထဲမွာ အဲဒီ နာမည္ကို ယူၿပီး ဒီလို သံုးလိုက္လို ့ရပါၿပီ။

<xs:element name="price" type="currency"/>

တကယ္လို ့ အၿခား element တခု ၊ ဥပမာ- totalAmount ဆိုတဲ့ element ကလည္း price လိုပဲ ဒသမဂဏန္း ၂ လံုးဆိုရင္-

<xs:element name=”totalAmount” type="currency"/>

paymentAmount ကလည္း ဒသမ ၂ လံုးပဲ ဆိုပါစို ့။

<xs:element name=”paymentAmount” type="currency"/>

ဆိုၿပီး သံုးလိုရပါတယ္။ ေတြ ့လား။ currency ဆိုတဲ့ ေဒတာအမ်ိဳးအစားကို ပဲ ေခၚသံုးထားတယ္။ တခါတည္း simpletype အေနနဲ ့ ေၾကညာၿပီး ထပ္ေၾကညာစရာမလို ေတာ့ဘူး။ မဟုတ္ရင္ element အသစ္တစ္ခု ဖန္တီးတိုင္း ဒသမ ၂ လံုးဆိုတာကို ေၾကညာေနရမွာ။ အခု မလိုေတာ့ဘူး။ currency ဆိုတဲ့ name ကို ေခၚသံုးရံုပဲ။ ဒါကို ထပ္ခါထပ္ခါ အသံုးၿပဳႏိုင္ၿခင္း ( reusable) ၿဖစ္တယ္လို ့ေခၚတယ္။ ဘယ္ element ကမဆို သူတို ့ရဲ ့ ေဒတာအမ်ိုးအစား (data type ) အတြက္ သင့္ေလွ်ာ္တယ္ဆိုရင္ တၿခား XML ရဲ ့ ရိွၿပီးသားေဒတာ (build in datatype – eg: Int, Decimal , etc..) ေတြလိုပဲ ေခၚသံုးႏိုင္တယ္။

(သတိၿပဳရန္- type=”currency” ဆိုတာ XML Build-in DataType( XML မွာ အလိုအေလွ်ာက္ပါၿပီးသား ေဒတာအမ်ိုးအစား) မဟုတ္ဘူး။ ကၽြန္ေတာ္တို ့ အေပၚမွာ <simpleType> ဆိုၿပီးေက်ညာခဲ့လို ့သံုးလို ရတာ။ သူဟာ ေဒတာ အမ်ိဳးအစားတစ္ခုလို ့ၿဖစ္သြားပါတယ္။ အဲဒါကို အဓိကေၿပာခ်င္တာပါပဲ။)

ဒါဟာ XML သဒၵါ (schema) ရဲ ့ အလြန္ေကာင္းတဲ့ အားသာခ်က္တစ္ခုပါပဲ။

<simpletype> မွာ ကၽြန္ေတာ္တို ့ <list> <restriction> < union> ေတြကိုသံုးလို ့ ရတယ္လို ့ ေၿပာခဲ့ပါတယ္။
အေပၚမွာ <restriction> ကို သံုးၿပသြားခဲ့ပါတယ္။ အခု <list> ကိုသံုးၿပီး ဘယ္လို ့ အားသားခ်က္ေတြရိွလဲ၊ ဘယ္လိုကိစၥေတြကို လုပ္လို ့ရလဲ ဆိုတာၾကည့္ရေအာင္။

List

List က တန္ဖိုးတစ္ခုတည္းထက္ တန္ဖိုးအမ်ားၾကီးကိုလက္ခံႏိုင္တဲ့ ကိုယ္ပိုင္ ေဒတာ အမ်ိဳးအစားတစ္ခုကို ဖန္တီးတာကို ေၾကညာခ်င္တဲ့အခါမွာ သံုးလို ့ရပါတယ္။ ဥပမာ - ကၽြန္ေတာ္တို ့က color ဆိုတဲ့ element ေလးတစ္ခုကို တည္ေဆာက္မယ္ဆိုပါစို ့။ အဲဒီ ေလးဟာ မွာ အနီ (red) ၊ အ၀ါ (yellow) ၊ အၿပာ (blue) ၊ အစိမ္း (green) စသည္ၿဖင့္ ပါမယ္ေပါ့။ အဲဒီအခါ ကၽြန္ေတာ္တို ့က XML သဒၵါ (XML schema) မွာ ဒီလုိေၾကညာေပးလို ့ရတာေပါ့။

<xs:element name=”color” type=”xs:string”></xs:element>

ဒါေပမယ့္ ဒီလိုေၾကညာရင္ ကၽြန္ေတာ္တို ့ရဲ ့ <color> မွာ တန္ဖိုး (value) တစ္ခုပဲပါလို ့ရမယ္။ ဒီလိုမ်ိဳး -

<color>red</color>  (ဒါက အနီ)
<color>green</color>  (ဒါက အ၀ါ အဲလို တစ္ခုမွာ တန္ဖိုး တခုပဲပါလို ့ရမယ္)

တကယ္လို ့ ကၽြန္ေတာ္တို ့က <color> မွာ တန္ဖိုးေတြ တစ္ခုထက္မက ပါေစခ်င္တယ္ဆိုပါစို ့။<list> ကို သံုးၿပီးလုပ္လို ့ ရၿပီေပါ့။

<xs:element name=”color”>
  <xs:simpleType>
    <xs:list itemType=”xs:string”>
      <xs:restriction>
        <xs:minLength value=”1”/>
        <xs:maxLength value=”5”/>
    </xs:restriction>
  </xs:list>
</xs:simpleType>
</xs:element>

ဒီ XML Schema မွာ <simpleType> ထဲမွာ <list> ကိုထည့္ၿပီး ေၾကညာထားပါတယ္။ အဲဒီ <list> မွာ itemType ဆိုတဲ့ စြမ္းရည္ၿပ စကားလံုး (attribute) တစ္ခုလည္းသံုးထားတယ္။ သူက ဘာကိုေၿပာတာလည္းဆိုေတာ့ ဒီ list ထဲမွာ ပါမဲ့ ေဒတာအမ်ိဳးအစားကို ေၿပာၿပတယ္။ ဒီမွာဆို xs:string ၊ (စာအစဥ္အတန္း) ေဒတာအမ်ိဳးအစားေပါ့။ ဟုတ္တယ္ေလ။ ပါမဲ့ တန္ဖိုးက Red, Blue, Green စသည္ဆိုေတာ့ string အမ်ိဳးအစား ေဒတာေပါ့။ ၿပီးေတာ့ ကၽြန္ေတာ္တုိ ့ အေပၚက သံုးဖူးတဲ့ <restriction> ကို ၿပန္သံုးတယ္။ ဒီေနရာမွာေတာ့ ကၽြန္ေတာ္တို ့က <minLength> နဲ ့ <maxLength> တက္(ဂ္) ေလးကို သံုးထားတယ္။ အဲဒီ တက္(ဂ္)ေလး ၂ ခုက ဘာကိုေၿပာလည္းဆိုေတာ့ <color> element ထဲမွာ ပါမဲ့ တန္းဖိုး အေရအတြက္။ အခု <list> ကိုသံုးလိုက္ေတာ့ <color> ထဲမွာ တန္ဖိုးက တစ္ခုတည္းမဟုတ္ေတာ့ဘူးေလ။ တခုထက္မက ပိုၿပီးပါလာနိုင္ၿပီ မဟုတ္လား။ ဒီေတာ့ ကၽြန္ေတာ္တို ့က min နဲ ့ max ကိုသံုးၿပီး အႏွိမ့္ဆံုး ဘယ္ႏွစ္ခု၊ အၿမင့္ဆံုး ဘယ္ႏွခု ပါခြင့္ရိွႏိုင္သလဲဆိုတာကို သတ္မွတ္ေပးလိုက္တယ္။ ဒီမွာဆို အႏွိမ့္ဆံုး ၁ ခု၊ အၿမင့္ဆံုး ၅ ခုပါခြင့္ ရိွတယ္ေပါ့။

သတိ။ <minLength> နဲ ့ <maxLenght>တို ့က string (စာအစဥ္အတန္း) တစ္ခုလံုးရဲ ့ အရွည္ကို ေၿပာတာမဟုတ္ပါ။ <list> ရဲ ့ အရွည္ (list ထဲမွာ ဘယ္ႏွခုပါလည္းဆိုတာ) ကိုေၿပာတာပါ။

ဒီေတာ့ ၾကည့္ၾကမယ္။

<color>Red Blue Green</color> ဒါဆို အားလံုးအိုေကေပါ့။ Red, Blue, Green ဆိုမွ List က ၃ ခုပဲရိွေသးတာပဲ။ ဟုတ္။

<color>Red Blue Green Black Orange Purple Brown</color> ဒီလိုေတာ့ မရဘူးေပါ့။ ဘာလို ့ လည္းဆိုေတာ့ အၿမင့္ ဆံုး ရိွရမယ့္ အရွည္ ထက္ ပိုမ်ားေနတယ္ေလ။ အၿမင့္ဆံုးအရွည္က ၅ ၊ အခုက ၇ ခု၇ိွေနတယ္။

<color></color> ဒီလိုလည္းမရဘူး။ အနည္းဆံုး တန္းဖိုး ၁ ခုပါရမယ္လို ့သတ္မွတ္ထားခဲ့တယ္။ မွတ္မိတယ္ထင္ပါတယ္။

<list> က ကၽြန္ေတာ္တို ့ element ထဲမွာ တန္ဖိုးတစ္ခုထက္ပိုၿပီး ထည့္ေပးခ်င္တဲ့ အခါ၊ အဲလို element ကို schema (သဒၵါ) မွာ ေၾကညာရတဲ့ အခါမ်ိဳး အသံုးက်ပါတယ္။

ဆက္ရန္။

ထပ္ေရးေနပါတယ္ဗ်ာ..။ :D

အာေကလာ (akela)

Aug 27, 2008 12.02 pm