Question

与Builder pattern类似，其中可以从一个公共函数调用必须以特定顺序调用的一系列函数或代码。

当客户端必须首先调用特定的初始化函数，然后是零个或多个客户端代码调用，然后是最后的deinitializer函数时，是否存在模式？

我想这样做，以便客户端不必担心调用（或忘记调用）init和deinit函数，并且可以担心他们自己的代码。

Answer 1

根据使用的语言，您可以尝试使用NVI惯用法或Proxy模式。还有一些其他成语/模式间接解决了这个问题。

Answer 2

我在这种情况下的偏好是让客户端使用参数executeFn()调用单个函数（我们可以调用f），这是客户端提供的函数，{{{ 1}}这是客户端通过fp向f()提供参数的一种方式。 executeFn()可能还需要f()接受已在初始化步骤中创建的executeFn()提供的参数，并返回executeFn()在去初始化步骤中使用的值。

在Python中，例如：

def executeFn (f, fp):
    # do the initalisation here
    i = len(fp)
    f(fp,i)
    # do the de-initalisation here

def myFn (p,i):
    print (i)
    print (p)

executeFn(myFn,"message")

......输出：

7
message

Answer 3

除了Simon的回答，你可以做代理而不是硬编码里面的操作，并且依赖于语言，你可以使用委托来传递。

例如在C＃中调用webservice，哪种语言能够传递委托：

public class Invoker{
    public ResultClass Invoke(Func<InvokeResultClass, ServiceClass> action){
        ResultClass result;
        using(ServiceClass svc = new ServiceClass()){ //create the service
            InvokeResultClass invokeResult = action(svc);
            // do something with InvokeResultClass and creating ResultClass
        } // dispose it
        return result;
    }
}

消费者：

Invoker inv = new Invoker();
ResultClass result = inv.Invoke( svc => svc.CallWebServiceMethod(param1, param2, etc) );

Answer 4

您可能需要Adapter Pattern您在适配器上有客户端调用methodA()的实现

class Adaptee
{
    methodA()
    {
        // some code
    }
}
class Adapter extends Adaptee
{
    methodA()
    {
        mustBeCalledFirst(); //methodB()
        super.methodA(); //from adaptee
        mustBeCalledLast(); //methodC()
    }
}
class Client
{
    Adapter adapter;
    methodA()
    {
        adapter.methodA();
    }
}

修改

如果您的methodB（）和methodC（）在您的客户端，您可以添加客户端界面

class Adaptee
{
    methodA()
    {
        // some code
    }
}
class Adapter extends Adaptee
{
    ClientInterface clientInterface;
    public Adapter( ClientInterface clientInterface)
    {
         this.clientInterface = clientInterface ;
    }
    methodA()
    {
        clientInterface.methodB()
        super.methodA(); //from adaptee
        clientInterface.methodC()
    }
}
class Client implements ClientInterface
{
    Adapter adapter;
    methodA()
    {
        adapter.methodA();
    }
    @override
    methodB(){}
    @override
    methodC(){}
}
Interface ClientInterface
{
     methodB();
     methodC();
}

必须首先调用的函数的模式，然后是客户端代码，然后是必须最后调用的函数？

4 个答案: