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

Question

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

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

我想这样做，这样客户就不必担心调用（或忘记调用）init 和 deinit 函数，而只需担心他们自己的代码。

Answer 1

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

Answer 2

除了西蒙的回答，你可以做委托而不是硬编码里面的操作，并且取决于语言，你可以使用委托来传递。

例如在 C# 中调用 web 服务，哪种语言能够通过委托：

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 3

您可能需要适配器模式，您可以在其中对适配器进行客户端调用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();
}

Answer 4

在这种情况下，我的偏好是让客户端使用参数调用单个函数（我们可能会调用它executeFn()），f这是客户端提供的函数，也是客户端向viafp提供参数的一种方式。可能还需要接受由 提供的参数，这些参数是在初始化步骤中创建的，并返回一个在反初始化步骤中使用的值。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