Policy mode - unity

The strategy pattern

The strategy pattern is an object behavior pattern . This mode Define a series of algorithms , Encapsulate it , Make these algorithms complete specific tasks , Can replace each other . Through a scenario class , Separate its algorithm implementation from business logic , Dynamically switch different algorithms for management .

Strategic patterns are also very common in life , Such as the way of travel , When you need to reach a destination , We need a way to achieve , Cycling , Take the bus, etc , They all achieve the same task , But the way of implementation is quite different . In the program , Sorting is very common , Different sorting methods have different specific （ Like fast platoon , Homing , Stacking and so on ）, Through different scenes , We can choose these sorts flexibly .

structure

explain

• Abstract strategy （IStrategy）- Declare the general interface of the algorithm , Delegate algorithm implementation to subclasses .
• Specific strategies （Concrete Strategy）- Implement specific algorithms .
• scene （Context）- Dependent policy references , Do not realize the function , The method responsible for calling the policy interface .

The algorithm itself needs to be independent

Realization

Example ： Scene: the switch （Scene Switching）

Scene: the switch （ Abstract strategy ）

    public interface ISceneSwitch
    {
    
        void SceneSwitch();
    }

Switch algorithm （ Specific strategies ）

	// Fade switch 
    public class FadeSwitch : ISceneSwitch
    {
    
        public void SceneSwitch()
        {
    
            Debug.Log("Scene Fade Switch");
        }
    }
    // Circular switch 
    public class CircularSwitch : ISceneSwitch
    {
    
        public void SceneSwitch()
        {
    
            Debug.Log("Circular Scene Switch");
        }
    }

scene （ scene ）

    public class Scene
    {
    
        private ISceneSwitch _sceneSwitch;

        public ISceneSwitch SceneSwitch
        {
    
            set => _sceneSwitch = value;
        }
        
        public Scene(ISceneSwitch sceneSwitch)
        {
    
            _sceneSwitch = sceneSwitch;
        }

        public void SceneSwitching()
        {
    
            _sceneSwitch.SceneSwitch();
        }
    }

call

    public class StrategyExample : MonoBehaviour
    {
    
        private void Start()
        {
    
            Scene scene = new Scene(new FadeSwitch());
            scene.SceneSwitching();

            scene.SceneSwitch = new CircularSwitch();
            scene.SceneSwitching();
        }
    }

Application scenarios

• When the client needs dynamic switching algorithm , And different algorithms realize a specific task
• When a large number of conditional branch statements are used to perform tasks , We can use strategy patterns
• The algorithm itself needs to be separated from the business logic , And the algorithm implementation does not depend on context

Advantages and disadvantages

advantage

• Avoid using multiple branch statements , Such as if…else,switch…case etc. , The code is simpler .
• It satisfies the open close principle , When extending the new algorithm , There is no need to change the client code .
• Separate business logic and Algorithm

shortcoming

• Make the system more complex
• The client itself needs to understand the differences between different policy algorithms

The difference from other models

• The bridge and Strategy Very similar , And they delegate tasks to reference objects , But the essence is different , Bridging focuses on separating functions , Interact with each implementation reference through abstract classes , To complete the corresponding functions , The essence is to combine various functions into a large structure , And the idea is mainly to replace inheritance by composition to complete the separation of abstraction and implementation . The strategic model focuses on only one , That's it The algorithms can switch between each other in operation , And they don't interfere with each other , Algorithm implementation and business logic separation .
• Template method and Strategy They are all different implementations of algorithms . But the idea is different , The template method itself is on an algorithm skeleton , Rewrite specific steps , The algorithm itself is sequential . And the algorithm implementation of strategy , It can be completely different , As long as you complete a specific task . Template methods are class inheritance , Strategy is a combination of objects . Template method algorithm is static , The strategy algorithm is dynamic .
• state and Strategy It's all about function switching at runtime . Function switching of state , It is mainly the state change that makes the function switch , The strategy is to actively switch . There is no clear separation between function realization and state switching , It can cooperate with the strategic mode , Realize the separation of implementation and switching .