c# iis Oracle链接

本文介绍策略模式以及使用函数式编程替代简单的策略模式。

策略模式

上面这段话来自菜鸟教程。简单来说，就是一种封装。Context需要执行某种算法，但是Context无法构造出算法的细节，于是Context需要找Concrete Strategy类获取，不同的Concrete Strategy类对应不同的算法，因为他们继承自一个公共的Abstract Strategy。

作为行为型模式的一种，这个还是一个比较好理解的设计模式，至少对我来说。我大概看了介绍就写了写C++的实现：

首先定义一个公共的父类：

struct AbsBaseStrategy
{
public:
    virtual void show() = 0;
};

然后写两个子类继承：

struct SpecificStrategy1 : AbsBaseStrategy
{
public:
    void show() override
    {
        cout << "SpecificStrategy1 show" << endl;
    }
};

struct SpecificStrategy2 : AbsBaseStrategy
{
public:
    void show() override
    {
        cout << "SpecificStrategy2 show" << endl;
    }
};

写一个公共的上下文，调用策略类的方法。我比较懒，这里就用智能指针了。引用的写法是类似的：

struct TradStrategyCtxt
{
public:
    TradStrategyCtxt(shared_ptr<AbsBaseStrategy> strategy) : m_strategy(strategy){};
    void ctxtShow()
    {
        m_strategy->show();
    }

private:
    shared_ptr<AbsBaseStrategy> m_strategy;
};

然后使用的时候直接传递具体的对象进来就行：

int main()
{
    TradStrategyCtxt ctxt1(make_shared<SpecificStrategy1>());
    TradStrategyCtxt ctxt2(make_shared<SpecificStrategy2>());
    ctxt1.ctxtShow();
    ctxt2.ctxtShow();
}

函数式编程下的策略模式

事实上如果只是调用某一个（或者少量某几个）具体的方法，我们大可不必非得传一个类进来。不同的策略类唯一的意义就是对接口函数进行包装，那如果直接把函数指针传入，也是可以的。还是上面的例子。

我们使用两个函数，代替两个具体的策略类：

void show1()
{
    cout << "SpecificStrategy1 show" << endl;
};

void show2()
{
    cout << "SpecificStrategy2 show" << endl;
};

在Context中，直接传入函数指针：

struct TradStrategyCtxt
{
public:
    TradStrategyCtxt(function<void()> func) : m_func(func){};
    void ctxtShow()
    {
        m_func();
    }

private:
    function<void()> m_func;
};

调用的地方也不需要修改什么，最后的效果是相同的：

int main()
{
    TradStrategyCtxt ctxt1(show1);
    TradStrategyCtxt ctxt2(show2);
    ctxt1.ctxtShow();
    ctxt2.ctxtShow();
}