วิธีใช้รูปแบบการออกแบบคำสั่งใน C #

รูปแบบการออกแบบเป็นโซลูชันที่ได้รับการพิสูจน์แล้วว่าใช้เพื่อแก้ปัญหาการออกแบบทั่วไปและลดความซับซ้อนในโค้ด รูปแบบการออกแบบ Gang of Four แบ่งออกเป็น 3 ประเภท:

  • Creational - รูปแบบที่เกี่ยวข้องกับการสร้างวัตถุ
  • โครงสร้าง - รูปแบบที่เกี่ยวข้องกับการประกอบวัตถุ
  • พฤติกรรม - รูปแบบที่เกี่ยวข้องกับการทำงานร่วมกันของวัตถุและการแยกความรับผิดชอบ

รูปแบบการออกแบบคำสั่งอยู่ภายใต้ประเภทรูปแบบพฤติกรรม บทความนี้จะอธิบายว่าเราสามารถทำงานกับรูปแบบการออกแบบคำสั่งใน C # ได้อย่างไร

รูปแบบการออกแบบคำสั่งคืออะไร?

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

รูปแบบการออกแบบคำสั่งเป็นตัวเลือกที่ดีเมื่อคุณต้องการใช้การเรียกกลับงานการจัดคิวประวัติการติดตามและฟังก์ชันการเลิกทำ / ทำซ้ำในแอปพลิเคชันของคุณ รูปแบบคำสั่งเป็นทางเลือกที่ดีสำหรับการใช้กลไกการลองใหม่ - เมื่อแอปพลิเคชันของคุณต้องการลองเชื่อมต่อกับบริการอีกครั้งในเวลาต่อมาซึ่งยังไม่พร้อมใช้งานในขณะนี้ รูปแบบคำสั่งยังใช้ในแอปพลิเคชันการจัดคิวข้อความเช่นในแอปพลิเคชันที่ต้องการกู้คืนจากข้อมูลสูญหาย

ผู้เข้าร่วมรูปแบบการออกแบบคำสั่ง

ในการใช้งานรูปแบบคำสั่งแบบคลาสสิกคุณมีองค์ประกอบสี่ส่วน ได้แก่ คำสั่งผู้เรียกใช้ผู้รับและไคลเอ็นต์ ผู้เข้าร่วมในรูปแบบการออกแบบคำสั่งมีดังต่อไปนี้:

  • Command - จัดเตรียมอินเทอร์เฟซสำหรับการดำเนินการ
  • ConcreteCommand - ขยายอินเตอร์เฟส Command และใช้เมธอด Execute
  • ไคลเอนต์ - สร้างอินสแตนซ์คลาส ConcreteCommand
  • Invoker - แจ้งคำสั่งเพื่อดำเนินการตามคำขอ
  • ผู้รับ - มีตรรกะในการดำเนินการที่เกี่ยวข้องกับคำขอ

ตัวอย่างรูปแบบการออกแบบคำสั่งใน C #

ในส่วนถัดไปเราจะสำรวจว่าเราสามารถใช้รูปแบบการออกแบบคำสั่งได้อย่างไร ในตัวอย่างของเราเราจะใช้เครื่องคิดเลขง่ายๆโดยใช้คลาสต่อไปนี้:

  • คำสั่ง (คลาสฐานคำสั่งนามธรรม)
  • SimpleCalculator (คลาสตัวรับ)
  • AddCommand (คลาสคำสั่งคอนกรีต)
  • SubstractCommand (คลาสคำสั่งคอนกรีต)
  • Multiply Command (คลาสคำสั่งที่เป็นรูปธรรม)
  • DivideCommand (คลาสคำสั่งคอนกรีต)
  • Invoker (คลาส Invoker)

สร้างคลาสฐานคำสั่งนามธรรมใน C #

พิจารณาคลาสพื้นฐานที่เป็นนามธรรมต่อไปนี้ชื่อ Command ที่มีการประกาศของเมธอด Execute

คำสั่งระดับนามธรรมสาธารณะ

    {

        ตัวรับ SimpleCalculator ที่ได้รับการป้องกัน

        คำสั่งสาธารณะ (ตัวรับ SimpleCalculator)

        {

            this.receiver = ผู้รับ;

        }

        int Execute นามธรรมสาธารณะ ();

    }

enum ต่อไปนี้แสดงการทำงานที่จะได้รับการสนับสนุนในเครื่องคิดเลขอย่างง่ายของเรา

CommandOption สาธารณะ enum

    {

        เพิ่ม, ย่อย, คูณ, หาร

    }

สร้างคลาสตัวรับใน C #

ต่อไปนี้เป็นคลาสชื่อ SimpleCalculator คลาสนี้ทำหน้าที่เป็นตัวรับและมีคำจำกัดความของวิธีการเพิ่มลบคูณและหาร

SimpleCalculator ระดับสาธารณะ

    {

        int ส่วนตัว _x, _y;

        SimpleCalculator สาธารณะ (int a, int b)

        {

            _x = a;

            _y = b;

        }

        int สาธารณะเพิ่ม ()

        {

            กลับ _x + _y;

        }

        int สาธารณะลบ ()

        {

            กลับ _x - _y;

        }

        int สาธารณะ Multiply ()

        {

            กลับ _x * _y;

        }

        แบ่ง int สาธารณะ ()

        {

            กลับ _x / _y;

        }

    }

สร้างคลาสคำสั่งคอนกรีตใน C #

คลาสคำสั่งที่เป็นรูปธรรมจะขยายคลาสฐานนามธรรมของคำสั่งและใช้เมธอด Execute ดังที่แสดงด้านล่าง

 คลาสสาธารณะ AddCommand: Command

    {

        SimpleCalculator ส่วนตัว _calculator;

        AddCommand สาธารณะ (เครื่องคิดเลข SimpleCalculator): ฐาน (เครื่องคิดเลข)

        {

            _calculator = เครื่องคิดเลข;

        }

        การแทนที่สาธารณะ int Execute ()

        {

            กลับ _calculator.Add ();

        }

    }

    คลาสสาธารณะ SubtractCommand: Command

    {

        SimpleCalculator ส่วนตัว _calculator;

        SubtractCommand สาธารณะ (เครื่องคิดเลข SimpleCalculator):

        ฐาน (เครื่องคิดเลข)

        {

            _calculator = เครื่องคิดเลข;

        }

        การแทนที่สาธารณะ int Execute ()

        {

            ส่งคืน _calculator.Subtract ();

        }

    }

    MultiplyCommand คลาสสาธารณะ: Command

    {

        SimpleCalculator ส่วนตัว _calculator;

        MultiplyCommand สาธารณะ (เครื่องคิดเลข SimpleCalculator):

        ฐาน (เครื่องคิดเลข)

        {

            _calculator = เครื่องคิดเลข;

        }

        การแทนที่สาธารณะ int Execute ()

        {

            กลับ _calculator.Multiply ();

        }

    }

    คลาสสาธารณะ DivideCommand: Command

    {

        SimpleCalculator ส่วนตัว _calculator;

        DivideCommand สาธารณะ (เครื่องคิดเลข SimpleCalculator):

        ฐาน (เครื่องคิดเลข)

        {

            _calculator = เครื่องคิดเลข;

        }

        การแทนที่สาธารณะ int Execute ()

        {

            กลับ _calculator.Divide ();

        }

    }

สร้างคลาส Invoker ใน C #

ข้อมูลโค้ดต่อไปนี้แสดงถึงคลาส Invoker ประกอบด้วยสองวิธีการ SetCommand และ Execute ในขณะที่ SetCommand ถูกใช้เพื่อกำหนดอ็อบเจ็กต์คำสั่งให้กับการอ้างอิงคำสั่งส่วนตัวในคลาส Invoker แต่ Execute จะใช้เพื่อดำเนินการคำสั่ง

    Invoker คลาสสาธารณะ

    {

        คำสั่งส่วนตัว _command;

        โมฆะสาธารณะ SetCommand (คำสั่ง Command)

        {

            _command = คำสั่ง;

        }

        int สาธารณะดำเนินการ ()

        {

            ส่งคืน _command.Execute ();

        }

    }

รูปแบบการออกแบบคำสั่งในการดำเนินการใน C #

สุดท้ายข้อมูลโค้ดต่อไปนี้แสดงให้เห็นว่าคุณสามารถคำนวณอย่างง่ายโดยใช้คลาส SimpleCalculator

โมฆะคงที่หลัก (สตริง [] args)

        {

            เครื่องคิดเลข SimpleCalculator = SimpleCalculator ใหม่ (15, 3);

            var addCommand = AddCommand ใหม่ (เครื่องคิดเลข);

            var substractCommand = SubtractCommand ใหม่ (เครื่องคิดเลข);

            var multiplyCommand = MultiplyCommand ใหม่ (เครื่องคิดเลข);

            var DivideCommand = DivideCommand ใหม่ (เครื่องคิดเลข);

            Invoker Invoker = Invoker ใหม่ ();

            invoker.SetCommand (addCommand);

            Console.WriteLine ("ผลลัพธ์คือ {0}", invoker.Execute ());

            invoker.SetCommand (substractCommand);

            Console.WriteLine ("ผลลัพธ์คือ {0}", invoker.Execute ());

            invoker.SetCommand (multiplyCommand);

            Console.WriteLine ("ผลลัพธ์คือ {0}", invoker.Execute ());

            Invoker.SetCommand (DivideCommand);

            Console.WriteLine ("ผลลัพธ์คือ {0}", invoker.Execute ());

            Console.ReadLine ();

        }

รูปแบบการออกแบบคำสั่งให้การสนับสนุนสำหรับความสามารถในการขยายและลดการมีเพศสัมพันธ์ที่มีอยู่ระหว่างตัวเรียกและตัวรับของคำสั่ง เนื่องจากคำขอถูกห่อหุ้มไว้ในออบเจ็กต์แบบสแตนด์อะโลนคุณสามารถกำหนดพารามิเตอร์วิธีการด้วยการร้องขอที่แตกต่างกันบันทึกคำขอในคิวและแม้กระทั่งให้การสนับสนุนสำหรับการดำเนินการที่สามารถทำซ้ำหรือยกเลิกได้

-

ทำได้มากขึ้นด้วย C #:

  • วิธีทำงานกับ AutoMapper ใน C #
  • เมื่อใดควรใช้คลาสนามธรรมเทียบกับอินเทอร์เฟซใน C #
  • วิธีการทำงานกับเธรดใน C #
  • วิธีใช้ Dapper ORM ใน C #
  • วิธีใช้รูปแบบการออกแบบที่เก็บใน C #
  • วิธีใช้คนตัดไม้อย่างง่ายใน C #
  • วิธีการทำงานกับผู้รับมอบสิทธิ์ใน C #
  • วิธีการทำงานกับผู้รับมอบสิทธิ์ Action, Func และ Predicate ใน C #
  • วิธีการทำงานกับ log4net ใน C #
  • วิธีการทำงานกับการสะท้อนใน C #