Question

我将首先解释我尝试这样做的原因。我的初始层次结构：

Value

两个调用路径都触及基类的特定方法根据CalltoBase的来源，我需要使用该方法的不同实现。这就是我通常会做的事情：

BaseClass
   |
ControlClass
   |     \
CalltoBase  DerivedClass1
              |
            CalltoBase

问题是这个项目正在增长，并且有必要基类中的那个方法的更多实现。因此我想做这样的事情的原因，我愿意喜欢每次遇到这个时只需要创建一个额外的派生类而不是三个。

BaseClass____DerivedClass2
   |              |      
ControlClass   ControlClass2
   |    \             |    \
 call DerivedClass1  call  DerivedClass3
          call                 call

注意：除了调用行之外的每一行都是继承我没有权力或时间来改变系统，以便他们不会继承。

我的目标是做这样的事情：

BaseClass
  |      \______
ControlClass<t> \_____           
 |    \               \
call DerivedClass1<t>  tClass
       call

这样的事情是可能的，还是我应该接受，我每次都搞砸了并制作了所有衍生课程？

EDIT1 ***************************************** 在做了一些研究后，我认为我的真正问题是：如何在没有显式注入依赖项时，如何使用依赖注入覆盖方法或设置默认方法？

EDIT2 ***********

此代码全部位于公司创建的库中，并由许多项目使用。这是UAT使用selenium / specflow。

public class BaseClass{code}
public class tClass : BaseClass {code}
public class ControlClass<t> : t where t : BaseClass {code}
public class DerivedClass1<t> : ControlClass<t> where t : BaseClass {code}
//defaults
public class ControlClass : ControlClass<BaseClass> {empty}
public class DerivedClass1 : ControlClass<BaseClass> {empty}

更改pageName的部分是需要根据哪个项目是调用者来修改的部分。哪个派生类进行调用并不重要，重要的是实例化基类的类。

Answer 1

我认为在你的情况下更好地制作更复杂的基类 - 你的层次结构看起来像用于提供一些帮助和辅助功能的不和谐。将它水平拆分为服务并制作聚合可能更好，而不是制作难以理解的混合通用层次结构？

可能只是在类中使用.ctors进行初始化，可以将其更改为Factory？

为什么你确定你必须拥有拆分后合并层次结构？

糟糕的设计导致不好的问题。你可以用继承和泛型做任何事情，但如果你不得不这样做，那就好好想想......

Answer 2

通过使用覆盖，在基类上调用不同的方法，不应该这样吗？类似的东西：

public class BaseClass
{
    public virtual void FunctionA() { ... }
    public void FunctionAVariant1() { ... }
    public void FunctionAVariant2() { ... }
}

public class DerivedClass1 : BaseClass
{
    public override void FunctionA()
    {
        base.FunctionAVariant1();
    }
}

public class DerivedClass2 : BaseClass
{
    public override void FunctionA()
    {
        base.FunctionAVariant2();
    }
}

Answer 3

也许您可以检查一下您在基类中的类型。

public class BaseClass
{
    public void Call()
    {
        if (this is DerivedClass<int>)
        {
            CallInt();
        }
        else if (this is DerivedClass<string>)
        {
            CallString();
        }
        else
        {
            Console.WriteLine("Base class");
        }
    }

    public void CallInt()
    {
        Console.WriteLine("It's an int");
    }

    public void CallString()
    {
        Console.WriteLine("It's a string");
    }
}

public class DerivedClass<T> : BaseClass {

}

public class Program
{
    public static void Main()
    {
        var intClass = new DerivedClass<int>();
        var stringClass = new DerivedClass<string>();
        intClass.Call(); // writes 'It's an int'
        stringClass.Call(); // writes 'It's a string'
    }
}

如何在没有显式注入依赖项时，如何使用依赖注入覆盖方法或设置默认方法？

3 个答案: