การออกแบบรูปแบบคำสั่ง

ฉันมีการใช้รูปแบบคำสั่งเก่านี้ เป็นการผ่านบริบทผ่านการใช้งานDIOperationทั้งหมดแต่ฉันรู้ในภายหลังในกระบวนการเรียนรู้และการเรียนรู้ (ที่ไม่เคยหยุดนิ่ง) นั่นไม่เหมาะสม ฉันยังคิดว่า "การเยี่ยมชม" ที่นี่ไม่เหมาะและสับสนจริงๆ

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

ตัวอย่างกรณีการใช้งานสมมติว่าCommandBต้องการชื่อผู้ใช้ที่CommandAกำหนดไว้ CommandA ควรตั้งค่าUserNameForCommandB = Johnหรือไม่ หรือพวกเขาควรแบ่งปันชื่อผู้ใช้ทั่วไป= John key-value หรือไม่ จะเกิดอะไรขึ้นหากชื่อผู้ใช้ถูกใช้โดยคำสั่งที่สาม

ฉันจะปรับปรุงการออกแบบนี้ได้อย่างไร ขอบคุณ!

class DIParameters {
public:
   /**
    * Parameter setter.
    */
    virtual void setParameter(std::string key, std::string value) = 0;
    /**
    * Parameter getter.
    */
    virtual std::string getParameter(std::string key) const = 0;

    virtual ~DIParameters() = 0;
};

class DIOperation {
public:
    /**
     * Visit before performing execution.
     */
    virtual void visitBefore(DIParameters& visitee) = 0;
    /**
     * Perform.
     */
    virtual int perform() = 0;
    /**
     * Visit after performing execution.
     */
    virtual void visitAfter(DIParameters& visitee) = 0;

    virtual ~DIOperation() = 0;
};

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

ปัญหาเกี่ยวกับวิธีการของคุณ:

คุณต้องการให้เธรด / คำสั่งอื่นเปลี่ยนพารามิเตอร์ของคุณในขณะที่performเกิดขึ้นหรือไม่?

คุณต้องการvisitBeforeและเรียกวัตถุvisitAfterเดียวกันCommandด้วยDIParameterวัตถุที่แตกต่างกันหรือไม่?

คุณต้องการให้ใครสักคนป้อนพารามิเตอร์ให้กับคำสั่งของคุณซึ่งคำสั่งนั้นไม่มีความคิดหรือไม่?

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

ตัวอย่างของผลที่ตามมา:

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

ฉันสามารถตั้งค่าuserNameพารามิเตอร์หรือusername.. คุณปฏิบัติกับกรณีพารามิเตอร์อย่างไม่รู้สึกตัวหรือไม่? ฉันไม่รู้จริง ๆ เลย .. โอ้เดี๋ยวก่อน .. อาจจะเป็นเพียงแค่name?

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

วิธีการออกแบบที่เป็นไปได้ที่แตกต่างกัน:

• พารามิเตอร์ที่ไม่เปลี่ยนรูป: เมื่อเปลี่ยนParameterอินสแตนซ์ของคุณที่ไม่เปลี่ยนรูปคุณสามารถนำกลับมาใช้ใหม่ได้อย่างอิสระในคำสั่งต่าง ๆ
• คลาสพารามิเตอร์เฉพาะ: เมื่อกำหนดUserParameterคลาสที่มีพารามิเตอร์ที่แน่นอนที่ฉันต้องการสำหรับคำสั่งที่เกี่ยวข้องกับผู้ใช้มันจะง่ายกว่ามากในการทำงานกับ API นี้ คุณยังอาจมีมรดกพารามิเตอร์ แต่มันจะไม่ทำให้รู้สึกใด ๆ อีกต่อไปสำหรับการเรียนคำสั่งที่จะใช้พารามิเตอร์พล - ที่ด้านโปรของหลักสูตรนี้หมายถึงว่าผู้ใช้ API รู้ซึ่งพารามิเตอร์จะต้องตรง
• อินสแตนซ์คำสั่งหนึ่งคำสั่งต่อบริบท: หากคุณต้องการให้คำสั่งของคุณมีสิ่งที่ชอบvisitBeforeและvisitAfterในขณะที่การนำกลับมาใช้ใหม่ด้วยพารามิเตอร์ที่แตกต่างกันคุณจะเปิดปัญหาการเรียกด้วยพารามิเตอร์ที่แตกต่าง หากพารามิเตอร์ควรเหมือนกันในการเรียกใช้เมธอดหลายวิธีคุณต้องใส่แค็ปซูลลงในคำสั่งเพื่อไม่สามารถเปลี่ยนพารามิเตอร์อื่น ๆ ระหว่างการโทรได้

สิ่งที่ดีเกี่ยวกับหลักการออกแบบคือไม่ช้าก็เร็วพวกเขาขัดแย้งกัน

ในสถานการณ์ที่อธิบายไว้ฉันคิดว่าฉันต้องการไปกับบริบทบางอย่างที่แต่ละคำสั่งสามารถนำข้อมูลจากและนำข้อมูลไปใช้ (โดยเฉพาะถ้าเป็นคู่ของคีย์ - ค่า) สิ่งนี้ขึ้นอยู่กับการแลกเปลี่ยน: ฉันไม่ต้องการให้คำสั่งแยกจากกันเป็นเพียงเพราะพวกเขาเป็นชนิดของการป้อนข้อมูลซึ่งกันและกัน ภายใน CommandB ฉันไม่สนใจว่า UserName ได้รับการตั้งค่าอย่างไรเพียงแค่มีไว้ให้ฉันใช้ สิ่งเดียวกันใน CommandA: ฉันตั้งค่าข้อมูลไว้ฉันไม่ต้องการรู้ว่าคนอื่นทำอะไรกับมัน - ไม่ว่าพวกเขาจะเป็นใคร

นี่หมายถึงบริบทการผ่านซึ่งคุณสามารถค้นหาได้ไม่ดี สำหรับฉันทางเลือกนั้นแย่ลงโดยเฉพาะอย่างยิ่งถ้าบริบทคีย์ - ค่าง่าย ๆ (อาจเป็นถั่วธรรมดาที่มี getters และ setters เพื่อ จำกัด บิตของ "free form" factor) สามารถทำให้โซลูชันนั้นง่ายและทดสอบได้ดี คำสั่งที่แยกจากกันแต่ละตัวมีตรรกะทางธุรกิจของตัวเอง

สมมติว่าคุณมีอินเตอร์เฟสคำสั่ง:

class Command {
public:
    void execute() = 0;
};

และเรื่อง:

class Subject {
    std::string name;
public:
    void setName(const std::string& name) {this->name = name;}
}

สิ่งที่คุณต้องการคือ:

class NameObserver {
public:
    void update(const std::string& name) = 0;
};

class Subject {
    NameObserver& o;
    std::string name;
private:
    void setName(const std::string& name) {
        this->name = name;
        o.update(name);
    }
};

class CommandB: public Command, public NameObserver {
    std::string name;
public:
    void execute();
    void update(const std::string& name) {
        this->name = name;
        execute();
    }
};

ตั้งNameObserver& oเป็นการอ้างอิงไปยัง CommandB ตอนนี้เมื่อใดก็ตามที่ CommandA เปลี่ยนชื่อวิชา CommandB สามารถดำเนินการด้วยข้อมูลที่ถูกต้อง หากชื่อถูกใช้โดยคำสั่งเพิ่มเติมให้ใช้std::list<NameObserver>

ฉันไม่รู้ว่านี่เป็นวิธีที่ถูกต้องในการจัดการกับโปรแกรมเมอร์ (ซึ่งในกรณีนี้ฉันขอโทษ) แต่หลังจากตรวจสอบคำตอบทั้งหมดที่นี่ (โดยเฉพาะ @ @ Frank) ฉัน refactored รหัสของฉันด้วยวิธีนี้:

• Diparameters ที่ลดลง ฉันจะมีวัตถุ (ทั่วไป) แต่ละรายการเป็นอินพุตของ DIOperation (ไม่เปลี่ยนรูป) ตัวอย่าง:

คลาส RelatedObjectTriplet {
เอกชน:
    std :: string const m_sPrimaryObjectId;
    std :: string const m_sSecondaryObjectId;
    std :: string const m_sRelationObjectId;

    RelatedObjectTriplet & operator = (RelatedObjectTriplet อื่น ๆ );

ส่วนกลาง:
    RelatedObjectTriplet (std :: สตริง const & sPrimaryObjectId,
                         std :: สตริง const & sSecondaryObjectId,
                         std :: string const & sRelationObjectId);

    RelatedObjectTriplet (ที่เกี่ยวข้อง ObjectTriplet const & อื่น ๆ );


    std :: string const & getPrimaryObjectId () const;
    std :: สตริง const & getSecondaryObjectId () const;
    std :: สตริง const & getRelationObjectId () const;

    ~ RelatedObjectTriplet ();
};

• คลาส DIOperation ใหม่ (พร้อมตัวอย่าง) กำหนดเป็น:
  

แม่แบบ <class T = void> 
ระดับ DIOperation {
ส่วนกลาง:
    virtual int perform () = 0;

    virtual T getResult () = 0;

    virtual ~ DIOperation () = 0;
};

ระดับ CreateRelation: สาธารณะ DIOperation <RelatedObjectTriplet> {
เอกชน:
    คงที่มาตรฐาน :: สตริง const TYPE;

    // Params (ไม่เปลี่ยนรูป)
    RelatedObjectTriplet const m_sParams;

    // ซ่อนเร้น
    CreateRelation & operator = (CreateRelation const & แหล่งที่มา);
    CreateRelation (CreateRelation const & แหล่งที่มา);

    // ภายใน
    std :: string m_sNewRelationId;

ส่วนกลาง:
    CreateRelation (ที่เกี่ยวข้อง ObjectTriplet const & params);

    int ดำเนินการ ();

    RelatedObjectTriplet getResult ();

    ~ CreateRelation ();
};

• มันสามารถใช้เช่นนี้:

RelatedObjectTriplet triplet ("33333", "55555", "77777");
CreateRelation createRel (triplet);
createRel.perform ();
const RelatedObjectTriplet res = createRel.getResult ();

ขอบคุณสำหรับความช่วยเหลือและฉันหวังว่าฉันไม่ได้ทำผิดพลาดที่นี่ :)