c# - 接口(interface)和抽象类在解耦方面的区别？

Question

众所周知，接口(interface)和抽象类之间基本上有两个重要的区别。

1. 我们可以在抽象类中定义函数。当我们想在一个类中添加一个函数而不需要追踪它的所有实现时，这是有利的。

2. 我们可以有多个接口(interface)实现。

我才知道我们可以在解耦方面区分它们？

您的评论...

另外，如果你能提供一个非常基本的链接来解释接口(interface)和抽象类的解耦？

我们通常使用业务逻辑层、数据访问层(包含抽象函数)和DataAccess.SqlServer层。正确的？尽管我们知道业务需求，但为什么我们要创建数据访问层(包含抽象函数)，为什么业务逻辑层不能直接访问DataAccess.SqlServer层?

Answer 1

解耦

在编程和设计中，这通常是使代码在尽可能少的依赖下可重用的行为。

这种情况下的工厂模式

当使用工厂模式时，你有一个集中的工厂，它可以创建对象而不必自己定义它们。这取决于对象的定义。

抽象与界面

界面

定义接口(interface)是最佳实践，因为它允许使用轻量级类型进行推理，还提供了所有继承类必须遵守的蓝图。例如，IDisposable 必须实现 Dispose 方法。请注意，这与接口(interface)分离，因为每个继承 IDisposable 的类都将定义其自己的 Dispose 方法函数。

摘要

Abstract 类似于接口(interface)，用于继承和推理，但它包含所有类将继承的定义。每辆汽车都会有一个引擎，因此一个好的汽车抽象类可以包含一组预定义的引擎方法。

编辑

解释

在这里您将看到一个使用接口(interface)和抽象类进行继承的简单示例。当接口(interface)被抽象类继承，然后它的方法被定制时，就会发生解耦。这允许类继承抽象类并且仍然具有与接口(interface)相同的类型。好处是当期望类型为原始接口(interface)时，可以使用继承抽象类的类。

解耦

该优势允许使用符合预期接口(interface)的任何实现。因此，可以编写和传递许多不同的重载。这是一个示例。

示例

接口(interface)定义

public interface IReady
{
    bool ComputeReadiness();
}

继承

public abstract class WidgetExample : IReady
{
    public int WidgetCount { get; set; }
    public int WidgetTarget { get; set; }
    public bool WidgetsReady { get; set; }

    public WidgetExample()
    {
        WidgetCount = 3;
        WidgetTarget = 45;
    }

    public bool ComputeReadiness()
    {
        if (WidgetCount < WidgetTarget)
        {
            WidgetsReady = false;
        }
        return WidgetsReady;
    }
}


public class Foo : WidgetExample
{
    public Foo()
    {
        this.WidgetTarget = 2;
    }
}

public class Bar : IReady
{
    public bool ComputeReadiness()
    {
        return true;
    }
}

解耦

public class UsesIReady
{
    public bool Start { get; set; }
    public List<string> WidgetNames { get; set; }

    //Here is the decoupling. Note that any object passed
    //in with type IReady will be accepted in this method
    public void BeginWork(IReady readiness)
    {
        if (readiness.ComputeReadiness())
        {
            Start = true;
            Work();
        }
    }

    private void Work()
    {
        foreach( var name in WidgetNames )
        {
            //todo: build name
        }
    }
}

多态性

public class Main
{
    public Main()
    {
        //Notice that either one of these implementations 
        //is accepted by BeginWork

        //Foo uses the abstract class
        IReady example = new Foo();
        UsesIReady workExample = new UsesIReady();
        workExample.BeginWork(example);

        //Bar uses the interface
        IReady sample = new Bar();
        UsesIReady workSample = new UsesIReady();
        workSample.BeginWork(sample);
    }
}