Question

我们有一个包含几个具有不同功能的程序集的库。我们在为客户开发的任何前端项目中使用此库。假设我想在库中执行特定的任务/方法，但该方法的实现必须在前端。

简而言之：库中的类X调用库中类Y的方法A，但方法A需要在库外实现。怎么样？

Answer 1

您可以从lib公开委托，让消费者将其设置为指向自己的实现。

示例：

public delegate void DoWorkDelegate(CustomWorkParameters p);

public DoWorkDelegate DoWorkCallback
{
  get
  {
    return _workCallback;
  }
  set 
  {
    _workCallback = value;
  }
}

稍后在您的lib中，当您需要实际完成工作时：

private void DoWorkInternal() 
{
  //Some work here

  //Check if caller set the callback
  if(_workCallback != null) 
  {
     _workCallback(localWorkParameters);
  }  
  else 
  {
     //throw exception
  }
  //Some more work here
}

消费者应该有一个尊重委托签名的方法，并在初始化阶段将其传递给你的lib。

Answer 2

将ClassY定义为Abstract类，要求使用者为定义为Abstract的方法提供实现。在ClassY基础上定义的逻辑对于所有派生类是通用的，并且在ClassY base上定义为“abstract”的方法将需要由每个派生类实现。注意我只是将它一起攻击，所以我没有声称实际代码代表了最佳实践！

抽象基类：

public abstract class AbstractLibraryClassY
{
    private static int _multiplier = 0;


    public abstract int MethodA(int SomeParam);

    // A simple example Property defined and implemented on the Abstract base class:
    public int Multiplier
    {
        get { return _multiplier; }
        set { _multiplier = value; }
    }


    private void someclassYImplementationStuff()
    {
        // Other implementation code . . .
    }
}

ClassY的两种可能实现：

public class ConcreteClassYImplementationOne : AbstractLibraryClassY
{
    public override int MethodA(int SomeParam)
    {
        return SomeParam * this.Multiplier;
    }
}


public class ConcreteClassYImplementationTwo : AbstractLibraryClassY
{
    public override int MethodA(int SomeParam)
    {
        return SomeParam * this.Multiplier + 5;
    }
}

Class X，使用ClassY的实例：

public class LibraryClassX
{
    public int methodCallsClassYMethodA(AbstractLibraryClassY ImplementedClassY)
    {
        ImplementedClassY.Multiplier = 2;
        return ImplementedClassY.MethodA(100);
    }
}

一个简单的演示，它使用类X按顺序使用ClassY的每个实现：

public class Consumer1
{
    public void ConsumeClassX()
    {
        // Some hokey, arbitrary inputs:
        int MyInput = 200;
        int MyMultiplier = 2;

        // Consume Library Class Y using ConcreteClassYImplementationOne:
        AbstractLibraryClassY InstanceOf = new ConcreteClassYImplementationOne();
        InstanceOf.Multiplier = MyMultiplier;

        // Will output 400, per implementation defined in ConcreteClassYImplementationOne:
        Console.WriteLine("Output = " + InstanceOf.MethodA(MyInput).ToString());

        // Consume Library Class Y using ConcreteClassYImplementationTwo:
        InstanceOf = new ConcreteClassYImplementationTwo();
        InstanceOf.Multiplier = MyMultiplier;

        // Will output 405, per implementation defined in ConcreteClassYImplementationTwo:
        Console.WriteLine("Output = " + InstanceOf.MethodA(MyInput).ToString());

    }
}

希望有所帮助。另请参阅评论员的建议：依赖注入。我现在只是在研究它（它可能就是我刚才所描述的 - 不确定，需要研究！

在客户端项目中实现库方法

2 个答案: