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

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

• ตอนที่ 1 เรื่องเบื้องต้นที่ควรรู้เกี่ยวกับการเขียนโปรแกรมลง Windows Mobile, Hello World แบบเซียน และผมขอบังอาจกำหนด Application Framework ไว้เลยเราจะได้พูดภาษาเดียวกัน
• ตอนที่ 2 การใช้ฐานข้อมูล SQL Server CE บน Windows Mobile พร้อมกับ Framework การติดต่อฐานข้อมูลในแบบของผม
• ตอนที่ 3 เรื่องของ Data Binding เพื่อนำเอาข้อมูล มา Bind เข้ากับ UI ซึ่งเป็นแนวทางที่ควรใช้ในการเขียนโปรแกรมยุคนี้
• ตอนที่ 4 การเรียกใช้โปรโตคอล/API แบบ REST ซึ่งฮิตตามพวก Social Network Site อย่างเช่น Twitter, Flickr และการอัพโหลด ดาวน์โหลดข้อมูลกับ Web Application รวมไปถึงการสร้าง Web Service/Web Application ให้อุปกรณ์ WM เรียกใช้ได้
• ตอนที่ 5 การใช้งาน Thread เพื่อที่โปรแกรมจะได้ไม่ค้าง เวลารอข้อมูลจาก Server, Database หรือรอข้อมูลจากเครื่อง
• ตอนที่ 6 การใช้งานฟีเจอร์ PIM (Personal Information Management) เพื่อเข้าถึงข้อมูล Contact List, Calendar บนเครื่อง
• ตอนที่ 7 การใช้งานกล้อง และ GPS ในตัวเครื่อง และการแปลงค่า NMEA จาก GPS เป็นข้อมูล
• ตอนที่ 8 การใช้งานฟีเจอร์ด้านโทรศัพท์ของ WM6.5 เช่น ส่ง SMS สั่งโทรออก แล้วเขียนโปรแกรมจับข้อมูลจาก SMS
• ตอนที่ 9 การเขียน Gadget สำหรับ WM6.5
• ตอนที่ 10 การวาดภาพเบื้องต้นด้วย GDI+ เพื่อแสดงกราฟ หรือภาพกราฟฟิกอย่างง่ายๆ
• ตอนที่ 11 การดึงเอาภาพแผนที่จาก Google Map/Virtual Earth มาแสดงผล
• ตอนที่ 12 ผสมทุกอย่างที่เราเจอกันมา และสร้างเป็น App ที่ใช้งานได้จริง คู่กับเว็บ CoreSharp!

หมายเหตุ: สำหรับโพสในเซ็ทนี้ ผมขอสงวนลิขสิทธิ์ ห้ามนำไปเผยแพร่ต่อโดยไม่ได้รับอนุญาตนะครับ ถ้าต้องการใช้เนื้อหาส่วนใดส่วนหนึ่ง กรุณาติดต่อผมทางอีเมลล์ก่อนครับที่ nantcom [at] coresharp [dot] net

เอาละครับ วางแผนกันไว้ดิบดี ซะขนาดนี้ ก็ต้องรีบเขียนซะแล้วละครับ เพื่อไม่ให้เป็นการเสียเวลา มาเริ่มตอนแรกกันเลยดีกว่า กับ เบสิคทั้งหมดที่คุณควรรู้ เกี่ยวกับการเขียนโปรแกรมลง Windows Mobile

สิ่งที่คุณต้องการ

• เครื่องคอม  Dual Core แรม 2GB และไม่จำเป็นต้องมีเครื่อง Windows Mobile จริง
  ถึงแม้ว่าเดี๋ยวนี้ เครื่อง Windows Mobile จะราคาถูกแสนถูก อย่าง Sense 80 ผมเห็นมือ 1 อยู่ที่ 6900 แล้ว แต่การจะพัฒนา ก็ไม่ต้องใช้เครื่องจริงได้ครับ เพราะเทคโนโลยี Emulator นั้นก้าวไปไกลมาแล้ว ขนาดที่ว่า CPU ที่ตัว Emulator จำลองมา ยังเป็น CPU แบบ ARM เหมือนจริงเป๊ะ ส่วนที่ผมว่า ต้องการเครื่อง Dual Core ก็เพราะว่า เครื่องจะได้ไม่อืดจนเกินไป เวลาเปิด Emulator ทำงานไปด้วยครับ และ Emulator เอง ก็กินแรมไปแล้ว 128MB – 200MB ถ้ามีแรมสัก 2GB ก็จะดีครับ
  
• Visual Studio 2008 Professional ขึ้นไป + SP1
  สำหรับการพัฒนาอะไรของไมโครซอฟท์ ก็คงจะหนีไม่พ้น VS2008 แน่นอนอยู่แล้ว และควรจะลง SP1 ด้วยครับ จากการทดลองลง 2010 มันยังไม่มี Device Project นะครับ ดังนั้น อย่าเพิ่งไปลง
  
• Windows Mobile Device Center/ActiveSync
  เอาไว้ Cradle ตัว Emulator ของ Windows Mobile เข้ากับ Windows เหมือนเครื่องจริงๆ ครับ แม้ว่าเราจะไม่มีเครื่องจริงก็ตาม ดาวน์โหลดแบบ 32-bit หรือ 64-bit ตาม Windows ที่ลงอยู่ และติดตั้งเลยครับ ส่วนถ้าใครยังติด WGA ผมก็ได้ Mirror ไว้ให้แล้วครับ
  
• Windows Mobile 6 SDK Refresh และ Windows Mobile 6.5 Developer Tool kit
  ดาวน์โหลด WM6 SDK และ WM6.5 DTK ได้จากเว็บไมโครซอฟท์ครับ
  
• Virtual PC 2007
  อาจจะงงว่า ใช้ Windows Mobile จะเอา Virtual PC มาทำอะไร พอดีว่า ในนั้นมันมี Driver ที่เราต้องการอยู่ครับ ซึ่งไมโครซอทฟ์ไม่ได้เปิดให้ดาวน์โหลดแยก เราจึงจำเป็นต้องดาวน์โหลด Virtual PC มาทั้งก้อน ไม่ได้ใช้ก็ไม่เป็นไรครับ Virtual PC ไม่มีการลง Service อะไรเพิ่มเหมือน VMWare กินที่ไว้อย่างเดียวเท่านั้น เผื่อจะได้เปิดดู VPC อื่นๆ ด้วย ไม่เสียหายอะไรครับ ดาวน์โหลดได้จาก เว็บ Microsoft เลยครับ ใช้ 64-bit ก็ต้องลง 64-bit นะครับ
  
• เซ็ทให้ Emulator ออกเน็ตได้ เพื่อที่เวลาที่คุณไม่ได้มีสายแลน หรือ ต่อ Wireless ตลอดเวลา Emulator ก็ยังคุยกับเครื่องเราได้
  โดยการอ่าน โพสนี้ครับ http://coresharp.net/blogs/article/archive/2008/01/01/set-emulator-vista-xp.aspx
• เราสามารถทำให้ Emulator ออกเน็ตได้ โดยไม่ต้องใช้ Virtual PC และการ Bridge Network แล้วครับ สามารถ ทำตามโพสนี้ได้เลย ถ้าคุณต้องการสร้างโปรเจคที่ต้องติดต่อกับ Server ที่รันบนเครื่องคอมพิวเตอร์ หรือ Server
  
• ระบบ Source Control
  อย่าไปคิดว่า เขียนโปรแกรมเล็กๆ น้อยๆ ไม่ต้องมี Source Control ก็ได้นะครับ การที่มี Source Control ช่วยให้เราช่วยบันทึกไว้ได้ด้วยว่า เราทำอะไรไปบ้างแล้ว มีไฟล์ไหนโดนแก้บ้าง และที่สำคัญคือ ถ้าเกิดเราไปแก้ตรงไหนแล้วเกิดพังขึ้นมา ก็ยังเอา Version เก่า กลับมาได้ ถ้ายังเริ่มต้นไม่ถูก ลองอ่านโพสเรื่อง Source Control ของผมได้ครับ

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

Booting Up!

สำหรับโปรจคของ Windows Mobile จะต่างจากโปรเจคอื่นๆ ใน VS2008 หน่อย ตรงที่หลังจากเลือก Smart Device Project จากหน้าจอด้านล่างนี้แล้ว…

ก็ยังมีหน้าจอให้เราเลือก SDK ที่จะใช้ ต่ออีก ดังรูปด้านล่าง  ซึ่งก็น่าแปลกที่ WM6.5 ไม่นับเป็น SDK แต่ให้เราใช้ WM6 แทน

สำหรับความแตกต่างระหว่าง SDK ชนิดต่างๆ ผมสรุปให้ฟังง่ายๆ ว่า

• Windows CE คือ Real Time OS ที่ออกแบบมาสำหรับทำงานบนเครื่อง Handheld PC (hPC) หรือ เน็ตบุ้ค สมัยก่อนโน้น รวมไปถึงเครื่องใช้ไฟฟ้า ตู้เอทีเอ็ม และอุปกรณ์อื่นๆ อีกหลายอย่าง เวอร์ชั่นแรกของมัน ออกวางขายตั้งแต่ปี 1996 และยังได้รับการพัฒนามาอย่างต่อเนื่อง จึงนับว่าเป็น OS ที่มีรากฐานแน่นหนามากตัวหนึ่งเลยทีเดียว และอาจเรียกได้ว่า “เก๋า” มากกว่า 5 เจ้าที่เหลือในตลาดซะอีก เพราะออกมาปุ๊บ ก็เน้นจอ Touchscreen และ สามารถทำ Handwriting Recognition ได้โดยกำเนิด จะติดอยู่อย่างเดียว ก็ตรงที่หน้าตาของมัน ก็ใช้หน้าตาเดิมมา 13 ปีแล้ว (หน้าตาคล้าย Windows 98 แต่ใช้ไอคอน XP มีปุ่ม Start, Taskbar และ Desktop ครบถ้วน) และก็ยังจะคงใช้อยู่ต่อไปจนกว่าจะถึงปีหน้า ที่ “Windows Mobile 7” จะเปิดตัวในเดือนกุมภาพันธ์ปี 2010 ถ้าสงสัยว่าหน้าตา ของเครื่อง hPC และ Windows CE เป็นยังไง ก็ดูได้จากภาพด้านล่างนี้ครับ
  
• Windows Mobile/Pocket PC/Windows Mobile Professional สำหรับ Windows Mobile หรือ Pocket PC ก็คือ Windows CE เหมือนกัน แต่เป็น Windows CE ที่ออกแบบมาสำหรับเครื่องในระดับ Pocket PC ซึ่งก็คือ Windows Mobile ที่เรารู้จักกันทั่วไปนี่ละครับ หน้าตาเป็นอย่างไร คงไม่ต้องบอก เพราะเห็นกันซะชินตาอยู่แล้ว
  
• Windows Mobile Standard/Smart Phone เป็น Windows CE สำหรับอุปกรณ์ Smart Phone ซึ่งตัวแรกที่ออกมาวางตลาดเลย คือ Orange SPV ซึ่งการทำงานของมัน อันที่จริง ก็คล้ายๆ กับ WM ทั่วไปมาก แต่การออกแบบหน้าจอจะทำได้จำกัดกว่า เพราะไม่มี Touch Screen มีแต่ปุ่มเพียงอย่างเดียว

สำหรับสิ่งแรกที่เราควรจะเตรียมกัน ก็คือ ตัว Emulator ครับ ลองมองดูที่ Toolbar จะเห็นว่ามี Toolbar ใหม่ แสดงขึ้นมาให้เราเลือกว่า จะใช้ Device ตัวไหนในการพัฒนา(สังเกตว่า ไม่มี WM6.5 Device…) ตัวที่เราจะเลือก คือ WM6.5 Professional Portrait QVGA ซึ่งก็คือ เครื่อง WM6.5 ที่วางเครื่องแนวตั้ง และใช้ความละเอียด 320x240 ซึ่งคือระดับมาตรฐานของ WM ทั่วไปครับ

หลังจากเลือกได้แล้ว ให้ไปตั้งค่าของ Emulator เพิ่มอีกหน่อย โดยการกดปุ่ม Device Options ครับ และกดปุ่ม Properties ตามด้วย Emulator Options ต่ออีกครั้งหนึ่ง

• Specify RAM Size ตรงนี้ผมแนะนำให้ใส่ไว้ที่ 128MB ครับ เพราะอุปกรณ์จริงส่วนใหญ่ มีแรมเพียงไม่เกิน 128MB เท่านั้นในขณะนี้
• Network ให้เลือกยี่ห้อแรก และเลือกให้เป็น Connected Network Card หรือ Loopback ถ้าคุณได้ทำตาม Guide ที่ผมบอกไว้

เมื่อตั้งค่าเสร็จแล้ว ให้กด Connect to Device ด้วยปุ่มที่อยู่ข้างกัน จะเป็นการเปิด Emulator ขึ้นมา ซึ่งในครั้งแรก อาจจะใช้เวลานานหน่อย เหมือนเวลาที่เราซื้อเครื่อง Windows Mobile มาใหม่ แบบนั้นเลยครับ เมื่อ Connect ติด  ก็จะได้หน้าจอแบบนี้

แต่เนื่องจากตอนนี้ เครื่องเป็นเครื่องเปล่า ยังไม่ได้ทำการติดตั้งเครื่องมือใดๆ ทั้งสิ้น เราจึงต้องติดตั้ง .NET CF 3.5 ซะก่อน ซึ่งทำได้ง่ายๆ โดยการสั่ง Deploy โปรเจคเราลงไปโดยการกด Build –> Deploy ครับ ซึ่งจะเห็นใน Status Bar ด้านล่างเลยว่า เครื่องกำลังติดตั้ง .NETCF3.5 ลงไป แถมเป็นของ CPU ARM ซะด้วย

สำหรับเหตุที่ว่า ทำไมการ Emulate CPU ARM จึงสำคัญนัก ก็เพราะว่า ผมเคยพัฒนาลง Emulator มาก่อน ซึ่งแต่ก่อน จำลอง CPU ใน Emulator เป็น x86 ปรากฏว่า พอไปรันกับเครื่องจริง เกิดปัญหาขึ้นมากมายจนแทบจะต้องมาแก้ไขทุกอย่างใหม่หมดเลยทีเดียว การที่ Emulate CPU ARM นี้ จึงทำให้เรามั่นใจได้มากขึ้น

เมื่อ VS รายงานว่า Deploy Succeeded ก็ให้เราปิด Emulator ครับ มันจะขึ้นถามว่า ต้องการจะ Save State หรือไม่ ตอนนี้ตอบ Yes ไปก่อนครับ เพื่อให้ Emulator มันจำ State ตอนนี้ไว้ พอครั้งต่อไปให้ตอบ No เพื่อที่ว่า เวลาเปิด Emulator ใหม่ มันจะได้เป็นเครื่องที่สะอาดหมดจด ไม่มีสิ่งเจือปนที่โปรแกรมที่เราเขียน อาจจะไปสร้างไว้ เราจะได้เทสโปรแกรมได้ดีขึ้นครับ

.NET Compact Framework (.NETCF) คืออะไรกัน?

สำหรับผู้ที่เพิ่งจะผ่านมาเห็นเป็นครั้งแรก และยังไม่เคยได้รู้จักกับ .NET CF หรือ Compact Framework มาก่อน (ตอนแรกผมเขียนด้วยความเคยชิน คิดว่าทุกคนรู้จักกันหมดแล้ว ต้องขออภัยไว้ด้วย) .NET CF หรือ Compact Framework นี้คือ .NET Framework พร้อมกับตัว Runtime (CLR) แบบเดียวกับ .NET Framework ตัวเต็มที่รันอยู่บนเครื่อง Desktop ทั่วไปนี่ละครับ แต่ความแตกต่างอยู่ที่ .NET CF จะถูกตัดฟีเจอร์หลายๆ อย่างออกไป เพื่อให้ขนาดมันเล็กลง และสามารถเก็บในรอมของอุปกรณ์ Mobile หรือ มือถือ ซึ่งมีขนาดไม่ใหญ่โตนักได้ ซึ่ง .NET CF 3.5 นั้น มีขนาดพอกับ Silverlight เลยทีเดียว คือประมาณ 4-5MB ในขณะที่ถ้าคุณลองเข้าเว็บไมโครซอฟท์ดู จะพบว่า แค่จะดาวน์โหลด .NET Framework เฉยๆ ก็ขนาดปาเข้าไปตั้งเกือบ 250MB แล้วในเวลานี้ นี่มันยังไม่ได้แตกไฟล์ออกมาในเครื่องเราเลยนะเนี่ย

แล้วทีนี้ จะรู้ได้ยังไงว่า อะไรใช้ได้ อะไรใช้ไม่ได้ ลองเข้าไปดูใน MSDN แล้วจะได้คำตอบครับ

สังเกตว่า ตรงไอคอนที่แสดงถึงเมธอด จะมีตัว S ซึ่งหมายถึง เมธอดแบบ Static เรียกใช้ผ่านชื่อคลาสได้เลย (MessageBox.Show โดยที่ไม่ต้อง MessageBox msg = new MessageBox(); msg.Show()) และมีไอคอนเล็กๆ เป็นรูป Pocket PC สีเหลืองๆ นั่นละครับ หมายถึงว่า เป็น Overload ที่สามารถใช้ใน Windows Mobile ได้ อย่างตัวอย่างของ MessageBox.Show ก็จะเห็นว่า ของ Desktop Framework จะมี Overload เป็นสิบตัว ในขณะที่ ของ .NET CF มีเพียง 3 ตัว ที่เราใช้บ่อยที่สุดเท่านั้น

และอีกทางหนึ่ง คือ ดูได้จาก Platform ด้านล่างครับ สมัมุติว่า ผมต้องการจะใช้ BackgroundWorker แต่ไม่แน่ใจว่า Component นี้ มีใน .NET CF หรือเปล่า ก็ให้ไปที่หน้า Reference ของ BackgroundWorker แล้วเลื่อนลงมาด้านล่าง จะพบกับส่วนนี้ครับ

นั่นแปลว่า มันไม่มีใน .NET CF นั่นเอง แต่ถ้าของ LinkLabel

ก็จะพบว่า มีให้ใช้ใน .NET Compact Framework 2.0 เป็นต้นมาครับ

สำหรับการเขียนโปรแกรมด้วย .NET CF นั้น นอกเหนือจากบางคลาส หรือความสามารถบางอย่างที่หายไป ทุกอย่างใช้งานได้เหมือนกันครับ เช่น Linq, Anonymous Method เป็นต้น

Hello World! (อีกแล้ว)

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

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

ระบบ Tracing

ดังนั้น สิ่งแรกที่ผมมองก็คือเรื่อง Tracibility ครับ ตัวโปรแกรมควรจะมีการ Output ข้อความ เพื่อบอกการทำงานของมันในส่วนการทำงานสำคัญๆ เท่าที่จะเป็นไปได้ ผมจึงแนะนำให้มีคลาสชื่ว่า Tracing เพื่อช่วยให้เราเขียนข้อความลง Trace Message ได้ง่ายขึ้น เป็นคลาสง่ายๆ ที่มีเพียงแค่ Enum และ Property เท่านั้นเองครับ

/// <summary> /// Class which supports tracing /// </summary> public static class Tracing { [Flags] public enum Level { Verbose = 1, // 0001 Info = 2, // 0010 Debug = 4, // 0100 Exception = 8, // 1000 All = 15 // 1111 } /// <summary> /// Gets or sets the current trace level. /// </summary> /// <value>The current level.</value> public static Level CurrentLevel { get; set; } public static bool Verbose { get { return (Tracing.CurrentLevel & Level.Verbose) == Level.Verbose; } } public static bool Info { get { return (Tracing.CurrentLevel & Level.Info) == Level.Info; } } public static bool Debug { get { return (Tracing.CurrentLevel & Level.Debug) == Level.Debug; } } public static bool Exception { get { return (Tracing.CurrentLevel & Level.Exception) == Level.Exception; } } }

จุดน่าสนใจ

• ประการแรก จะเห็นว่า Enum ที่สร้างขึ้นมี Attribute ชื่อว่า Flag อยู่ ตรงนี้เป็นการกำหนดให้ Enum Level ทำงานในลักษณะ Bitfield ครับ
• จะเห็นว่า ภายในการกำหนดค่าของ Enum แต่ละตัว จะเป็นเลขยกกำลังของ 2 (ผมเรียกไม่ถูกเหมือนกัน) นั่นคือ 1 (2^0 = 1), 2 (2), 4 (2x2), 8 (2x2x2), 16 (2x2x2x2) เพราะว่า ค่าของตัวเลขเหล่านี้ เวลามองเป็นไบนารีแล้ว จะมีค่าเป็น 0001, 0010, 0100, 1000 ไปเรื่อยๆ ตามลำดับ คล้ายกับเลข 1 แต่ละตัวในข้อมูลเหล่านี้ เป็นค่า Boolean เพื่อบอกว่า มันมีค่าของ Enum ที่กำหนดไว้อยู่ เช่น
  
  

  หลักที่ 1	หลักที่ 2	หลักที่ 3	หลักที่ 4	ความหมาย
  0	0	0	1	Verbose
  0	1	0	0	Debug
  0	1	0	1	ทั้ง Verbose และ Debug

  
  
• ใน Property Verbose, Debug ที่คืนค่าเป็น Boolean ผมได้ใช้การ Bitwise And เพื่อตรวจสอบว่า มีค่าเหล่านั้น อยู่ใน CurrentLevel หรือไม่
• ค่า Level.All มีค่าเป็น 15 เพราะ 15 คือ 1111 นั่นหมายถึงว่า ไม่ว่าจะ And ด้วยค่าใด ก็จะมีค่าเป็น True นั่นเอง

จับ Unhandled Exception

นอกจากนี้ ภายในคลาส Program เราควรจะมีการจับ Unhandled Exception ไว้ด้วยครับ เพื่อป้องกันในกรณีที่เกิด Exception ที่เราไม่ได้จับไว้ ช่วยให้เราสามารถเก็บรายละเอียดสุดท้ายของโปรแกรม ก่อนที่ทุกอย่างจะพังได้ (ไม่มีทาง Cancel ได้เหมือน WPF) static class Program { private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e) { Exception ex = e.ExceptionObject as Exception; Trace.WriteLineIf(Tracing.Exception, ex.Message + "\r\n" + ex.StackTrace, "Unhandled Exception"); } /// <summary> /// The main entry point for the application. /// </summary> [MTAThread] static void Main() { Tracing.CurrentLevel = Tracing.Level.All; Trace.WriteLineIf(Tracing.Verbose, "Program Startup", "Main"); AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException); } }

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

คลาส Session

ผมเชื่อว่าหลายๆ ท่านอาจจะคุ้นเคยกับคลาส Session ของ ASP.NET หรือว่า PHP นะครับ เราก็จะนำเอาข้อดีของแนวคิดของคลาสที่เป็นศูนย์รวมของข้อมูลต่างๆ ที่ผู้ใช้จำเป็นต้องใช้ ซึ่งก็คือข้อมูลที่เราจะต้องใช้ในการแสดงผลของโปรแกรมเหมือนกันนั่นเอง และการมีคลาสนี้ ก็อาจจะมีส่วนช่วยในการ Debug โปรแกรมได้ด้วย เช่น ถ้าเกิด Unhandled Exception ขึ้นมา เราก็อาจจะทำการ Serialize คลาสนี้เก็บรวมลงไปใน Log ด้วย เพื่อใช้ในการ Reproduce Bug ภายหลัง

นอกจากนี้ คุณยังสามารถทำให้โปรแกรม สามารถ “Hibernate” ตัวเองได้ โดยการเซฟ (Serialize) คลาสนี้ลงไฟล์ หรือเก็บลง Database เพื่อที่ให้เราโหลด (Deserialize) มันกลับมาภายหลังได้

using System; using System.Linq; using System.Collections.Generic; using System.Text; using System.Diagnostics; using System.Windows.Forms; namespace CoreSharp.Lib { /// <summary> /// Class which represents state of the program /// </summary> public class Session { #region (Relaxed) Singleton Pattern private static Session _Current; public Session() { } ///<summary> /// Get the default instance of Session ///</summary> public static Session Current { get { if (_Current == null) { _Current = new Session(); } return _Current; } } #endregion private Form _CurrentForm; ///<summary> ///Get or set the value of CurrentForm ///</summary> public Form CurrentForm { get { return _CurrentForm; } set { _CurrentForm = value; this.CurrentFormName = value.GetType().Name; Trace.WriteLineIf(Tracing.Debug, "Current Form Changed to: " + this.CurrentFormName, "Session"); } } /// <summary> /// Gets or sets the name of the current form. /// </summary> /// <value>The name of the current form.</value> public string CurrentFormName { get; set; } } } 

จุดสังเกต

• คลาสนี้ใช้ Pattern ที่เรีบกว่า Singleton ครับ คือทั้งโปรแกรม จะยอมให้มีคลาสนี้เพียง Instance เดียวเท่านั้น และการเรียกใช้ จะต้องเรียกใช้ผ่าน Session.Current ได้เท่านั้น แต่ Singleton ผมเป็นแบบไม่บังคับมาก ผมขอเรียกมันว่า Relaxed Singleton แล้วกัน คือจะ New ก็ได้แต่ไม่ควร เหตุผลก็เพราะการ Serialization นั่นเอง (ไม่อย่างนั้น ระบบ Serialization ก็จะ New คลาส Session ไม่ได้เหมือนกัน)
• ถึงแม้ว่าเราจะต้องการให้คลาส Session เก็บข้อมูลเพียงชุดเดียว แต่ผมไม่เลือกที่จะประกาศ Member ต่างๆ ให้เป็น Static (Shared ใน Visual Basic) เพราะเหตุผลเรื่องการ Serialization ครับ ถ้าเป็น Static เราจะไม่สามารถ Serialize ได้
• การจะให้คลาสสามารถ Serialize/Deserialize ได้สำเร็จ อาจจะต้องมีการเพิ่มเติมโค๊ด ซึ่งผมยังไม่กล่าวถึงในตอนนี้ครับ

เพิ่มโค๊ดใน Form

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

#region Singleton Pattern private static Form1 _Default; ///<summary> /// Get the default instance of Form1 ///</summary> public static Form1 Default { get { if ( _Default == null ) { _Default = new Form1(); } return _Default; } } #endregion

โค๊ดเปิดโปรแกรม

สำหรับการเปิดโปรแกรม โค๊ดจะแตกต่างจากโค๊ดที่ Visual Studio สร้างขึ้นให้เล็กน้อย ดังนี้ครับ

Tracing.CurrentLevel = Tracing.Level.All; Trace.WriteLineIf(Tracing.Verbose, "Program Startup", "Main"); AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException); // Initializes or resume from hibernation Session.Current.CurrentForm = new Form1(); Session.Current.CurrentForm.Text = "Hello World"; Application.Run(Session.Current.CurrentForm);

จุดสนใจ

• Application.Run แทนที่จะ New ขึ้นมาใหม่ เปลี่ยนเป็นการใช้ Instance จากคลาส Session แทน
• จะเห็นว่า คุณสามารถดู Form ปัจจุบัน จากคลาส Session และเรียกใช้ Form ปัจจุบันได้ผ่าน Session.CurrentForm ได้เลย

เอ แล้ว Hello ตรงไหนละ?

อิอิ ผมปล่อยให้เป็นการบ้านแล้วกันครับ ผม Hello ไว้ด้านบนตรง Title Bar เนี่ยแหละ

สรุปส่งท้าย

ในตอนนี้ ผมได้พูดถึงองค์ประกอบต่างๆ ที่ผสมรวมกันเป็นรากฐานที่แข็งแรงสำหรับ App บน Windows Mobile กันไปแล้ว ถ้ามีคำแนะนำติชม ก็มาเม้นบอกกันได้นะครับ ผมเปิดรับไอเดียใหม่ๆ เสมอ

สำหรับตอนหน้า คือเรื่องการใช้งานฐานข้อมูล ติดตามต่อกันได้ที่โพสนี้เลยครับ