“30 ลิขิตฟ้า 70 ต้องฝ่าฟัน” … ครับ  คำนี้เป็นจริงแน่แท้ ครับ เราเหล่าโปรแกรมเมอร์ เหมือน นักประพันธ์หนังสือ code ที่เราบรรจงเขียนก็เหมือนกับการเรียงร้อยถ้อยคำในหนังสือก็ไมปาน  ความสวยงามของ code คืองานที่ โปรแกรมสร้างสรรค์ มันออกมา  ฮา ๆ นี่เป็นสิ่งที่ ผมมีความภาคภูมิใจ  และอาจเป็นความไฝ่ฝันของคนรุ่นใหม่อีก มากมาย – แต่การก้าวมาเป็น มืออาชีพต้องอาศัยความพยายามอย่างยิ่ง และอาจต้องสูญเสียบางสิ่ง ไปอีกด้วย – ฮะ ฮะ นี่เป็นอารมณ์ ในบาง อารมณ์ นะครับ

เรื่อง ที่ผมจะพูดในตอนนี้เป้นเรื่อง ต่อจากบทความที่แล้ว ของผม ครับเป็นเรื่องของการส่งผ่านข้อมูลระหว่าง form โดยใช้ delegates เทคนิค นะครับเราได้แสดงกรณีศึกษาแรกไปแล้วเป็น การส่งข้อมูลจาก Main form หรือ Parent form ไปยัง  child form ซึ่งเป็น form ที่  ถูกสร้างขึ้นมาจาก  Main form …  

สำหรับ ในตอนนี้จะเป็นการ ส่งข้อมูลจาก child form กลับไปยัง Main form ครับ โดยเราได้กำหนด scenario ดังนี้ กรณีที่สอง windows forms (parent) ที่มี Listbox  จะทำการเปิด dialog form ซึ่ง มี Textbox และ ปุ่มสองปุ่ม คือ (Add item) และ (Close) เมื่อใดก็ตามที่ ผู้ใช้ Click Add button       item จะถูกเพิ่มเข้าไปที่ Listbox ใน parent form โดยไม่ต้องปิด dialog นี้    สำหรับปุ่ม close ใช้สำหรับการปิด Dialog …

สำหรับ scenario นี้เราจะทำการ สร้าง delegate ที่รับ Parameter เป็นข้อมูลชนิด string อีกเช่นเคย ซึ่งจะให้ชื่อว่า AdditemDelegate. ใน dialog ลูก เราจะทำการ declare  method ที่เป็นชนิด AddItemDelegate ส่วนที่ Mainform เราจะทำการ สร้าง callback function ไว้ เพื่อรับการทำงานของ delegate ครับ

 ซึ่งเราจะสร้าง form ขึ้นดังรูป นะครับ จะคล้าย ๆ บทความแรกที่เราเขียน มี Main form   frmchild1  และ frmchild2 ครับแต่คราวนี้เราจะทำการ ส่งข้อมูลจาก child form เข้าไปยัง listbox ใน Main from ดังรูป ครับ ต่อไปเรามาดู code กันนะครับ อันดับแรกเราจะทำการ ประกาศ delegate ไว้ ที่ใดก็ได้ ภายนอก class และ ต้องเป็น namespace เดียวกัน ครับ ใขตัวอย่างนี้เราจะประกาศไว้ใน  program.cs ดังนี้

...
 using System.Windows.Forms;
namespace WindowsApplication3
{
      public delegate void AddItemDelegate(string item);
      static class Program
     {
       ///
       /// The main entry point for the application.
      ///
       [STAThread]
        static void Main()
       {
          Application.EnableVisualStyles();
          Application.SetCompatibleTextRenderingDefault(false);
          Application.Run(new frmMain());
       }
    }
}

ส่วนต่อมา เป็นการประกาศ callbackmethod ของ AddItemDelegate ครับ เพื่อมีไว้สำหรับสร้าง trigger และส่ง ข้อมูลกลับไปนะครับ

...
using System.Windows.Forms;
namespace WindowsApplication3
{
    public partial class frmChild1 : Form
    {
        public frmChild1()
        {
            InitializeComponent();
        }

        private void frmChild1_Load(object sender, EventArgs e)
        {

        }
        public AddItemDelegate AddItemCallback;

        private void btnAdd_Click(object sender, EventArgs e)
        {
            AddItemCallback(txtMessage.Text);
        }

    }
}

และใน child 2 from ก็เช่นเดียวกันนะครับ เราประการ callback function ไว้ชื่อว่า “AddItemCallback”

...

using System.Windows.Forms;

namespace WindowsApplication3
{
    public partial class frmchild2 : Form
    {
        public frmchild2()
        {
            InitializeComponent();
        }

        private void frmchild2_Load(object sender, EventArgs e)
        {

        }
        public AddItemDelegate AddItemCallback;

        private void btnAdd_Click(object sender, EventArgs e)
        {
            AddItemCallback(txtMessage.Text);
        }
    }
}

จะเห็นว่าทั้งสอง form จะประกาศ callback fuction ไว้เพื่อเป็นการ trig ทำให้เกิด event ขึ้น ไปกระตุ้นให้ supscriber ใน Main form ทำงาน ซึ่งการทำงาน นี้ขะเกิดขึ้นโดยอัตโนมัติ นะครับ

สุดท้ายเรามาดู ที่ Main form นะครับ

...
using System.Windows.Forms;
namespace WindowsApplication3
{
    public partial class frmMain : Form
    {
        public frmMain()
        {
            InitializeComponent();
        }

        private void btnChild1_Click(object sender, EventArgs e)
        {
            frmChild1 mychild1 = new frmChild1();
            mychild1.AddItemCallback = new AddItemDelegate(this.AddItemCallbackFn);
            mychild1.Show();
        }

        private void btnChild2_Click(object sender, EventArgs e)
        {
            frmchild2 mychild2 = new frmchild2();
            mychild2.AddItemCallback = new AddItemDelegate(this.AddItemCallbackFn);
            mychild2.Show();
        }
        private void AddItemCallbackFn(string item)
        {
            listBox1.Items.Add(item);
        }
    }
}

ครับ จะเห็นว่าใน Main form นั้น ได้มีการ add supscriber ให้กับ callback function ของแต่ละ form นะครับ ที่ บรรทัด 17 และ 24 ซึ่ง function นี้จะถูกเรียกทำงาน เมื่อ  callback function ที่อยู่ใน child 1 หรือ child 2 form ถูกเรียกและส่ง ผ่าน parameter มาให้  ครับ นั่นก็เป็น ตัวแย่างที่แสดงให้เห็น วิธีการหนึ่งในการ ส่งผ่าน ข้อมูลระหว่าง form ในรูปแบบต่าง ๆ นะครับ หวังว่าจะเป็นประดยชน์ต่อ ท่านที่สนใจทั้งหลาย นะครับ

s_teerapong2000@yahoo.com ,  Senoir programmer – soft speed solution co,.Ltd

Deletegates เป็นคุณสมบัติที่น่าสนใจเป็นอย่างยิ่ง ของ .Net Framework  ซึ่งเราทราบกันว่า หน้าที่การใช้งานหลักของมัน คือการสนับสนุนการทำงานของ event handling และ กลไกของการทำ callback. ในบทความนี้เราจะศึกษาวิธีการ ใช้งาน callback ของ deletegate เพื่อใช้สำหรับการสื่อสารระหว่าง windows forms

กรณีตัวอย่าง

การเขียนโปรแกรม ในหลาย ๆ กรณี เราใช้ windows form เปิด windows form อื่น ๆ   windows form ที่ถูกสร้าง และ windows form  ที่เป็นผู้สร้าง อาจจะต้องมี การส่งข้อมูลระหว่างกัน เช่น เราเลือกรายการใน combobox ใน windows form ที่ถูกสร้าง เราอาจต้องการ ส่งข้อมูลที่เลือกนี้ไปยัง form แม่ หรือ เรามีการเปลี่ยนแปลงข้อมูลใน form แม่ และต้องการส่ง การเปลี่ยนแปลงนี้ไปยัง form ลูกเป็นต้น  เหตุการณ์ ตัวอย่างที่กล่าว นั้น เรามารถทำได้ ด้วย deletegate ในรูปแบบ callbacks.

กรณีศึกษา  เราจะทำการศึกษา ผ่าน 2 กรณี ดังนี้

• กรณีแรก Windows form (parent) ที่สามารถเปิด windows form อื่น ๆ (children)  โดยที่ parent form มี Textbox เมื่อใดก็ตามที่ข้อมูลใน Textbox เปลี่ยน จะส่งการเปลี่ยนแปลงไปยัง children forms และแสดงผล
• กรณีที่สอง windows forms (parent) ที่มี Listbox  จะทำการเปิด dialog form ซึ่ง มี Textbox และ ปุ่มสองปุ่ม คือ (Add item) และ (Close) เมื่อใดก็ตามที่ ผู้ใช้ Click Add button       item จะถูกเพิ่มเข้าไปที่ Listbox ใน parent form โดยไม่ต้องปิด dialog นี้    สำหรับปุ่ม close ใช้สำหรับการปิด Dialog …

บางท่านบอกว่า ไม่เห็นยากเลย เราก็ทำให้ control เป็น public ซะสิ อืม ก็ได้แต่ว่า มันไม่ใช่ นะครับ เราควรจะรักษา control ให้เป็น private และใช้ delegates แทน ครับ

เรามาดูกันที่ กรณีแรกกันก่อนนะครับ เราจะทำการสร้าง Form ดังต่อไปนี้นะครับ ผม อนุมานเอาว่า ผู้ที่ติดตามอ่าน รู้เรื่อง form และ controls ดีนะครับ

 จะเห็นว่าเราสร้าง Form ขึ้นมาทั้งหมด 3  forms ด้วยกันนะครับ ซึ่งก็ประกอบด้วย Main form   frmChild1  และ frmChild2  ใน Main form นั้นจะเห็นว่ามี button ที่ใช้ click เพื่อสร้าง form ลูก   2 ปุ่ม คือ Open child 1 และ Open Child 2

นอกจากนั้น Main from ยังมี Textbox เพื่อให้สามารถใส่ข้อมูลอะไรบ้างอย่างลงไปได้ (ใช้สำหรับการส่งข้อมูลไปยัง form ลูกครับ )

ส่วนที่ form ลูก ทั้งสอง forms นั้นมีลักษณะเหมือนกันคือ มี TextBox เพื่อไว้แสดงข้อมูล นะครับ

ความคาดหมายของ โปรแกรมทดสอบนี้ ก็คือเมื่อเรา Run โปรแกรมขึ้นมาเราจะได้ Main form เมื่อ Click ไปที่ ปุ่ม “Open Child 1″  หรือ “Open Child 2″  form ลูก จะถูกสร้างขึ้น ตามที่ปุ้มคลิก เมื่อเรา ใส่ข้อมูลลงใน Textbox ของ Main form ข้อความที่ใส่ลงไปนั้นจะ ถูกส่งไปแสดงที่ form ลูกทั้งสอง พร้อม ๆ กันเลย ครับ 

ดังนั้นเราก็มาดู ที่ code กันนะครับ

Listing-01 : Main function …

...

using System.Text;

using System.Windows.Forms;

namespace WindowsApplication2

{

   public delegate void SetParameterValueDelegate(string value);

   public partial class frmMain : Form

  {

      public frmMain()

     {

       InitializeComponent();

      }

       public SetParameterValueDelegate SetParameterValueCallBack;

       private void btnOpenchild1_Click(object sender, EventArgs e)

       {

           frmChild1 frm1 = new frmChild1();

           this.SetParameterValueCallBack += new SetParameterValueDelegate(frm1.SetParamValueCallBackFn);

           frm1.Show();

        }  

        private void txtMessageBox_TextChanged(object sender, EventArgs e)

        {

           SetParameterValueCallBack(txtMessageBox.Text);

         }

         private void btnOpenchild2_Click(object sender, EventArgs e)

        {

            frmChild2 frm2 = new frmChild2();

            this.SetParameterValueCallBack += new SetParameterValueDelegate(frm2.SetParamValueCallBackFn);

           frm2.Show();

        }

     }

}

ใน Mian form นี่ เรา declare delegate  ไว้ นะครับ ในบรรทัดที่ 7  และต่อมาในบรรทัดที่ 15 เราก็ทำการ ประกาศ function ที่เราจะใช้ trig หรือ ส่งสัญญาณไปยัง subscrib ที่อยู่ใน form  Child 1 และ Child 2 ครับ  

หลังจากนั้น ใน event Click ของ ปุ่มทั้งสองเรา จะทำการสร้าง form Child 1 , Child 2 เราจะเห็นว่า จะมี การ subscrib ไว้ในแต่ละ form ว่าหากมีการ trig จาก Main form ขึ้นมาจะเรียก function อะไร ในแต่ละ form ครับ ในบรรทัดที่ 20 และ 32 นะครับจะเห็น ว่าแต่ละ form นั้นกำหนดไว้ว่า หากมีการ trig เกิดขึ้นที่ Main form จะเรียก function ชื่อว่า “SetParamValueCallBackFn เหมือนกันเลย นะครับ อันที่จริงเราไม่ต้องให้เหมือนกันก็ได้นะครับ

และสุดท้านที่สำคัญก็คือ trigger ที่จะทำให้ เกิดการทำงานขึ้นนั้นเราใส่ไว้ใน event ของ TextBox ชื่อว่า TextChange นะครับ เมื่อใดก็ตามที่ ผู้ใช้พิมพ์ ข้อความลงไปในช่องนี้ ก็จะไปปรากฎที่  form ลูกทั้งสองด้วย  บรรทัดที่ 26

ต่อไปมาดู code ของ form ลูกทั้งสองเลยนะครับ

[frmChild1]

......
using System.Text;
using System.Windows.Forms;
namespace WindowsApplication2
{
    public partial class frmChild1 : Form
   {
        public frmChild1()
       {
          InitializeComponent();
       }
       public void SetParamValueCallBackFn(string value)
      {
          txtMessageBox.Text = value;
      }
   }
}

[frmChild2]

using System.Text;
using System.Windows.Forms;
namespace WindowsApplication2
{
     public partial class frmChild2 : Form
    {
         public frmChild2()
        {
           InitializeComponent();
        }
        public void SetParamValueCallBackFn(string value)
       {
           txtMessageBox.Text = value;
       }
    }
}

ครับ สำหรับ code ของ form ลูกทั้งสอง นั้นก็ implement function ที่ชื่อว่า SetParamValueCallBackFn(string value) ไว้เพื่อให้เมื่อมีการ trig เกิดขึ้นที่ Main form ก็จะทำให้ function ที่ได้มีการ subscrib ไว้ทำงาน ซึ่งก็คือ function ที่กล่าวมานั่นเอง ครับ ก็เป็นอันว่า การทำงาน สมบูรณ์ นะครับ ถ้ายังไม่เข้าใจ ขอให้ทำตามตัวอย่าง ให้ครบแล้วลอง Run ดูนะครับ

สำหรับ กรณีศึกษาที่สอง ขอไว้เป็นตอนที่สองก็แล้วกันนะครับ

หากยังไม่เข้าใจเรื่องของ delegate นะครับ ก็ขอให้ไปอ่าน ทำความเข้าใจ ก่อนนะครับ ตาม link นี้

 Delegates and Event ตอนที่ 1
 Delegates and Event ตอนที่ 2
 Delegates and Event ตอนที่ 3

s_teerapong2000@yahoo.com

Class ต่าง ๆ เป็น Reference type  หมายถึง ตัวแปรของ Obeject ของ Class นั้น ไม่ได้อ้างอิงไปยัง Object โดยตรง แต่ชี้ไปยังที่ตำแหน่งใน Address ของ Object แทน ซึ่งทำให้เราสามารถใช้งาน Object ในรูปแบบพิเศษได้มากมาย  Delegates ก็เป็นตัวแปรอีกชนิดหนึ่งที่เป็นลักษณะ Reference type  Deletgates นั้น สามารถที่จะชี้ไปยัง Method หรือ Reference ไปยัง Method ได้ในขณะ runtime  นั่นก็หมายถึงเราสามารถ ที่จะเลือกได้ว่า เราจะ สั่ง Method ไหนทำงานก็ได้ ในขณะ runtime  ขึ้นอยู่กับ ความต้องการในขณะนั้น

ในส่วนนี้ผมจะพูดถึงเรื่อง การสร้าง Deletgates การทำ multicast delegates และ วิธีการใช้ event กับ delegates

Deletgates เป็นตัวแปร แบบ Reference type สามารถที่จะอ้างอิงไปยัง method ใด ๆ ก็ได้  delegate ใน C# คล้ายกับ function pointer ใน C++   เพื่อให้เกิดความเข้าใจ พิจารณาจาก code ต่อไปนี้

// Delegate declaration
public delegate void MyDelegate(string ArgValue);
public void DelegateFunction(string PassValue)
{
  // Method implement here
}
public void UseMethod()
{
   // Delegate Instantiation
   MyDelegate DelegateObject = new MyDelegate(DelegateFunction);
}

จาก code ด้านบน บรรทัดแรกคือการประกาศ delegate สังเกตุรูปแบบของการประกาศเป็นไปตาม syntax นี้
delegate <return type> <delegate-name> <parameter list>
จาก code ตัวอย่าง delegate ชื่อ MyDelegate ไม่ return ค่าและมี parameter 1 ตัวคือ PassValue ซึ่งมีชนิดเป็น string สำหรับ function ที่เราจะทำ delegate ก็จะต้อง มีการกำหนด signature ให้ตรงกับ delegate ที่ประกาศไว้ จากตัวอย่าง คือ function ถัดมา ชื่อว่า DelegateFunction ซึ่งได้มีการประกาศ signature ไว้ตรงกับ delegate ด้านบนทุกประการ หลังจากนั้น การใช้งานเราจำทำการ instantiate Delegate object คล้ายกับการ Instantiat object ของ Class  เพียงแต่ว่า นี้เป็น object ที่เป็นdelegate โดยจะส่งชื่อ function ที่ต้องการเป็น Parameter  ของ delegate constructure

Mydelegate DelegatObject = new MyDelegate(DelegateFunction);

หลังจากนั้น การใช้งานเราสามารถที่จะเรียก DelegateObject แทนชื่อ function ได้เลยและเป็นลักษณะ reference สามารถที่จะส่งผ่าน DelegateObject เป็น argument ของfunctionใด ๆ ที่ต้องการใช้ function เป็น parameter ได้เลย ซึ่งจะได้เห็นการใช้งานในรูปแบบต่าง ๆต่อไป

การใช้งาน Delegate
เพื่อให้เห็น ภาพมากขึ้นจะขอยกตัวอย่างการเรียกใช้ function ปกติขึ้นมาพิจารณาเพื่อนำไปสู่การใช้งาน ขอให้พิจารณาจากตัวอย่างนี้นะครับ

namespace MyNameSpace.NoDelegate
{
   public class MyClass
  {
       public void Process()
      {
        Console.WriteLine(“Process() begin”);
        Console.WriteLine(“Process() end”);
      }
  }
  public class Test
 {
    static void Main(string[] args)
     {
        MyClass myClass = new MyClass();
        myClass.Process();
      }
   }
}

จาก ตัวอย่าง เป็นการใช้งานทั่วไปสำหรับการเรียกใช้ function สมมุติว่าถ้าหากเราไม่ต้องการเรียกใช้ function ตรง ๆ หล่ะหากเราต้องการที่จะส่งผ่าน function นี้ให้กับ function อื่นเรียกใช้อีกที โดยเฉพาะการทำงานในลักษณะ event-driven เรามาดูการ ใช้ delegate จากตัวอย่างเดียวกัน

Very basic delegate

namespace ConsoleApplication1
{
   public class MyClass
  {
     public delegate void WriteHandler(string message);
     public void Process(WriteHandler writeh)
     {
        writeh(“Process() begin”);
        writeh(“Process() end”);
     }
     public void writer(string message)
    {
        Console.WriteLine(message);
     }
  }
  public class Program
 {
    static void Main(string[] args)
    {
      MyClass myclass = new MyClass();
      MyClass.WriteHandler writehander = new MyClass.WriteHandler(myclass.writer);
      myclass.Process(writehander);
     }
  }
}

ผลของการ ทำงาน จะได้เช่นเดียวกับโปรแกรมแรกนะครับ แต่โปรแกรมนี้เราใช้คุณลักษณะของ delegate พิจารณา class Myclass จะเห็นว่ามีการ ประกาศ Delegate ชื่อ ว่า WriteHandler มี parameter 1 ตัวคือ message และไม่มีการ return ค่าดังนั้น function ที่เราต้องการทำ delegation คือ writer สังเกตุว่า มี signature เหมือนกัน

หลังจากนั้น เราต้องการส่งผ่านฟังก์ชันนี้เขาไปทำงานใน method ชื่อ Process นะครับ สังเกตุว่า Parameter ของ Process นั้นเป็นชนิดเดียวกับ delegate

แล้วสุดท้ายเรามาดูที่ class program ที่ Main เราจะเห็นว่า จะมีการ instantiate delegate object ชื่อ writehander แล้วส่ง method ชื่อ writer เป็น argument ผลก็คือได้ writerhandler ที่อ้างอิงไปยัง writer เราก็โยน writerhandler เข้าไปให้ Process เป็นการส่งผ่าน parameter แบบ reference นะครับ จะเห็นว่าการทำงานครั้งนี้ เราส่งผ่าน function หรือ method เป็น parameter นะครับ นี่แหละการทำงานของ delegate ครับ จะเห็นว่าการทำงานของ delegate นั้นมีขั้นตอนดังนี้นะครับ

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

using System;

namespace Mynamespace.BasicDelegate
{
  // #1 Declaration
  public delegate void SimpleDelegate();

  class TestDelegate
  {
    public static void MyFunc()
    {
      Console.WriteLine(“I was called by delegate …”);
    }
   public static void Main()
   {
     // #2 Instantiation
     SimpleDelegate simpleDelegate = new SimpleDelegate(MyFunc);
     // #3 Invocation
     simpleDelegate();
   }
  }
}

เป็นงั้ยครับ พอจะได้ concept ใหม่ครับ ลอง run code ดูนะครับแล้วจะเข้าใจ สำหรับ delegate ขอพอแค่นี้ก่อนนะครับ

ขอให้ติดตาม ในตอน ต่อ ๆไปนะครับเนื่องจากมีการใช้งานอีก หลายลักษณะ  ขอให้มีความสุขกับการเรียนรู้นะครับ