การเขียนโปรแกรมขั้นสูงด้วย C# และ .NET.3.5 (รุ่นที่ 4)

C# 与.NET 3.0 高级程序设计（英文版）

ตอนที่ 1 nnn การแนะนำ C# และแพลตฟอร์ม .NET
บทที่ 1 ปรัชญาของ .NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 3
ทำความเข้าใจกับสถานการณ์ก่อนหน้า - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 3
โซลูชั่น .NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 6
ขอแนะนำ Building Blocks ของแพลตฟอร์ม .NET (CLR, CTS,
และซีแอลเอส) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 6
ภาษาการเขียนโปรแกรม .NET-Aware เพิ่มเติม - - - - - - - - - - - - - - - - - - - - - - - - - - 9
ภาพรวมของ .NET Assembly - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 11
ทำความเข้าใจกับระบบประเภททั่วไป - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 17
การทำความเข้าใจข้อกำหนดภาษาทั่วไป - - - - - - - - - - - - - - - - - - - - - 20
ทำความเข้าใจรันไทม์ภาษาทั่วไป - - - - - - - - - - - - - - - - - - - - - - - - - 22
แอสเซมบลี/เนมสเปซ/ความแตกต่างประเภท - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 23
การสำรวจ Assembly โดยใช้ ildasm.exe - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 28
สำรวจการชุมนุมโดยใช้ตัวสะท้อนแสงของ Lutz Roeder - - - - - - - - - - - - - - - - - - - - - 31
การปรับใช้รันไทม์ .NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 31
ลักษณะที่ไม่ขึ้นกับแพลตฟอร์มของ .NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 32
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 33
บทที่ 2 การสร้างแอปพลิเคชัน C# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 35
บทบาทของ .NET Framework 3.5 SDK - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 35
การสร้างแอปพลิเคชัน C# โดยใช้ csc.exe - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 36
การสร้างแอปพลิเคชัน .NET โดยใช้ TextPad - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 42
การสร้างแอปพลิเคชัน .NET โดยใช้ Notepad++ - - - - - - - - - - - - - - - - - - - - - - - - - - - - 46
การสร้างแอปพลิเคชัน .NET โดยใช้ SharpDevelop - - - - - - - - - - - - - - - - - - - - - - - - - - 48
การสร้างแอปพลิเคชัน .NET โดยใช้ Visual C# 2008 Express - - - - - - - - - - - - - - - - - 50
การสร้างแอปพลิเคชัน .NET โดยใช้ Visual Studio 2008 - - - - - - - - - - - - - - - - - - - - - 52
แค็ตตาล็อกบางส่วนของเครื่องมือพัฒนา .NET เพิ่มเติม - - - - - - - - - - - - - - - - - - - 64
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 65
สี่
ส่วนที่ 2 โครงสร้างการเขียนโปรแกรม C# nnn
บทที่ 3 โครงสร้างการเขียนโปรแกรม Core C# ตอนที่ 1 - - - - - - - - - - - - - - - - - - - - - - - - 69
กายวิภาคของโปรแกรม C# อย่างง่าย - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 69
นอกเหนือจากที่น่าสนใจ: สมาชิกเพิ่มเติมบางส่วนของ
ระบบ.ระดับสิ่งแวดล้อม. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 75
คลาส System.Console - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 76
ประเภทข้อมูลระบบและสัญลักษณ์ชวเลข C# - - - - - - - - - - - - - - - - - - - - - - - - - - 80
ทำความเข้าใจเกี่ยวกับ System.String Type - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 86
การแปลงประเภทข้อมูลที่แคบลงและกว้างขึ้น - - - - - - - - - - - - - - - - - - - - - - - - - 95
โครงสร้างการวนซ้ำ C # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 100
โครงสร้างการตัดสินใจและตัวดำเนินการเชิงสัมพันธ์/ความเท่าเทียมกัน - - - - - - - - - - - - - - - - 102
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 104
บทที่ 4 โครงสร้างการเขียนโปรแกรม Core C# ตอนที่ II - - - - - - - - - - - - - - - - - - - - - - - 107
วิธีการและตัวแก้ไขพารามิเตอร์ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 107
ทำความเข้าใจกับการโอเวอร์โหลดของสมาชิก - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 113
การจัดการอาร์เรย์ใน C# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 114
ทำความเข้าใจกับประเภท Enum - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 121
ทำความเข้าใจกับประเภทโครงสร้าง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 126
การทำความเข้าใจประเภทค่าและประเภทการอ้างอิง - - - - - - - - - - - - - - - - - - - - - - - 129
ค่าและประเภทการอ้างอิง: รายละเอียดขั้นสุดท้าย - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 135
ทำความเข้าใจเกี่ยวกับประเภท Nullable ของ C# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 136
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 139
บทที่ 5 การกำหนดประเภทคลาสแบบห่อหุ้ม - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 141
ขอแนะนำประเภทคลาส C# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 141
ทำความเข้าใจกับตัวสร้างคลาส - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 144
บทบาทของคำหลักนี้ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 147
ทำความเข้าใจกับคำหลักแบบคงที่ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 152
การกำหนดเสาหลักของ OOP - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 159
ตัวแก้ไขการเข้าถึง C # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 163
เสาแรก: บริการห่อหุ้มของ C# - - - - - - - - - - - - - - - - - - - - - - - - - - - 164
ทำความเข้าใจกับข้อมูลคงที่ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 173
ทำความเข้าใจกับฟิลด์แบบอ่านอย่างเดียว - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 174
ทำความเข้าใจกับประเภทบางส่วน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 175
การจัดทำเอกสารซอร์สโค้ด C# ผ่าน XML - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 176
เห็นภาพผลของแรงงานของเรา - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 182
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 182
บทที่ 6 การทำความเข้าใจเกี่ยวกับมรดกและความหลากหลาย - - - - - - - - - - - - - - - - - 185
กลไกพื้นฐานของการสืบทอด - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 185
การแก้ไขไดอะแกรมคลาส Visual Studio - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 189
เสาที่สอง: รายละเอียดของมรดก - - - - - - - - - - - - - - - - - - - - - - - - - - - 190
การเขียนโปรแกรมสำหรับการบรรจุ/การมอบหมาย - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 196
เนื้อหา v
vi สารบัญ
เสาหลักที่สาม: การสนับสนุน Polymorphic ของ C# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 199
ทำความเข้าใจกับกฎการคัดเลือกคลาสพื้นฐาน/คลาสที่ได้รับ - - - - - - - - - - - - - - - - - - 210
คลาสผู้ปกครองหลัก: System.Object - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 212
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 218
บทที่ 7 การทำความเข้าใจการจัดการข้อยกเว้นที่มีโครงสร้าง - - - - - - - - - - - - - - - - - - 219
บทกวีถึงข้อผิดพลาด ข้อบกพร่อง และข้อยกเว้น - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 219
บทบาทของการจัดการข้อยกเว้น .NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 220
ตัวอย่างที่ง่ายที่สุดที่เป็นไปได้ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 222
การกำหนดค่าสถานะของข้อยกเว้น - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 226
ข้อยกเว้นระดับระบบ (System.SystemException) - - - - - - - - - - - - - - - - - - - - 230
ข้อยกเว้นระดับแอปพลิเคชัน (System.ApplicationException) - - - - - - - - - - - - - - 231
กำลังประมวลผลข้อยกเว้นหลายรายการ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 236
บล็อคสุดท้าย. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 239
ใครเป็นคนขว้างอะไร? - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 240
ผลลัพธ์ของข้อยกเว้นที่ไม่สามารถจัดการได้ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 241
การดีบักข้อยกเว้นที่ไม่สามารถจัดการได้โดยใช้ Visual Studio . - - - - - - - - - - - - - - - - - - - 242
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 243
บทที่ 8 ทำความเข้าใจเกี่ยวกับอายุการใช้งานของวัตถุ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 245
คลาส วัตถุ และการอ้างอิง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 245
พื้นฐานของอายุการใช้งานของวัตถุ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 246
บทบาทของรูทแอปพลิเคชัน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 249
ทำความเข้าใจเกี่ยวกับการสร้างออบเจ็กต์ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 251
ประเภท System.GC - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 252
การสร้างออบเจ็กต์ที่สามารถสรุปผลได้ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 256
การสร้างวัตถุที่ใช้แล้วทิ้ง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 259
การสร้างประเภทที่สรุปผลได้และแบบใช้แล้วทิ้ง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 262
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 265
ส่วนที่ 3 โครงสร้างการเขียนโปรแกรม C# ขั้นสูง
บทที่ 9 การทำงานกับอินเทอร์เฟซ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 269
ทำความเข้าใจเกี่ยวกับประเภทอินเทอร์เฟซ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 269
การกำหนดอินเทอร์เฟซแบบกำหนดเอง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 272
การใช้อินเทอร์เฟซ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 274
การเรียกใช้สมาชิกอินเทอร์เฟซในระดับอ็อบเจ็กต์ - - - - - - - - - - - - - - - - - - - - - - - - 276
อินเทอร์เฟซเป็นพารามิเตอร์ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 278
อินเทอร์เฟซเป็นค่าส่งคืน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 280
อาร์เรย์ของประเภทอินเทอร์เฟซ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 281
การใช้อินเทอร์เฟซโดยใช้ Visual Studio 2008 - - - - - - - - - - - - - - - - - - - - - - 282
การแก้ไขการขัดแย้งของชื่อด้วยการใช้อินเทอร์เฟซที่ชัดเจน - - - - - - - - - - - - 283
การออกแบบลำดับชั้นของอินเทอร์เฟซ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 286
การสร้างประเภทการนับ (IEnumerable และ IEnumerator) - - - - - - - - - - - - - - 289
การสร้างวัตถุที่โคลนได้ (ICloneable) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 295
การสร้างวัตถุที่เปรียบเทียบได้ (IComparable) - - - - - - - - - - - - - - - - - - - - - - - - - - - - 299
ทำความเข้าใจกับอินเทอร์เฟซการโทรกลับ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 304
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 308
บทที่ 10 คอลเลกชันและข้อมูลทั่วไป - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 309
อินเทอร์เฟซของ System.Collections Namespace - - - - - - - - - - - - - - - - - - - - 309
ประเภทคลาสของ System.Collections - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 312
System.Collections.เนมสเปซเฉพาะทาง - - - - - - - - - - - - - - - - - - - - - - - - - - - - 316
ความสัมพันธ์ระหว่างการชกมวย การแกะกล่อง และระบบ วัตถุ - - - - - - - - - - - - - - - - - - 316
ประเด็นเรื่องความปลอดภัยประเภทและคอลเลกชันที่พิมพ์อย่างเข้มงวด - - - - - - - - - - - - - - - - - 319
System.Collections.Generic เนมสเปซ - - - - - - - - - - - - - - - - - - - - - - - - - - - 324
การสร้างวิธีการทั่วไปแบบกำหนดเอง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 327
การสร้างโครงสร้างและคลาสทั่วไป - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 330
การสร้างคอลเลกชันทั่วไปที่กำหนดเอง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 332
การสร้างคลาสพื้นฐานทั่วไป - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 337
การสร้างอินเทอร์เฟซทั่วไป - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 338
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 339
บทที่ 11 ผู้ร่วมประชุม กิจกรรม และแลมบ์ดา - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 341
ทำความเข้าใจเกี่ยวกับประเภทผู้รับมอบสิทธิ์ .NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 341
การกำหนดผู้รับมอบสิทธิ์ใน C # . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 342
คลาสพื้นฐานของ System.MulticastDelegate และ System.Delegate - - - - - - - - 344
ตัวอย่างการมอบสิทธิ์ที่ง่ายที่สุดที่เป็นไปได้ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 345
การปรับเปลี่ยนประเภทรถยนต์ด้วยผู้ร่วมประชุม - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 348
ตัวอย่างการมอบหมายที่ซับซ้อนยิ่งขึ้น - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 353
ทำความเข้าใจกับความแปรปรวนร่วมของผู้รับมอบสิทธิ์ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 358
การสร้างผู้รับมอบสิทธิ์ทั่วไป - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 360
ทำความเข้าใจกับเหตุการณ์ C# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 362
ผู้รับมอบสิทธิ์ EventHandler ทั่วไป - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 369
ทำความเข้าใจกับวิธีการที่ไม่ระบุชื่อ C # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 370
ทำความเข้าใจกับการแปลงกลุ่มวิธีการ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 372
ตัวดำเนินการแลมบ์ดา C# 2008 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 374
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 381
บทที่ 12 ตัวทำดัชนี ตัวดำเนินการ และตัวชี้ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 383
ทำความเข้าใจวิธีการทำดัชนี - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 383
ทำความเข้าใจกับการโอเวอร์โหลดของตัวดำเนินการ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 388
ทำความเข้าใจกับการแปลงประเภทที่กำหนดเอง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 397
การทำงานกับประเภทพอยน์เตอร์ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 404
คำสั่งตัวประมวลผลล่วงหน้า C # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 411
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 414
บทที่ 13 คุณสมบัติภาษา C# 2008 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 415
ทำความเข้าใจกับตัวแปรท้องถิ่นที่พิมพ์โดยปริยาย - - - - - - - - - - - - - - - - - - - - - - - - - 415
ทำความเข้าใจเกี่ยวกับคุณสมบัติอัตโนมัติ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 420
ทำความเข้าใจกับวิธีการขยาย - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 424
ไม่มีเนื้อหา vii
ทำความเข้าใจวิธีการบางส่วน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 433
ทำความเข้าใจกับไวยากรณ์ของ Object Initializer - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 436
ทำความเข้าใจกับประเภทที่ไม่เปิดเผยตัวตน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 440
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 445
บทที่ 14 บทนำสู่ LINQ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 447
ทำความเข้าใจบทบาทของ LINQ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 447
ดูครั้งแรกที่ LINQ Query Expressions - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 450
LINQ และคอลเลกชันทั่วไป - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 456
LINQ และคอลเลกชันที่ไม่ใช่แบบทั่วไป - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 457
การแสดงภายในของตัวดำเนินการสืบค้น LINQ - - - - - - - - - - - - - - - - - - - - 459
การตรวจสอบตัวดำเนินการสืบค้น C# LINQ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 463
แบบสอบถาม LINQ: เกาะสำหรับตัวเอง?. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 469
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 472
ตอนที่ 4 nnn การเขียนโปรแกรมด้วย .NET Assemblies
บทที่ 15 การแนะนำ .NET Assemblies - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 475
การกำหนดเนมสเปซที่กำหนดเอง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 475
บทบาทของ. NET Assembly - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 480
ทำความเข้าใจรูปแบบของ .NET Assembly - - - - - - - - - - - - - - - - - - - - - - - - - 482
การสร้างและการใช้แอสเซมบลีไฟล์เดียว - - - - - - - - - - - - - - - - - - - - - - - - 486
การสร้างและการใช้ชุดประกอบหลายไฟล์ - - - - - - - - - - - - - - - - - - - - - - - - - - 496
ทำความเข้าใจกับสภาเอกชน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 499
ทำความเข้าใจกับแอสเซมบลีที่ใช้ร่วมกัน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 504
การบริโภคการชุมนุมที่ใช้ร่วมกัน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 510
การกำหนดค่าแอสเซมบลีที่ใช้ร่วมกัน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 512
การตรวจสอบองค์ประกอบภายในของ GAC - - - - - - - - - - - - - - - - - - - - - - - 516
ทำความเข้าใจเกี่ยวกับแอสเซมบลีนโยบายผู้จัดพิมพ์ - - - - - - - - - - - - - - - - - - - - - - - - - - - - 518
ทำความเข้าใจกับองค์ประกอบ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 519
เนมสเปซ System.Configuration - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 521
ไฟล์การกำหนดค่าเครื่อง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 522
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 522
บทที่ 16 การสะท้อนประเภท การเชื่อมโยงล่าช้า และอิงตามคุณลักษณะ
การเขียนโปรแกรม - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 523
ความจำเป็นของประเภทข้อมูลเมตา - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 523
ทำความเข้าใจกับการสะท้อน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 527
การสร้างโปรแกรมดูข้อมูลเมตาที่กำหนดเอง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 530
กำลังโหลดแอสเซมบลีแบบไดนามิก - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 536
สะท้อนถึงแอสเซมบลีที่ใช้ร่วมกัน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 538
ทำความเข้าใจกับการผูกมัดล่าช้า - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 539
viii เนื้อหา
ทำความเข้าใจกับการเขียนโปรแกรมแบบระบุแหล่งที่มา - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 542
การสร้างคุณสมบัติที่กำหนดเอง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 546
แอตทริบิวต์ระดับแอสเซมบลี (และระดับโมดูล) - - - - - - - - - - - - - - - - - - - - - - - - - 549
การสะท้อนคุณลักษณะโดยใช้การผูกล่วงหน้า - - - - - - - - - - - - - - - - - - - - - - - - - - - - 550
การสะท้อนคุณลักษณะโดยใช้ Late Binding - - - - - - - - - - - - - - - - - - - - - - - - - - - - 551
ใส่การสะท้อน การผูกล่าช้า และแอตทริบิวต์ที่กำหนดเองในเปอร์สเปคทีฟ - - - - - 553
การสร้างแอปพลิเคชันแบบขยายได้ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 553
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 559
บทที่ 17 กระบวนการ AppDomains และบริบทของออบเจ็กต์ - - - - - - - - - - - - - - - - - - 561
การทบทวนกระบวนการ Win32 แบบดั้งเดิม - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 561
การโต้ตอบกับกระบวนการภายใต้แพลตฟอร์ม .NET - - - - - - - - - - - - - - - - - - - - - 563
ทำความเข้าใจกับโดเมนแอปพลิเคชัน .NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 571
การทำความเข้าใจขอบเขตบริบทของวัตถุ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 577
การสรุปกระบวนการ AppDomains และบริบท - - - - - - - - - - - - - - - - - - - - - 581
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 582
บทที่ 18 การสร้างแอปพลิเคชันแบบมัลติเธรด - - - - - - - - - - - - - - - - - - - - - - - - - - - - 583
กระบวนการ/AppDomain/บริบท/ความสัมพันธ์ของเธรด - - - - - - - - - - - - - - - - - - - 583
การตรวจสอบโดยย่อของ .NET Delegate - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 585
ลักษณะอะซิงโครนัสของผู้ได้รับมอบหมาย - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 587
การเรียกใช้เมธอดแบบอะซิงโครนัส - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 588
เนมสเปซ System.Threading - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 593
คลาส System.Threading.Thread - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 594
การสร้างเธรดรองโดยทางโปรแกรม - - - - - - - - - - - - - - - - - - - - - - - - - 597
ประเด็นเรื่องความเห็นพ้องต้องกัน. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 602
การเขียนโปรแกรมด้วย Timer Callbacks - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 609
ทำความเข้าใจเกี่ยวกับ CLR ThreadPool - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 610
บทบาทของคอมโพเนนต์ BackgroundWorker - - - - - - - - - - - - - - - - - - - - - - - - - 612
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 616
บทที่ 19 การทำความเข้าใจ CIL และบทบาทของแอสเซมบลีแบบไดนามิก - - - - - - - 617
สะท้อนถึงธรรมชาติของการเขียนโปรแกรม CIL - - - - - - - - - - - - - - - - - - - - - - - - - - 617
การตรวจสอบคำสั่ง CIL คุณลักษณะ และ Opcodes - - - - - - - - - - - - - - - - - - - - - - 618
การผลักและการกระแทก: ลักษณะแบบสแต็กของ CIL - - - - - - - - - - - - - - - - - - - 620
ทำความเข้าใจเกี่ยวกับวิศวกรรมไป-กลับ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 621
ทำความเข้าใจกับคำสั่งและคุณลักษณะของ CIL - - - - - - - - - - - - - - - - - - - - - - - - - - - - 629
.NET Base Class Library, C# และ CIL Data Type Mappings - - - - - - - - - - - - - - - 635
การกำหนดประเภทสมาชิกใน CIL - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 636
ตรวจสอบ CIL Opcodes - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 638
การสร้าง.NET Assembly ด้วย CIL . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 643
ทำความเข้าใจกับแอสเซมบลีแบบไดนามิก - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 648
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 657
เนื้อหา ix
ส่วนที่ 5 nnn การแนะนำ .NET Base Class Libraries
บทที่ 20 ไฟล์ I/O และพื้นที่เก็บข้อมูลแบบแยก - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 661
การสำรวจเนมสเปซ System.IO - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 661
ประเภทไดเร็กทอรี (ข้อมูล) และไฟล์ (ข้อมูล) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 662
การทำงานกับ DirectoryInfo Type - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 663
การทำงานกับประเภทไดเรกทอรี - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 667
การทำงานกับประเภทคลาส DriveInfo - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 668
การทำงานกับคลาส FileInfo - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 669
การทำงานกับประเภทไฟล์ . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 673
คลาสสตรีมบทคัดย่อ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 675
การทำงานร่วมกับ StreamWriters และ StreamReaders - - - - - - - - - - - - - - - - - - - - - - - 677
การทำงานกับ StringWriters และ StringReaders - - - - - - - - - - - - - - - - - - - - - - - - - 680
การทำงานกับ BinaryWriters และ BinaryReaders - - - - - - - - - - - - - - - - - - - - - - - - - 682
ไฟล์ "การรับชม" โดยทางโปรแกรม - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 683
การดำเนินการ I/O ไฟล์แบบอะซิงโครนัส - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 685
ทำความเข้าใจบทบาทของพื้นที่เก็บข้อมูลแบบแยกส่วน - - - - - - - - - - - - - - - - - - - - - - - - - - - - 687
ไพรเมอร์เกี่ยวกับการรักษาความปลอดภัยการเข้าถึงรหัส - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 688
ภาพรวมของพื้นที่เก็บข้อมูลแบบแยกส่วน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 698
การรับร้านค้าโดยใช้ IsolatedStorageFile - - - - - - - - - - - - - - - - - - - - - - - - - - - - 702
พื้นที่เก็บข้อมูลแบบแยกในการดำเนินการ: การปรับใช้ ClickOnce - - - - - - - - - - - - - - - - - - - - - - - 707
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 710
บทที่ 21 การแนะนำวัตถุการทำให้เป็นอนุกรม - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 711
ทำความเข้าใจเกี่ยวกับการทำให้เป็นอนุกรมของวัตถุ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 711
การกำหนดค่าออบเจ็กต์สำหรับการทำให้เป็นอนุกรม - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 713
การเลือกฟอร์แมตเตอร์การทำให้เป็นอนุกรม - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 715
การทำให้วัตถุเป็นอนุกรมโดยใช้ BinaryFormatter - - - - - - - - - - - - - - - - - - - - - - - - - - 717
การทำให้วัตถุเป็นอนุกรมโดยใช้ SoapFormatter - - - - - - - - - - - - - - - - - - - - - - - - - - - 719
การทำให้วัตถุเป็นอนุกรมโดยใช้ XmlSerializer - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 720
การเรียงลำดับคอลเลกชันของออบเจ็กต์ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 723
การปรับแต่งกระบวนการทำให้เป็นอนุกรม - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 724
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 729
บทที่ 22 ADO.NET ตอนที่ 1: เลเยอร์ที่เชื่อมต่อ - - - - - - - - - - - - - - - - - - - - - - - - - - - 731
คำจำกัดความระดับสูงของ ADO.NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 731
ทำความเข้าใจกับผู้ให้บริการข้อมูล ADO.NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 733
เนมสเปซ ADO.NET เพิ่มเติม - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 736
ประเภทของเนมสเปซ System.Data - - - - - - - - - - - - - - - - - - - - - - - - - - - - 737
ผู้ให้บริการข้อมูลเชิงนามธรรมโดยใช้อินเทอร์เฟซ - - - - - - - - - - - - - - - - - - - - - - - - - - - - 741
การสร้างฐานข้อมูล AutoLot - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 744
แบบจำลองโรงงานผู้ให้บริการข้อมูล ADO.NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 749
ทำความเข้าใจกับเลเยอร์ที่เชื่อมต่อของ ADO.NET - - - - - - - - - - - - - - - - - - - - - - - - 755
การทำงานกับเครื่องอ่านข้อมูล - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 760
การสร้างไลบรารีการเข้าถึงข้อมูลที่ใช้ซ้ำได้ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 763
x nเนื้อหา
การสร้างส่วนหน้าตาม UI ของคอนโซล - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 770
การเข้าถึงข้อมูลแบบอะซิงโครนัสโดยใช้ SqlCommand - - - - - - - - - - - - - - - - - - - - - - - - 775
ทำความเข้าใจเกี่ยวกับธุรกรรมฐานข้อมูล - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 777
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 781
บทที่ 23 ADO.NET ตอนที่ II: เลเยอร์ที่ขาดการเชื่อมต่อ - - - - - - - - - - - - - - - - - - - - - - - 783
ทำความเข้าใจกับ Disconnected Layer ของ ADO.NET - - - - - - - - - - - - - - - - - - - - - 783
การทำความเข้าใจบทบาทของชุดข้อมูล - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 784
การทำงานกับ DataColumns - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 787
การทำงานกับ DataRows - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 789
การทำงานกับ DataTable - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 793
การเชื่อมโยงวัตถุ DataTable กับส่วนต่อประสานผู้ใช้ - - - - - - - - - - - - - - - - - - - - - - - - - - - 798
การกรอกวัตถุ DataSet/DataTable โดยใช้ Data Adapters - - - - - - - - - - - - - - - - - - 808
เยี่ยมชม AutoLotDAL.dll อีกครั้ง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 811
การนำทางวัตถุชุดข้อมูลแบบหลายตาราง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 814
เครื่องมือการเข้าถึงข้อมูลของ Visual Studio 2008 - - - - - - - - - - - - - - - - - - - - - - - - - - 820
แยกรหัสที่สร้างอัตโนมัติออกจากเลเยอร์ UI - - - - - - - - - - - - - - - - - - - - - - 831
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 835
บทที่ 24 การเขียนโปรแกรมด้วย LINQ API - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 837
บทบาทของ LINQ ต่อ ADO.NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 837
การเขียนโปรแกรมด้วย LINQ ไปยัง DataSet . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 838
การเขียนโปรแกรมด้วย LINQ เป็น SQL . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 843
การสร้างคลาสเอนทิตีโดยใช้ SqlMetal.exe - - - - - - - - - - - - - - - - - - - - - - - - - - 848
การสร้างคลาสเอนทิตีโดยใช้ Visual Studio 2008 . - - - - - - - - - - - - - - - - - - - - - - - 854
การจัดการเอกสาร XML โดยใช้ LINQ เป็น XML - - - - - - - - - - - - - - - - - - - - - - - 857
การนำทางเอกสารในหน่วยความจำ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 862
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 865
บทที่ 25 แนะนำ Windows Communication Foundation - - - - - - - - - - - - - - 867
บุหงาของ API คอมพิวเตอร์แบบกระจาย - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 867
บทบาทของ WCF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 873
การตรวจสอบชุดประกอบ WCF หลัก - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 876
เทมเพลตโครงการ Visual Studio WCF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 877
องค์ประกอบพื้นฐานของแอปพลิเคชัน WCF - - - - - - - - - - - - - - - - - - - - - - - - - - - 879
ABC ของ WCF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 880
การสร้างบริการ WCF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 885
โฮสติ้งบริการ WCF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 888
การสร้างแอปพลิเคชันไคลเอ็นต์ WCF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 896
การใช้เทมเพลตโครงการห้องสมุดบริการ WCF - - - - - - - - - - - - - - - - - - - - - - - - 900
โฮสต์บริการ WCF เป็นบริการ Windows - - - - - - - - - - - - - - - - - - - - - - - - 903
การเรียกใช้บริการแบบอะซิงโครนัส - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 908
การออกแบบสัญญาข้อมูล WCF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 910
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 915
ไม่มีเนื้อหา xi
บทที่ 26 การแนะนำ Windows Workflow Foundation - - - - - - - - - - - - - - - - - - - - 917
การกำหนดกระบวนการทางธุรกิจ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 917
องค์ประกอบสำคัญของ WF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 918
แอสเซมบลี WF เนมสเปซ และโปรเจ็กต์ - - - - - - - - - - - - - - - - - - - - - - - - - - - - 924
การสร้างแอปพลิเคชันที่เปิดใช้งานเวิร์กโฟลว์อย่างง่าย - - - - - - - - - - - - - - - - - - - - - - - - 926
ตรวจสอบรหัสโฮสติ้ง WF Engine - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 930
การเรียกใช้บริการเว็บภายในเวิร์กโฟลว์ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 934
การสร้างไลบรารีโค้ด WF ที่ใช้ซ้ำได้ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 945
คำสั้นๆ เกี่ยวกับกิจกรรมที่กำหนดเอง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 951
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 952
ส่วนที่ 6 nnn อินเทอร์เฟซผู้ใช้เดสก์ท็อป
บทที่ 27 การเขียนโปรแกรมด้วย Windows Forms - - - - - - - - - - - - - - - - - - - - - - - - - - - - 955
เนมสเปซแบบฟอร์ม Windows - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 955
การสร้างแอปพลิเคชัน Windows Forms อย่างง่าย (ไม่มี IDE) - - - - - - - - - - - - - - - - - 956
เทมเพลตโครงการแบบฟอร์ม Windows Visual Studio - - - - - - - - - - - - - - - - - - - - - 961
กายวิภาคของแบบฟอร์ม - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 968
ตอบสนองต่อกิจกรรมของเมาส์ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 975
การตอบสนองต่อกิจกรรมของแป้นพิมพ์ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 977
การออกแบบกล่องโต้ตอบ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 978
การแสดงผลข้อมูลกราฟิกโดยใช้ GDI+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 985
การสร้างแอปพลิเคชัน Windows Forms ที่สมบูรณ์ - - - - - - - - - - - - - - - - - - - - - - - 990
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 997
บทที่ 28 การแนะนำ Windows Presentation Foundation และ XAML - - - - - - 999
แรงจูงใจเบื้องหลัง WPF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 999
รสชาติที่หลากหลายของแอปพลิเคชั่น WPF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1002
การตรวจสอบการชุมนุม WPF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1004
การสร้างแอปพลิเคชัน WPF (ปลอด XAML) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1011
รายละเอียดเพิ่มเติมของประเภทการสมัคร - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1015
รายละเอียดเพิ่มเติมของประเภทหน้าต่าง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1017
การสร้างแอปพลิเคชัน WPF (XAML-Centric) - - - - - - - - - - - - - - - - - - - - - - - - - - - 1,021
การแปลงมาร์กอัปให้เป็น .NET Assembly - - - - - - - - - - - - - - - - - - - - - - - - - - - 1,025
การแยกข้อกังวลโดยใช้ไฟล์ Code-Behind - - - - - - - - - - - - - - - - - - - - - - 1,029
ไวยากรณ์ของ XAML - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1,031
การสร้างแอปพลิเคชัน WPF โดยใช้ Visual Studio 2008 - - - - - - - - - - - - - - - - - - - 1,044
กำลังประมวลผล XAML ที่รันไทม์: SimpleXamlPad.exe - - - - - - - - - - - - - - - - - - - - - 1,048
บทบาทของ Microsoft Expression Blend - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1,052
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1,053
xii เนื้อหา
บทที่ 29 การเขียนโปรแกรมด้วยการควบคุม WPF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1,055
การสำรวจไลบรารีควบคุม WPF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1,055
การประกาศการควบคุมใน XAML . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1,058
การทำความเข้าใจบทบาทของคุณสมบัติการพึ่งพา - - - - - - - - - - - - - - - - - - - - - 1,060
ทำความเข้าใจกับเหตุการณ์ที่กำหนดเส้นทาง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1,064
การทำงานกับประเภทปุ่ม - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1,068
การทำงานกับ CheckBoxes และ RadioButtons - - - - - - - - - - - - - - - - - - - - - - - - - - 1,072
การทำงานกับ ListBox และ ComboBox Types - - - - - - - - - - - - - - - - - - - - - - - 1,075
การทำงานกับพื้นที่ข้อความ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1081
การควบคุมเค้าโครงเนื้อหาโดยใช้พาเนล - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1083
การสร้างกรอบหน้าต่างโดยใช้แผงที่ซ้อนกัน - - - - - - - - - - - - - - - - - - - - - - 1,093
ทำความเข้าใจกับคำสั่งควบคุม WPF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1,099
ทำความเข้าใจกับโมเดลการเชื่อมโยงข้อมูล WPF - - - - - - - - - - - - - - - - - - - - - - - - - - 1102
การแปลงข้อมูลโดยใช้ IValueConverter - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1106
เชื่อมโยงกับออบเจ็กต์ที่กำหนดเอง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1108
การเชื่อมโยงองค์ประกอบ UI กับเอกสาร XML - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1112
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1116
บทที่ 30 การเรนเดอร์กราฟิก ทรัพยากร และธีม WPF 2D - - - - - - - - 1117
ปรัชญาของบริการการเรนเดอร์กราฟิก WPF - - - - - - - - - - - - - - - - - - - 1117
การสำรวจประเภทที่ได้มาจากรูปร่าง - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1124
การทำงานกับแปรง WPF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1127
การทำงานกับปากกา WPF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1130
การสำรวจประเภทที่ได้มาจากการวาด - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1130
บทบาทของการเปลี่ยนแปลง UI - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1135
ทำความเข้าใจกับบริการแอนิเมชันของ WPF - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1136
ทำความเข้าใจกับระบบทรัพยากร WPF - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1145
การกำหนดและการใช้สไตล์สำหรับการควบคุม WPF - - - - - - - - - - - - - - - - - - - - - - - - 1147
การเปลี่ยนแปลง UI ของการควบคุมโดยใช้เทมเพลต - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1156
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1160
ตอนที่ 7 การสร้างเว็บแอปพลิเคชันด้วย ASP.NET
บทที่ 31 การสร้างเว็บเพจ ASP.NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1163
บทบาทของ HTTP - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1163
ทำความเข้าใจกับเว็บแอปพลิเคชันและเว็บเซิร์ฟเวอร์ - - - - - - - - - - - - - - - - - - - - - 1164
บทบาทของ HTML - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1167
บทบาทของการเขียนสคริปต์ฝั่งไคลเอ็นต์ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1172
การส่งข้อมูลแบบฟอร์ม (GET และ POST) - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1174
การสร้างเพจ ASP แบบคลาสสิก - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1175
ปัญหากับ Classic ASP . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1177
เนมสเปซ ASP.NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1178
รูปแบบโค้ดเว็บเพจ ASP.NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1179
รายละเอียดโครงสร้างไดเรกทอรีเว็บไซต์ ASP.NET - - - - - - - - - - - - - - - - - - - - - 1190
วงจรการรวบรวมเพจ ASP.NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1192
ไม่มีเนื้อหา xiii
สายการสืบทอดของประเภทเพจ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1194
การโต้ตอบกับคำขอ HTTP ขาเข้า - - - - - - - - - - - - - - - - - - - - - - - - - - 1195
การโต้ตอบกับการตอบสนอง HTTP ขาออก - - - - - - - - - - - - - - - - - - - - - - - - - 1198
วงจรชีวิตของเว็บเพจ ASP.NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1200
บทบาทของไฟล์ Web.config - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1203
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1206
บทที่ 32 การควบคุมเว็บ ASP.NET ธีม และมาสเตอร์เพจ - - - - - - - - - - - 1207
ทำความเข้าใจกับธรรมชาติของการควบคุมเว็บ - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1207
ประเภท System.Web.UI.Control - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1209
ประเภท System.Web.UI.WebControls.WebControl - - - - - - - - - - - - - - - - - - - - - 1213
หมวดหมู่หลักของการควบคุมเว็บ ASP.NET - - - - - - - - - - - - - - - - - - - - - - - - - - - 1213
การสร้างเว็บไซต์ ASP.NET ที่มีคุณสมบัติหลากหลาย - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1215
บทบาทของการควบคุมการตรวจสอบ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1231
การทำงานกับธีม - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1237
การควบคุมตำแหน่งโดยใช้ตาราง HTML - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1243
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1244
บทที่ 33 เทคนิคการจัดการสถานะ ASP.NET - - - - - - - - - - - - - - - - - - - - - - 1245
ปัญหาของรัฐ. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1245
เทคนิคการจัดการสถานะ ASP.NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1247
การทำความเข้าใจบทบาทของสถานะมุมมอง ASP.NET - - - - - - - - - - - - - - - - - - - - - - - - 1248
บทบาทของไฟล์ Global.asax - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1251
ทำความเข้าใจเกี่ยวกับความแตกต่างของแอปพลิเคชัน/เซสชัน - - - - - - - - - - - - - - - - - - - - - 1254
การทำงานกับแคชของแอปพลิเคชัน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1259
การรักษาข้อมูลเซสชั่น - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1263
ทำความเข้าใจเกี่ยวกับคุกกี้ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1267
บทบาทขององค์ประกอบ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1269
ทำความเข้าใจเกี่ยวกับ ASP.NET Profile API - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1272
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1279
ส่วนที่ 8 nnn ภาคผนวก
nAPPENDIX ความสามารถในการทำงานร่วมกันของ COM และ .NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1283
ขอบเขตของการทำงานร่วมกันของ .NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1283
ตัวอย่างง่ายๆ ของ .NET กับ COM Interop - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1284
การตรวจสอบ .NET Interop Assembly - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1287
ทำความเข้าใจกับ Runtime Callable Wrapper - - - - - - - - - - - - - - - - - - - - - - - - - 1289
บทบาทของ COM IDL - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1292
การใช้ Type Library เพื่อสร้าง Interop Assembly - - - - - - - - - - - - - - - - - - - - - 1296
การสร้างเซิร์ฟเวอร์ COM ที่ซับซ้อนยิ่งขึ้น - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1299
การตรวจสอบสภา Interop - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1301
ทำความเข้าใจการทำงานร่วมกันระหว่าง COM กับ .NET - - - - - - - - - - - - - - - - - - - - - - - - - - - 1305
บทบาทของ กปปส. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1306
บทบาทของ .NET Class Interface - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1307
xiv nเนื้อหา
การสร้างประเภท .NET ของคุณ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1308
การสร้างไลบรารีประเภทและการลงทะเบียนประเภท .NET - - - - - - - - - - - - - 1310
การตรวจสอบข้อมูลประเภทที่ส่งออก - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1311
การสร้างไคลเอนต์ทดสอบ Visual Basic 6.0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1312
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1313
nAPPENDIX B การพัฒนา .NET ที่ไม่ขึ้นกับแพลตฟอร์มด้วย Mono - - - - - - - - - - 1315
ลักษณะที่ไม่ขึ้นกับแพลตฟอร์มของ .NET - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1315
การรับและติดตั้ง Mono . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1318
เครื่องมือพัฒนาโมโน - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1321
การสร้างแอปพลิเคชั่น .NET ด้วย Mono . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1323
ข้อเสนอแนะในการศึกษาต่อ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1330
สรุป . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1331
ดัชนี . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1333