Delphi VS C# ทำ Multiple Inheritance สร้างคลาสเทพๆ (ตอนที่ 1)

ในการเขียนโปรแกรมโดยใช้หลักการเชิงวัตถุ (OOP) นั้น โปรแกรมที่เราสร้างขี้นก็จะประกอบด้วย Class และ Object มากมาย สิ่งที่สำคัญที่ช่วยให้การเขียนโปรแกรมเป็นไปในแนวทาง OOP อย่างมืออาชีพก็คือ การเล่นกับ Class ไม่ว่าจะเป็นการ Inheritance  การใช้ Abstract และ Interface เพื่อนำไปสู่การทำ Multiple Inheritance

ผู้เขียนขอแปลไทยเป็นไทย ด้วยภาษาพูดบ้านๆ เพื่อให้ความหมายของสิ่งต่างๆ ที่จะทดสอบกันในตอนนี้ คือ

• Inheritance คือการสืบทอด นั่นหมายความว่าเมื่อสืบทอดมาแล้วจะได้รับมรดกจากผู้ให้ อาจจะได้มาทั้งหมด หรือได้มาบางส่วนก็ได้
• Interface คือไทป์ที่มีรูปแบบเหมือนๆกับคลาส แต่ใช้งานไม่เหมือนกัน เพราะ Interface จะมีแต่การระบุเพียงการประกาศของ method เอาไว้ เพื่อที่ว่าเมื่อสืบทอดจาก Interface แล้ว จะต้องเอา method ที่ประกาศเหล่านี้ไป implement ต่อด้วย
• Abstract คล้ายกับ Interface แต่ถ้า Abstract ใช้กับ Class หมายความเสมือนว่า คลาสนั้นยังสร้างไม่สมบูรณ์ มีทั้งการที่ประกาศ$52;ว้เฉยๆเหมือน Interface ก็ได้ หรือจะ implement method ขึ้นมาใช้งานเลยก็ได้ จึงมีความยืดหยุ่นกว่า Interface มาก

ผู้เขียนจะทำการเพิ่มประสิทธิภาพของคลาสด้วยการใช้งานทั้ง Inheritance Interface และ Abstract ทำ Multiple Inheritance ผลที่ได้ก็คือ คลาสที่มีความสามารถมากมาย ซึ่งท่านผู้อ่านอาจจะนำไปประยุคใช้เขียนเป็น base class libraly หรือการเขียน Component ขึ้นมาเองก็ได้

ผู้เขียนจะนำเสนอ 2 ภาษา ภาษานึงคือภาษาที่เก่ง และเกิดมาเพื่อสิ่งนี้อยู่แล้วคือ C# ส่วนภาษาที่สอง อาจจะไม่ได้เกิดมาพร้อมกับการใช้ OOP ล้วนๆ แต่ก็สามารถทำได้เช่นกันคือ Delphi

ตัวอย่าง Interface ของ C#

     interface Imyinterface
    {
        void myMethod1();
        int myMethod2(int param);
    }

ตัวอย่าง Interface ของ Delphi

  IMyInterface = interface
     procedure MyMethod1;
     function MyMethod2(param: Integer): Integer;
  end;



Interface ในทั้งสองภาษานี้นำไปใช้งานในจุดประสงค์เดียวกัน และแทบจะเขียนเหมือนกันต่างกันเพียงแค่ Syntax เท่านั้น

ตัวอย่าง abstract class ของ C#

    abstract class myAbstract
    {
        public void Hello()
        {
            MessageBox.Show("Hello World");
        }


        public abstract void abstractMethod();
    }

สังเกตุได้ว่ามีความแตกต่างจาก Interface เพราะภายในคลาส นอกจะมีทั้ง method ที่สร้างขึ้นมาพร้อมใช้งานเหมือนคลาสทั่วๆไป ยังสามารถทำ abstract method เพื่อรอให้นำไป Implement ต่อได้ด้วย
ตัวอย่าง abstract class ของ Delphi

  TAbstract = class(TObject)
  public
      procedure myMethod1; virtual; abstract;
      procedure myMethod2; virtual;
  end;



{ TAbstract }


procedure TAbstract.myMethod2;
begin
      //any code
end;

การสร้างคลาสที่เป็น Abstract ของ Delphi ต่างออกไปจาก C#  เพราะ Delphi ไม่มีคลาสที่ระบุให้เป็น Abstract แต่ก็สามารถประยุคขึ้นมาได้ด้วยการสร้างคลาสปกติ ที่รวบรวม method ที่เป็น Abstract เอาไว้ ซึ่งคลาสจะประกาศขึ้นมาเป็นไทป์คลาสหรือสืบทอดมาจาก TObject ก็ได้
โดยที่ myMethod1 นั้นจะนำไป Implement ในคลาสอื่นที่ได้สืบทอดไป (คลาสลูก หรือ Client Class) เพราะมีการระบุ keyword เป็น Abstract
ส่วน myMethod2 นั้นจะเป็น method ที่สร้างขึ้นเพื่อใช้งานได้เลย แต่ก็ยอมให้คลาสลูกนำไป Customize เพิ่มได้ หรือจะทำ method hiding ด้วยการ Override ได้ ด้วยการระบุ keyword "virtual" กำกับเอาไว้

ตัวอย่างการนำไปใช้งานจริง ผู้เขียนจะเสนอส่วนของ C# ก่อน
สมมุติว่าต้องการเขียนโปรแกรมสมุดโทรศัพท์ ผู้เขียนจะใช้ทั้ง Interface และ   Abstract  ให้เห็นเป็นตัวอย่าง
ผู้เขียนสร้าง File myBase.cs เป็นไฟล์ที่บรรจุคลาสต่างๆเอาไว้

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;


namespace multipleInherit
{
    //interface ที่ใช้ในการทำงานกับข้อมูล
    interface ImanageData
    {
        bool AddNew();
        bool Delete();
        void Refresh();
        void Find();
    }


    //abstract class ที่มีหน้าที่เกี่ยวกับโหลดข้อมูล และการบันทึกเป็นไฟล์
    public abstract class phoneBookFile
    {
        string pbFile;


        public string PbFile
        {
            get { return pbFile; }
            set { pbFile = value; }
        }


        public bool saveToFile()
        {
            return true;
        }


        public bool loadFromFile()
        {
            return true;
        }
    }


    //abstract class ที่ได้ถูกทำให้มีความสามารถมากขึ้น ด้วยการสืบทอดการทำงานกับไฟล์ และนำ interface ในการจัดการข้อมูลมา implement ด้วย


    public abstract class phoneBook : phoneBookFile,ImanageData
    {
        //ส่วนที่ได้ implement จาก interface ImanageData
        #region ImanageData Implement
        public bool AddNew()
        {
            throw new NotImplementedException();
        }


        public bool Delete()
        {
            throw new NotImplementedException();
        }


        public void Refresh()
        {
            throw new NotImplementedException();
        }


        public void Find()
        {
            throw new NotImplementedException();
        }
        #endregion


        //method สร้าง DataTable ของ abstract class phoneBook ที่พร้อมใช้งาน
        public DataTable phoneBookTable(ref string tableName)
        {
            tableName = "PHONEBOOK";
            DataTable Res = new DataTable(tableName);
            Res.Columns.Add(new DataColumn("NAME", System.Type.GetType("System.String")));
            Res.Columns.Add(new DataColumn("NUMBER", System.Type.GetType("System.String")));
            return Res;
        }


        //abstract method ที่รอให้คลาสลูก นำไป implement ต่อโดยการ Override
        public abstract void clearBook();
    }


    //class myBase เป็นคลาสที่มีความสามารถสูงที่สุด เพราะจะได้ความสามารถทั้งหมดมาตั้งแต่ interface เปรียบเสมือนคลาสที่ได้ทำ Multiple Inheritance แล้ว
    public class myBase : phoneBook
    {
        //นำ abstract method จาก base class มา implement ต่อ
        public override void clearBook()
        {
            
        }
    }
}


การนำไปใช้งานก็จะใช้งานเฉพาะคลาส myBase ที่รวมความสามารถทั้งหมดไว้

ทดสอบง่ายๆ ถ้าใช้ Visual Studio เมื่อมีการใช้คำสั่ง new object ขึ้นมา ก็จะปรากฎ คุณสมบัติ และ method ต่างๆที่ได้สืบทอดมารวมอยู่ที่ myBase ทั้งหมด