Builder模式（构建器模式）

柔情只为你懂 2024-03-30 09:33 72阅读 0赞

#### 模式简介 ####

当我们需要new一个对象，但是它需要的参数比较多，并且我们并不是所有参数都需要传递时，就可以使用构建器模式，通过这个模式，我们可以将待传入的参数进行分组，并且能够动态传递需要的参数，不过缺点就是对于参数的分组会固定，面对不同的需求就有不同的分组标准，相对于传统的构造函数，这种构建器的方式有诸多优点，第一解决了参数无法可选传入的问题，第二解决了书写繁琐可读性低的问题。

#### 模式UML图 ####

![face0d882c91478881b61526d90aefa6.jpeg][]

#### 代码示例（C\#） ####

**提示：**可在本栏目的资源篇“[设计模式代码示例合集][Link 1]”下载所有完整代码资源。

public class CinemachineParameters
        {
            public float TrackedObjectOffset;
            public float LookaheadTime;
            public float LookaheadSmoothing;
            public bool LookaheadIgnoreY;
            public float XDamping;
            public float YDamping;
            public float ZDamping;
            public bool TargetMovementOnly;
            public int ScreenX;
            public int ScreenY;
            public float CameraDistance;
            public float DeadZoneWidth;
            public float DeadZoneHeight;
            public float DeadZoneDepth;
            public bool UnlimitedSoftZone;
            public float SoftZoneWidth;
            public float SoftZoneHeight;
            public float BiasX;
            public float BiasY;
            public bool CenterOnActive;
            private CinemachineParameters() { }
    
            public class Builder
            {
                private CinemachineParameters cp = new CinemachineParameters();
                public Builder SetLookahead(float p_lookaheadTime, float p_lookaheadSmoothing, bool p_lookaheadIgnoreY)
                {
                    cp.LookaheadTime = p_lookaheadTime;
                    cp.LookaheadSmoothing = p_lookaheadSmoothing;
                    cp.LookaheadIgnoreY = p_lookaheadIgnoreY;
                    return this;
                }
    
                public Builder SetDamping(float p_xDamping, float p_yDamping, float p_zDamping)
                {
                    cp.XDamping = p_xDamping;
                    cp.YDamping = p_yDamping;
                    cp.ZDamping = p_zDamping;
                    return this;
                }
    
                public Builder SetScreen(int p_screenX, int p_screenY)
                {
                    cp.ScreenX = p_screenX;
                    cp.ScreenY = p_screenY;
                    return this;
                }
    
                public Builder SetDeadZone(float p_deadZoneWidth, float p_deadZoneHeight, float p_deadZoneDepth)
                {
                    cp.DeadZoneWidth = p_deadZoneWidth;
                    cp.DeadZoneHeight = p_deadZoneHeight;
                    cp.DeadZoneDepth = p_deadZoneDepth;
                    return this;
                }
    
                public Builder SetSoftZone(bool p_unlimitedSoftZone, float p_softZoneWidth, float p_softZoneHeight)
                {
                    cp.UnlimitedSoftZone = p_unlimitedSoftZone;
                    cp.SoftZoneWidth = p_softZoneWidth;
                    cp.SoftZoneHeight = p_softZoneHeight;
                    return this;
                }
    
                public Builder SetBias(float p_biasX, float p_biasY)
                {
                    cp.BiasX = p_biasX;
                    cp.BiasY = p_biasY;
                    return this;
                }
    
                public Builder SetOther(float p_trackedObjectOffset, bool p_targetMovementOnly, float p_cameraDistance, bool p_centerOnActive)
                {
                    cp.TrackedObjectOffset = p_trackedObjectOffset;
                    cp.TargetMovementOnly = p_targetMovementOnly;
                    cp.CameraDistance = p_cameraDistance;
                    cp.CenterOnActive = p_centerOnActive;
                    return this;
                }
    
                public CinemachineParameters Build()
                {
                    return cp;
                }
            }
        }
    
        //测试代码
        public void Test()
        {
            CinemachineParameters cp = new CinemachineParameters.Builder()
            .SetLookahead(1.1f, 2.1f, false)
            .SetScreen(1920, 1080)
            .SetDamping(1.3f, 1.4f, 5.20f)
            .Build();
            CinemachineParameters cp2 = new CinemachineParameters.Builder()
            .SetLookahead(1.3f, 1.4f, false)
            .SetScreen(1314, 520)
            .SetDamping(1.3f, 1.4f, 5.20f)
            .Build();
            Console.WriteLine(cp.ScreenX + " " + cp.ScreenY);
            Console.WriteLine(cp2.ScreenX + " " + cp2.ScreenY);
        }

#### 代码解说 ####

示例中我们的对象类是CinemachineParameters类，我们给它声明了一个内部类Builder，这是构建器模式的一种常用写法，调用时只需要声明一个Builder对象，然后通过对应的SetXXX方法传入参数即可，当传入完毕后再调用Build方法确定创建并返回CinemachineParameters对象，同时我们这个示例中采用了链式编程进一步简化了构建器的使用。

**如果这篇文章对你有帮助，请给作者点个赞吧！**

[face0d882c91478881b61526d90aefa6.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/acf21fc0e19a42278c33e7cfba304da1.jpeg
[Link 1]: https://blog.csdn.net/hgf1037882434/article/details/128394782