Archive

Archive for the ‘C# .NET’ Category

NEWS: Procyon 800E Phase 2 Beta Testing Begins

Categories: C# .NET

ปัญหา The search key was not found in any record. ในไฟล์ .dbf หรือ dBase

หลังจากประสบปัญหากับการอ่าน File dBase โดยใช้ Jet Engine 4.0 ไม่ได้ เกิด Error Message “The search key was not found in any record.” in dBase ?  ในที่สุดก็พบวิธิการแก้ปัญหาแบบ จบเรื่องเลย สำหรับเพื่อนนักพัฒนา ที่มีปัญหาแบบเดียวกันลองทำดูนะครับ

ให้ทำตามขั้นตอน ดังนี้
1. ให้ใช้ Regedit เพื่อที่จะแก้ไข Registry key
Registry key: \HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Jet\4.0\Eng ines\Xbase
2.ที่ Panel ด้านขวาให้หา Deleted
3. แล้วคลิกขวาที่  Deleted  แล้วจึงเลือก Modify.
4. ให้เปลี่ยนค่า จาก 0000 01 ไปเป็น 0000 00
5. คลิก OK.
6. ปิด Regedit แล้วกลับไปลองใหม่นะครับ รับลองว่าจะได้อย่างไม่น่าเชื่อ

🙂

Categories: C# .NET

Watch “นารีผล” on YouTube

Categories: C# .NET

งาน UAV Community “Unmanned Unlimited” 2014

Categories: C# .NET, game development Tags:

เขียนโปรแกรมอย่างไรให้เป็น Thread-safe [ Writing Thread safe code in C# ]

 การเขียน multithreading  เพื่อเพิ่มประสิทธิภาพการทำงานให้กับ windows app ต้องระวังเรื่องการเรียกหรือทำงานกับ controls   ซึ่งจะต้องตระหนักเรื่อง thread-safe

การเข้าถึง windows forms controls จะไม่เป็น thread-safe ถ้าหาก มี thread  2 threads หรือ มากกว่า เข้าไปเรียกใช้ controls นั้น เพราะมันอาจทำให้ controls นั้น ทำงานหรือแสดงผล ไม่เป็นไปตามที่ คาดหมายไว้ หรือ ที่เรียกว่า inconsistent state  ผลก็คือ ทำให้ thread ที่เข้าใช้งาน ได้ผลลัพธ์ที่ไม่ถูกต้อง  ทำให้เกิด race conditions และ deadlocks  ดังนั้น เราจะต้องมั่นใจว่า การเข้าถึง control นั้นทำในวิธีที่ ปลอดภัย หรือ thread-safe

ใน .NET Framework จะช่วยให้แจ้งเราทราบ หากมีการเข้าถึง control ในลักษณะนี้  โดยแจ้งให้ทราบขณะที่เรา  debug โปรแกรม  หรือ เรา run โปรแกรมใน debug mode  เป็น message ว่า InvalidOperationException แล้วแจ้งชื่อ control name ที่ มีการเข้าถึงจาก thread อื่น ที่ไม่ใช่ thread ที่สร้าง control ที่เกิดปัญหานั้น

ตัวอย่างต่อไป จะเป็นการแสดงให้เห็นถึงการเรียก windows forms controls  ในลักษณะที่ เป็น thread-safe และไม่เป็น thread-safe   โดยยกตัวอย่าง การ กำหนดค่า Text property ให้กับ TextBox  เพื่อแสดงให้เห็นใน สองวิธีการ ตาม code ด้านล่าง

**code ทั้งหมดอ้างอิงจาก msdn.microsoft.com

using System;
using System.ComponentModel;
using System.Threading;
using System.Windows.Forms;

namespace CrossThreadDemo
{
	public class Form1 : Form
	{
		// This delegate enables asynchronous calls for setting
		// the text property on a TextBox control.
		delegate void SetTextCallback(string text);

		// This thread is used to demonstrate both thread-safe and
		// unsafe ways to call a Windows Forms control.
		private Thread demoThread = null;

		// This BackgroundWorker is used to demonstrate the
		// preferred way of performing asynchronous operations.
		private BackgroundWorker backgroundWorker1;

		private TextBox textBox1;
		private Button setTextUnsafeBtn;
		private Button setTextSafeBtn;
		private Button setTextBackgroundWorkerBtn;

		private System.ComponentModel.IContainer components = null;

		public Form1()
		{
			InitializeComponent();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing && (components != null))
			{
				components.Dispose();
			}
			base.Dispose(disposing);
		}

		// This event handler creates a thread that calls a
		// Windows Forms control in an unsafe way.
		private void setTextUnsafeBtn_Click(
			object sender,
			EventArgs e)
		{
			this.demoThread =
				new Thread(new ThreadStart(this.ThreadProcUnsafe));

			this.demoThread.Start();
		}

		// This method is executed on the worker thread and makes
		// an unsafe call on the TextBox control.
		private void ThreadProcUnsafe()
		{
			this.textBox1.Text = "This text was set unsafely.";
		}

		// This event handler creates a thread that calls a
		// Windows Forms control in a thread-safe way.
		private void setTextSafeBtn_Click(
			object sender,
			EventArgs e)
		{
			this.demoThread =
				new Thread(new ThreadStart(this.ThreadProcSafe));

			this.demoThread.Start();
		}

		// This method is executed on the worker thread and makes
		// a thread-safe call on the TextBox control.
		private void ThreadProcSafe()
		{
			this.SetText("This text was set safely.");
		}

		// This method demonstrates a pattern for making thread-safe
		// calls on a Windows Forms control.
		//
		// If the calling thread is different from the thread that
		// created the TextBox control, this method creates a
		// SetTextCallback and calls itself asynchronously using the
		// Invoke method.
		//
		// If the calling thread is the same as the thread that created
		// the TextBox control, the Text property is set directly.

		private void SetText(string text)
		{
			// InvokeRequired required compares the thread ID of the
			// calling thread to the thread ID of the creating thread.
			// If these threads are different, it returns true.
			if (this.textBox1.InvokeRequired)
			{
				SetTextCallback d = new SetTextCallback(SetText);
				this.Invoke(d, new object[] { text });
			}
			else
			{
				this.textBox1.Text = text;
			}
		}

		// This event handler starts the form's
		// BackgroundWorker by calling RunWorkerAsync.
		//
		// The Text property of the TextBox control is set
		// when the BackgroundWorker raises the RunWorkerCompleted
		// event.
		private void setTextBackgroundWorkerBtn_Click(
			object sender,
			EventArgs e)
		{
			this.backgroundWorker1.RunWorkerAsync();
		}

		// This event handler sets the Text property of the TextBox
		// control. It is called on the thread that created the
		// TextBox control, so the call is thread-safe.
		//
		// BackgroundWorker is the preferred way to perform asynchronous
		// operations.

		private void backgroundWorker1_RunWorkerCompleted(
			object sender,
			RunWorkerCompletedEventArgs e)
		{
			this.textBox1.Text =
				"This text was set safely by BackgroundWorker.";
		}

		#region Windows Form Designer generated code

		private void InitializeComponent()
		{
			this.textBox1 = new System.Windows.Forms.TextBox();
			this.setTextUnsafeBtn = new System.Windows.Forms.Button();
			this.setTextSafeBtn = new System.Windows.Forms.Button();
			this.setTextBackgroundWorkerBtn = new System.Windows.Forms.Button();
			this.backgroundWorker1 = new System.ComponentModel.BackgroundWorker();
			this.SuspendLayout();
			//
			// textBox1
			//
			this.textBox1.Location = new System.Drawing.Point(12, 12);
			this.textBox1.Name = "textBox1";
			this.textBox1.Size = new System.Drawing.Size(240, 20);
			this.textBox1.TabIndex = 0;
			//
			// setTextUnsafeBtn
			//
			this.setTextUnsafeBtn.Location = new System.Drawing.Point(15, 55);
			this.setTextUnsafeBtn.Name = "setTextUnsafeBtn";
			this.setTextUnsafeBtn.TabIndex = 1;
			this.setTextUnsafeBtn.Text = "Unsafe Call";
			this.setTextUnsafeBtn.Click += new System.EventHandler(this.setTextUnsafeBtn_Click);
			//
			// setTextSafeBtn
			//
			this.setTextSafeBtn.Location = new System.Drawing.Point(96, 55);
			this.setTextSafeBtn.Name = "setTextSafeBtn";
			this.setTextSafeBtn.TabIndex = 2;
			this.setTextSafeBtn.Text = "Safe Call";
			this.setTextSafeBtn.Click += new System.EventHandler(this.setTextSafeBtn_Click);
			//
			// setTextBackgroundWorkerBtn
			//
			this.setTextBackgroundWorkerBtn.Location = new System.Drawing.Point(177, 55);
			this.setTextBackgroundWorkerBtn.Name = "setTextBackgroundWorkerBtn";
			this.setTextBackgroundWorkerBtn.TabIndex = 3;
			this.setTextBackgroundWorkerBtn.Text = "Safe BW Call";
			this.setTextBackgroundWorkerBtn.Click += new System.EventHandler(this.setTextBackgroundWorkerBtn_Click);
			//
			// backgroundWorker1
			//
			this.backgroundWorker1.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(this.backgroundWorker1_RunWorkerCompleted);
			//
			// Form1
			//
			this.ClientSize = new System.Drawing.Size(268, 96);
			this.Controls.Add(this.setTextBackgroundWorkerBtn);
			this.Controls.Add(this.setTextSafeBtn);
			this.Controls.Add(this.setTextUnsafeBtn);
			this.Controls.Add(this.textBox1);
			this.Name = "Form1";
			this.Text = "Form1";
			this.ResumeLayout(false);
			this.PerformLayout();

		}

		#endregion

		[STAThread]
		static void Main()
		{
			Application.EnableVisualStyles();
			Application.Run(new Form1());
		}

	}
}

จาก code จะเห็นว่ามีการแสดงตัวอย่างการใช้งาน Thread 2 วิธีคือ
1. private Thread demoThread = null; // ใช้ class thread เป็น worker thread
2. private BackgroundWorker backgroundWorker1; // เป็น component ที่ทำงานบน windows form

ซึ่งการ ใช้ class thread นั้นเป็นการสร้าง thread ลูกของ windows form ขึ้นมาอีก 1 thread ซึ่ง worker thread ของ class นี้ จะเกิดสร้างปัญหา
เมื่อต้องเขเาไปเรียกใช้ component ที่วางอยู่บน form ในกรณีนี้คือ TextBox1 เหตุการแบบนี้เรียกว่า ไม่เป็น thread-safe ดังนั้นการเข้าถึงต้องมีวิธีการ เข้าถึงโดยการตรวจสอบ
InvokeRequired ของ textBox1 และ ดำเนินการเข้าถึง แตกแต่างกัน
– ถ้า InvokeRequired = true ให้เข้าถึงโดยใช้ delegate object ผ่าน thread หลักก็คือ Windows form (InVoke)
– ถ้า InvokeRequired = false ให้เข้าถึงได้โดยตรง
ตาม code ที่ตัมานะครับ

private void SetText(string text)
 {
     // InvokeRequired required compares the thread ID of the
     // calling thread to the thread ID of the creating thread.
     // If these threads are different, it returns true.
    if (this.textBox1.InvokeRequired)
    {
        SetTextCallback d = new SetTextCallback(SetText);
        this.Invoke(d, new object[] { text });
    }
     else
    {
       this.textBox1.Text = text;
    }
 }

ส่วนถ้าเราใช้ background worker ในการทำ multithreading เราก็สามารถเขาถึงได้โดยตรง ผ่าน event run ProgressChanged และ RunWorker conmpleted

ครับ เป็นอันว่าพอสมควรแก่ ประเด็นแล้วนะครับ เพื่อน ๆ ที่เคยเจอปัญหานี้คงพอเข้าใจแล้วนะครับ ขอให้สนุกสนานกับการเขียนโปรแกรม นะครับ

Categories: C# .NET

Learn

ํYou ‘ll never be brave if you don’t get hurt
You ‘ll never learn if you don’t make mistake
You ‘ll never be successful if you don’t encounter failure….
– – so
Failure is Success… if you learn from it.

Categories: C# .NET

การใช้งาน Deletgate เบื้องต้น

ครับ delegate น่าจะเป็นประเด็นที่ค่อนข้าง จะสับสน กับ นักพัฒนามือหัดขับ หลาย ๆ ท่าน ( ผมด้วย ) ในบทความนี้ จะพูดถึงการใช้งานแบบ พื้นฐานของ delegate เพื่อ พื้นที่สำคัญก้าวต่อไปของ การใช้ delegate ใน C# .net

Image
Delegate เป็น base type ตัวหนึ่งใน .NET  ซึ่งมันเป็น class สำหรับการสร้างและใช้ delegate ในขณะ runtime ครับอย่างที่ทราบกันนะครับโดย พื้นฐานแล้ว Delegate คล้ายกับ Function Pointer ใน C++   ซึ่งใช้ในการอ้างอิง method ต่างกันก็ตรงที่  delegate นั้น method ที่จะใช้อ้างอิง ต้องมี หน้าตาเหมือนกับ delegate type ที่ประกาศไว้ หน้าตาเหมือน ก็คือ มี return type และ parameters เหมือน กัน
มีการให้ข้อมูลเรื่องการใช้งาน delegate มากมาย แต่คำถามที่เกิดขึ้นในใจ เพื่อน ๆ ก็คือ  การใช้งาน เราจะใช้งานมันเมื่อไร หรือ ความจำเป็นอะไร ที่จะทำให้เราต้องเอา delegate มาแก้ปัญหา หล่ะ แน่นอนครับ มันต้องมีสิครับ ก็คือว่า ในการพัฒนา Application อาจมีบางครั้งหรือบางเหตุการณ์ที่เราอาจ ต้องแก้ปัญหาด้วยการ ส่งผ่าน method ไปให้ กับ method ตัวอื่น เพื่อใช้งาน ( method , function , procedure คืออันเดียวกันนะครับ)    ดังนั้นเราก็สามารถใช้ delegate ในการจัดการกับปัญหานี้ได้

เพื่อให้เห็นภาพ วิธีที่ดีก็คือ ดูจากตัวอย่างครับ  ตัวอย่างนี้ยืมมาจาก นี่ครับ http://msdn.microsoft.com/en-us/library/900fyy8e%28v=vs.71%29.aspx

จากภาพ ในขั้นตอนแรก ก็คือการ ประกาศ delegate ชื่อว่า MyDelegate มี parameter   ตัว คือ  I เป็น integer และ ไม่มี return type คือ กำหนดให้เป็น void
ต่อไป เป็นการ สร้าง function ชื่อว่า DelegateFunction ซึ่งเป็น ฟังก์ชันที่จะให้ delegate object มาใช้ หรือชี้มาที่ function นี้  จะเห็น ว่า มี parameter และ return type เหมือน กับ delegate ที่ประกาศไว้ นะครับ
ต่อไปเป็นการนำไปใช้ ในขั้นตอนที่ 3 เราส่งผ่าน delegate ให้กับ TaskADelegate fucion โดยผ่านเป็น parameter type เป็น delegate ที่ประกาศไว้
และสุดท้าย TaskADelegate function ก็ถูกเรียกใช้ใน public static void Main()   จากคำสั่งนี้  TaskADelegate(new MyDelegate(DelegateFuction));

จากคำสั่งที่เห็น รวบรัดไปหน่อยสำหรับ มือใหม่ ขอแตกออกเป็น 2 คำสั่งดังนีครับ
MyDelegate  delCall = new MyDelegate(DelegateFunction);
TaskADelegate(delCall);

จะเห็นว่าเหมือนการสร้าง object นะครับ  delCall เป็น object ของ MyDelegate และ ชี้ไปที่ DelegatFunction  แล้วก็ส่งผ่านไปให้ function TaskADelegate เรียกใช้ งานอีกที หรือ จะเรียก delCall( ตัวเลขใด ๆ ) เหมือนเรียกใช้ function เลยก็ได้ แล้วแต่การใช้งานครับ
ตัวอย่าง ง่าย ๆ ที่แสดงถึงการใช้ประโยชน์ Delegate คือ การที่ 2 delegate นำมา combine กันได้ หรือมารวมกันได้ โดยใช้ operator + หรือ –  

รูปนำมาจาก http://msdn.microsoft.com/en-us/library/900fyy8e%28v=vs.71%29.aspx

1 จากรูปตัวอย่าง เราประกาศ delegate ชื่อว่า myDelegate มี parameter ชนิด string  และไม่มี return type
2 ใน class ประกาศ method ที่มี signature เดียวกับ delegate มี 2 function คือ Hello และ Goodbye ทั้งสอง พิมพ์ ตัวอักษร ออกหน้าจอ ว่า Hello, “xxx” และ Good bye , “xxx” ตามลำดับ
3 หลังจากนั้นใน function main เราประกาศ ตัวแปร delegate  a,b,c,d
–    ให้ a point ไป Hello
–    ให้  b pointไป Goodbye
–    และ c = a + b;
–    และ d = c – a;
ผลการ run จะเห็นว่า เมื่อสั่ง c(); จะมี  การทำงาน ของ a() ต่อด้วย b()
เช่นเดียวกันกับ d() จะมีแค่ การทำงานของ b() เนื่องจาก ได้ลบ การทำงาน ของ a() ไปแล้ว
สรุปก็คือ instance ของ delegate สามารถนำมา บวกและ ลบกันได้ โดยที่บวก เป็นการเอา function มาทำงานต่อกัน และ – เป็นลบส่วนการทำงานของ function ที่ลบออกไป ครับ  เราอาจใช้
c += a; ก็ได้นะครับ นั่นเป็นวิธีการใช้ delegate แบบพื้น นะครับ ในบทความถัดไป จะพูดถึงการใช้งาน ขั้นสูงขึ้นต่อไปนะครับ s_teerapong2000@yahoo.com

Categories: C# .NET