在C#中跨类强制实现方法命名一致性

我在一个项目中有一系列的类，它们基本上做相同的事情，但在不同的对象上。由于其中一些代码是在不同的时间由不同的人编写的，因此在命名上存在一些不一致性。我希望以一种不仅在当前对象中而且在将来创建的新对象中强制实现某种一致性的方式来更新代码。我对编程的理解使我相信我需要一个基类或接口，但我不知道如何让它们都工作。我想要的方法是：

internal BusinessObject MethodA(EntityObject entity)
internal Void MethodB(EntityContext context, BusinessObject obj, EntityObject entity)

我遇到的问题是，在每个类中，“BusinessObject”和“EntityObject”将是不同的，例如，在一个类中可能是“CarObject和CarEntity”，而在另一个类中可能是“BusObject和BusEntity”。我仍然想要这两个方法，我仍然想要它们命名为MethodA和MethodB，我只是想在实现中交换掉实际的对象类型。实现本身将不同，因为它们使用不同的对象

我在编译时知道对象类型，并且需要能够访问对象的属性，因此如果使用泛型，我需要在实现中将泛型转换为正确的类型。此外，MethodA的实现还需要创建一个“新”业务对象，即“BusinessObject x=new BusinessObject（）”，如果这有什么不同的话

我尝试在方法中使用泛型接口，也尝试使用抽象方法基类，但我还没有弄清楚如何使两者都起作用

处理这个问题的最佳方法是什么？示例代码将不胜感激。

泛型是最好的选择

因此，我将按照以下思路声明一个接口（或基类，如果您喜欢该路由）：

internal interface IEntityContext<TEntity>
{
 ???
}

internal interface IMyInterfaceName<TEntity, TBusinessObject>
{
TBusinessObject MethodA(TEntity entity);
Void MethodB(IEntityContext<TEntity> context, TBusinessObject obj, TEntity entity);
}

内部接口IEntityContext
{
???
}
内部接口IMyInterfaceName
{
t业务对象方法A（潜在实体）；
无效方法B（IEntityContext上下文、TBusinessObject对象、TEntity实体）；
}

然后，在实现类时：

class MyClassThatDoesThisStuff : IMyInterfaceName<Farm, FarmBo>
{
    internal FarmBo MethodA(Farm entity);
    internal Void MethodB(IEntityContext<Farm> context, FarmBo obj, Farm entity);

}

classmyclassthat做这件事：IMyInterfaceName
{
内部FarmBo MethodA（农场实体）；
内部无效方法B（IEntityContext上下文、FarmBo对象、Farm实体）；
}

等等

您还可以强制您的类从以下内容派生：

interface IMyInterfaceName<TEntity, TBusinessObject> 
            where TEntity : EntityBase,
                  TBusinessObject : BusinessObjectBase
{
...
}

接口IMyInterfaceName
其中tenty:EntityBase，
t业务对象：业务对象库
{
...
}

泛型是解决方法

因此，我将按照以下思路声明一个接口（或基类，如果您喜欢该路由）：

internal interface IEntityContext<TEntity>
{
 ???
}

internal interface IMyInterfaceName<TEntity, TBusinessObject>
{
TBusinessObject MethodA(TEntity entity);
Void MethodB(IEntityContext<TEntity> context, TBusinessObject obj, TEntity entity);
}

内部接口IEntityContext
{
???
}
内部接口IMyInterfaceName
{
t业务对象方法A（潜在实体）；
无效方法B（IEntityContext上下文、TBusinessObject对象、TEntity实体）；
}

然后，在实现类时：

class MyClassThatDoesThisStuff : IMyInterfaceName<Farm, FarmBo>
{
    internal FarmBo MethodA(Farm entity);
    internal Void MethodB(IEntityContext<Farm> context, FarmBo obj, Farm entity);

}

classmyclassthat做这件事：IMyInterfaceName
{
内部FarmBo MethodA（农场实体）；
内部无效方法B（IEntityContext上下文、FarmBo对象、Farm实体）；
}

等等

您还可以强制您的类从以下内容派生：

interface IMyInterfaceName<TEntity, TBusinessObject> 
            where TEntity : EntityBase,
                  TBusinessObject : BusinessObjectBase
{
...
}

接口IMyInterfaceName
其中tenty:EntityBase，
t业务对象：业务对象库
{
...
}

为了展示带有抽象基类的解决方案，请参阅Neils答案以了解更多信息

public abstract class BaseClass<A,B> {
    internal abstract A MethodA(B entity);
    internal abstract void MethodB(EntityContext context, A obj, B entity);
}

公共抽象类基类{
内部摘要A方法A（B实体）；
内部抽象void方法B（EntityContext上下文，A对象，B实体）；
}

然后扩展这个类：

public class AClass : BaseClass<BusinessObject, EntityObject> {
    internal override BusinessObject MethodA(EntityObject entity) {...}
    internal override void MethodB(EntityContext ctx, BusinessObject obj, EntityObject entity) {...}
}

公共类AClass:BaseClass{
内部重写BusinessObject方法A（EntityObject实体）{…}
内部重写无效方法B（EntityContext ctx、BusinessObject obj、EntityObject实体）{…}
}

为了展示带有抽象基类的解决方案，请参阅Neils答案以了解更多信息

public abstract class BaseClass<A,B> {
    internal abstract A MethodA(B entity);
    internal abstract void MethodB(EntityContext context, A obj, B entity);
}

公共抽象类基类{
内部摘要A方法A（B实体）；
内部抽象void方法B（EntityContext上下文，A对象，B实体）；
}

然后扩展这个类：

public class AClass : BaseClass<BusinessObject, EntityObject> {
    internal override BusinessObject MethodA(EntityObject entity) {...}
    internal override void MethodB(EntityContext ctx, BusinessObject obj, EntityObject entity) {...}
}

公共类AClass:BaseClass{
内部重写BusinessObject方法A（EntityObject实体）{…}
内部重写无效方法B（EntityContext ctx、BusinessObject obj、EntityObject实体）{…}
}

实际上有三种方法：

泛型：指定容器对象的方式与BusinessObject和EntityObject的类型无关。您可以稍微扩展它，对泛型接受为带有泛型约束的参数的对象类型施加限制。最大的挑战是，如果没有强制转换和其他相对不安全的操作，很难实际使用BusinessObject和EntityObject

继承：在这种情况下，您将BusinessObject实现为基类，并要求用作参数的所有对象都从该基类派生，EntityObject也是如此。然后，您可以将实际需要使用的任何方法放入基类中（如有必要，还可以在派生类中重写它们）

接口：这是两者之间的一半。这里您说BusinessObject和EntityObject是接口（传统上，它们的名称将以I开头，如IBusinessObject等）。这里您在接口中指定需要任何BusinessObject或EntityObject实现的方法，并因此可以在容器对象中调用它们

---

因此，由于你提供的信息有限，不可能说哪一个是最合适的。但是，这是您的三个基本选择。

实际上有三种方法：

泛型：指定容器对象的方式与BusinessObject和EntityObject的类型无关。您可以稍微扩展它，对泛型接受为带有泛型约束的参数的对象类型施加限制。大挑战