“并不总是使用基类参数”代码气味

Question

假设您有这样的代码：

public Base
{
   abstract void Register();
}

public Registrator1: Base
{
   override void Register()
   {
      //uses the current state of the object to populate the UI captions
   }
}

public Registrator2: Base
{
   override void Register()
   {
      //uses the current state of the object to populate the UI captions
   }
}

但是当您收到一个新的业务规则要求您编写 Registrator3，它实际上根据某个参数进行注册，并且您将代码库更改为下一个：

public Base
{
   abstract void Register(externalParam);
}

public Registrator1: Base
{
   override void Register(externalParam)
   {
      //uses the current state of the object to populate theUI
   }
}

public Registrator2: Base
{
   override void Register(externalParam)
   {
      //uses the current state of the object to populate the UI
   }
}

public Registrator3: Base
{
   override void Register(externalParam)
   {
     //uses a DDD - service passed in the params to populate the UI
   }
}

但是 Registrator1 和 Registrator2 不需要该参数，并且代码变得很臭。有哪些方法可以重写这段代码？

Answer 1

您可以在这里使用对象作为参数；这通常用于参数数量可能根据所使用的调用而变化的场景。

struct RegistrationInfo
{
    public static readonly RegistrationInfo Empty = new RegistrationInfo();
    public string Username;
    public string CustomerName;
    public string Validity; 
}

abstract class Base
{
    public abstract void Register(RegistrationInfo info);
    // If you want to retain the paramaterless call:
    public void Register()
    {
         Register(RegistrationInfo.Empty);
    }
}

class Registrar1 : Base
{
    public override void Register(RegistrationInfo info)
    {
        if (info.Username == null) throw new ArgumentNullException("info.Username");
    }
}

class Registrar2 : Base
{
    public override void Register(RegistrationInfo info)
    {
        if (info.CustomerName == null) throw new ArgumentNullException("info.CustomerName");
    }
}

这样做的优点是您不需要在每次添加参数时更改方法参数（这会破坏接口）。用法也变得有点自我记录：

var r = new Registrar1();
r.Register(new RegistrationInfo(){ Username = "JimJoe" });
r.Register(RegistrationInfo.Empty);

它就像空气清新剂，用于这种类型的代码气味，虽然它仍然有臭味； 最后，您

可以通过将其设置为 params 参数来使调用站点更干净（这会产生少量开销）；老实说，虽然它更臭，因为它是一种语言黑客。最后你可以用泛型来改进它：

class RegistrationInfo
{

}

class RegistrationInfo1 : RegistrationInfo
{
    public string Arg;
}

class RegistrationInfo2 : RegistrationInfo
{
    public int Arg;
}

interface IBase<in TRegistration>
    where TRegistration : RegistrationInfo
{
    void Register(TRegistration registration);
}

class Base : IBase<RegistrationInfo>
{
    public void Register(RegistrationInfo registration)
    {

    }
}

class Registrar1 : IBase<RegistrationInfo1>
{
    public void Register(RegistrationInfo1 arg)
    {
    }
}

class Registrar2 : IBase<RegistrationInfo2>
{
    public void Register(RegistrationInfo2 arg)
    {
    }
}

Answer 2

是否不可能在Registrator3中包含externalParam的逻辑？
换句话说，Registrator3使用参数，然后调用未修改的无参数基数？

很大程度上取决于逻辑所属的位置。如果它是基类固有的东西，则将其放入基类中，并重载 Register() 函数或为参数提供默认值，以便子类不需要提供它。

Answer 3

假设您想重用基类中的注册逻辑，您可以按如下方式更新代码：

public class Base
{
   public virtual void Register(object externalParam)
   {
       // base registration logic goes here
   }
}

public class Registrator1: Base
{
   public override void Register(object externalParam)
   {
       base.Register(null);
       // custom registration logic goes here
   }
}

public class Registrator2: Base
{
   public override void Register(object externalParam)
   {
       base.Register(null);
       // custom registration logic goes here
   }
}

public class Registrator3: Base
{
   public override void Register(object externalParam)
   {
       base.Register(externalParam);
       // custom registration logic goes here
   }
}

HTH，

Cosmin

编辑：更新了要编译的代码。