每个实体都实现了接口？

Question

目前，我正在从事应用程序架构的工作，我在我的项目中有许多实体，即学生师范大学，我想知道所有实体都必须实现接口是不是一个好的做法。这对我的依赖注入有帮助吗？从架构的角度来看，最佳实践是什么？

 public interface IMyEntity
    {
          //an empty interface
    }
public class Student:IMyEntity
{

}
public class Teacher:IMyEntity
{

}

//hi我可以处理实现IMyEntity的每个对象

void Display(IMyEntity entity) //this function can be in some class
{
    // if IMyEntity is teacher behave like a teacher
    // if IMyEntity is student behave like sutdent
}

我知道接口是一种契约，但从架构的角度来看，这是最佳实践吗？我知道我的IMyEntity接口是空的。

Answer 1

不一定。如果在这种情况下，学生和教师有一些共同的功能，那么共享界面将是一种方法。

public void Display(IUniPerson person)
{
    var name = person.Name; // Everyone, student or teacher, has a name
    ...
}

但是，您给出的示例似乎表明事实并非如此，Display方法将尝试根据传入的IMyEntity实例的类型对其进行不同的处理。在这种情况下，使用两种具有不同参数的显示方法可能会更好。

public void Display(ITeacher teacher) { // teacher processing }
public void Display(IStudent student) { // student processing }

tl:dr版本:跨多个类实现一个接口，如果这些类实现相关的方法和函数是有意义的，而不是仅仅作为一个综合规则。

Answer 2

我认为从开发的角度来看，解耦2个或更多的类是一种很好的体验，而且它确实有助于长期维护代码。

考虑以下场景：

static void Main(string[] args)
{
    var objA = new A();
    var objB = new B(objA);
}

public class A {}

public class B 
{
  public B(A obj)
  {
    //Logic Here
  }
}

这段代码的问题是，它是强耦合的，类B需要A类被实例化，并执行它的业务。

如果你确定B永远不会有戏剧性的变化，这不是问题。

现在，如果我们想要将其解耦，我们可以进行第一次改进，实现如下接口

static void Main(string[] args)
{
    var objA = new A();
    var objB = new B(objA);
}

public interface IA()
{
    //TODO
}

public class A : IA {}

public class B 
{
  public B(IA obj)
  {
    //Logic Here
  }
}

这看起来很好，我们仍然有一个主要的耦合问题，所以在这一点上，我们将不得不实现一个像这样的IOC依赖注入，我们的代码将类似于：

static void Main(string[] args)
{
    var objB = new B();
}

public interface IA()
{
    //TODO
}

public class A : IA {}

public class B 
{
  public B(IA obj)
  {
    //Logic Here
  }
}

是的，看起来不错。我们已经完全消除了耦合的问题，如果在未来我们只需要取A，删除它，并用一些新的更酷的东西来替换它，这将是非常容易的。

显然，过度夸大了这是一种糟糕的做法，和我相信DI必须在仔细计划之后才能使用，以避免无用的实现。

例如，如果我有一个C类，它有一些基本的操作，我确信它永远不会改变，或者有一些戏剧性的更新需求，我可以避免DI。

那么，您是否必须在项目中的每个模型上实现接口？

我不认为你的项目中的每个模型都需要实现一个接口或DI，只要考虑一下，看看在哪里是有用的，在哪里只是夸大了。

Answer 3

是的，像这样做，这是最好的做法。这为您提供了多态性的优势。你应该在当前上下文中以更好的方式来做这件事，因为Student不是一个Teacher。如果你想共享公共接口，你应该把它定义为：IUniversityMember。这里有一个你的案例的例子，我想它会让你明白。

public interface IUniversityMember
{
   //... here common fields between `Teacher` and `Student`
   string Name{ get; set;}
   string Gender { get; set;}
}

//after that

public interface IStudent
{
    int GetGPA();
    int CreditsToPass {get; private set;}
}

public interface ITeacher
{
   int WorkedHours {get; set;}
   decimal PayPerHour {get; private set;}
}

public class BiologicalStudent: IUniversityMember, IStudent
{
    public int CreditsToPast {get; private set;}

    public BiologicalStudent ()
    {
        CreditsToPast  = 5;
    }
    //stuff
    public int GetGPA()
    {
        return 3;
    }
}

public class MathStudent: IUniversityMember, IStudent
{
    public int CreditsToPast {get; private set;}

    public BiologicalStudent ()
    {
        CreditsToPast  = 9;
    }

    public int GetGPA()
    {
        return 2;
    }
}

public class BiologicalTeacher: IUniversityMember, ITeacher
{
     public int WorkedHours { get; set;}
     public decimal PayPerHour {get; private set;}

     public MathTeacher()
     {
         PayPerHour = 8;

     }
}

public class MathTeacher: IUniversityMember, ITeacher
{
     public int WorkedHours { get; set;}
     public decimal PayPerHour {get; private set;}

     public MathTeacher()
     {
         PayPerHour = 10;

     }
}
//Now if you have a university class

public class OxfordUniversity:IUniversity //can inherit interface too
{
     public int MinGAPForSchollarship {get; private set;}

     public OxfordUniversity()
     {
         MinGAPForSchollarship = 3;
     }

     public decimal PaySallary(ITeacher teacher)
     {
          return teacher.WorkedHours*teacher.PayPerHour;
     }

     public bool CheckForSchollarship(IStudent student)
     {
         int gpa = student.GetGPA();
         //do some checks

         if(gpa >= MinGAPForSchollarship)
            return true;

         return false;
     }
}