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

【问题标题】：Implement library method in client project在客户端项目中实现库方法
【发布时间】：2012-07-04 14:07:02
【问题描述】：

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

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

【问题讨论】：

看依赖注入和应用组合

标签： c# inheritance interface

【解决方案1】：

您可以从您的库中公开一个委托，并让消费者将其设置为指向他们自己的实现。

例子：

public delegate void DoWorkDelegate(CustomWorkParameters p);

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

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

private void DoWorkInternal() 
{
  //Some work here

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

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

【讨论】：

【解决方案2】：

将 ClassY 定义为 Abstract 类，要求使用者为定义为 Abstract 的方法提供实现。在 ClassY 基础上定义的逻辑对所有派生类都是通用的，在 ClassY 基础上定义为“抽象”的方法将需要由每个派生类实现。请注意，我只是将其组合在一起作为示例，因此我没有声称实际代码代表最佳实践！

抽象基类：

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());

    }
}

希望对您有所帮助。还要查看评论者的建议：依赖注入。我现在才开始研究（这可能就是我刚才描述的 - 不确定，需要研究！

【讨论】：