C# 接口（Interface）

22.C# 接口（Interface）——《跟老吕学C#》
C# 接口（Interface）
一、接口的定义
二、接口的实现
三、接口的继承
四、接口的使用
1. 接口的声明
2. 接口的实现
3. 接口的多重继承
4. 接口的使用场景
五、特殊接口
1. 非托管资源
2. 实现`IDisposable`接口
3. 使用`IDisposable`接口的最佳实践
六、接口与抽象类的比较
1. 抽象类
2. 接口
3. 选择使用接口还是抽象类
七、接口作为参数和返回值
1. 作为方法参数
2. 作为返回值
总结

C# 接口（Interface）
在C#编程语言中，接口（Interface）是一个非常重要的概念，它允许我们定义一组方法、属性、事件或索引器的规范，但不提供这些成员的具体实现。接口是面向对象编程中实现多态性和代码复用的关键工具。

一、接口的定义
接口使用interface关键字声明，与类的声明类似，但接口的成员默认都是抽象的，即它们只声明成员而不提供实现。下面是一个简单的接口定义示例：

public interface IMyInterface
{
    void MyMethod();
    int MyProperty { get; set; }
    event EventHandler MyEvent;
    string this[int index] { get; set; }
}
1
2
3
4
5
6
7
在这个例子中，IMyInterface是一个接口，它定义了一个无参数的方法MyMethod、一个可读写的属性MyProperty、一个事件MyEvent和一个索引器。

二、接口的实现
接口不能单独存在，也不能直接实例化。它们必须由类或其他接口来实现。实现接口的类必须提供接口中所有成员的具体实现。下面是一个类实现接口的示例：

public class MyClass : IMyInterface
{
    public void MyMethod()
    {
        // 实现接口方法的代码
        Console.WriteLine("MyMethod called from MyClass");
    }

    public int MyProperty { get; set; } // 实现接口属性的代码

    public event EventHandler MyEvent; // 实现接口事件的代码

    public string this[int index]
    {
        get { /* 实现索引器的getter */ }
        set { /* 实现索引器的setter */ }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
在这个例子中，MyClass类实现了IMyInterface接口，并为接口中的所有成员提供了具体的实现。

三、接口的继承
接口可以继承自其他接口，这允许我们创建更复杂的接口层次结构。当一个接口继承自另一个接口时，它继承了基接口中定义的所有成员。下面是一个接口继承的示例：

public interface IMyInterface
{
    void MyMethod();
}

public interface IAnotherInterface : IMyInterface
{
    void AnotherMethod();
}
1
2
3
4
5
6
7
8
9
在这个例子中，IAnotherInterface接口继承自IMyInterface接口，并添加了一个新的方法AnotherMethod。任何实现IAnotherInterface接口的类都必须同时实现IMyInterface和IAnotherInterface中的所有成员。

接口继承在软件开发中有很多应用场景，特别是当我们想要创建一种“是-也-是”关系时。例如，如果我们有一个IAnimal接口和一个IFlyable接口，我们可能想要创建一个IBird接口，它既是动物，又能飞行。这时，我们就可以通过接口继承来实现：

public interface IAnimal
{
    void Eat();
    void Sleep();
}

public interface IFlyable
{
    void Fly();
}

public interface IBird : IAnimal, IFlyable
{
    // IBird 可以添加特定的鸟类方法或属性，但这里我们假设它仅包含继承的方法
}

// 某个类实现IBird接口
public class Sparrow : IBird
{
    public void Eat()
    {
        Console.WriteLine("Sparrow is eating.");
    }

    public void Sleep()
    {
        Console.WriteLine("Sparrow is sleeping.");
    }

    public void Fly()
    {
        Console.WriteLine("Sparrow is flying.");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
在上面的例子中，IBird接口同时继承了IAnimal和IFlyable接口，这意味着任何实现IBird接口的类（如Sparrow）都必须实现Eat、Sleep和Fly这三个方法。

接口继承的一个关键优势是它可以促进代码的重用和模块化。通过将通用的功能或行为定义为接口，并允许其他接口继承这些接口，我们可以创建更加灵活和可维护的代码库。同时，接口继承也支持了多态性的概念，使得我们可以在运行时根据对象的实际类型来调用不同的方法实现。

四、接口的使用
在C#中，接口的主要用途之一是定义一组行为或特征的契约，然后由不同的类来实现这些行为或特征。通过使用接口，我们可以编写更加灵活和可维护的代码，因为我们可以将代码与特定的实现细节隔离开来。此外，接口还支持多重继承，即一个类可以实现多个接口，从而支持多种不同的行为或特征。

1. 接口的声明
在C#中，接口使用interface关键字进行声明。接口声明中只包含方法的签名，不包含方法的实现。下面是一个简单的接口示例：

public interface IAnimal
{
    void Eat();
    void Sleep();
    string Sound();
}
1
2
3
4
5
6
这个IAnimal接口定义了三个方法：Eat、Sleep和Sound。任何实现这个接口的类都必须提供这三个方法的具体实现。

2. 接口的实现
类可以使用冒号和接口名称来声明它实现了某个接口。然后，该类必须为接口中的每个方法提供具体的实现。

public class Dog : IAnimal
{
    public void Eat()
    {
        Console.WriteLine("Dog is eating dog food.");
    }

    public void Sleep()
    {
        Console.WriteLine("Dog is sleeping.");
    }

    public string Sound()
    {
        return "Woof!";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
在这个例子中，Dog类实现了IAnimal接口，并为其中的每个方法提供了具体的实现。

3. 接口的多重继承
C#中的类可以实现多个接口，这允许类支持多种不同的行为或特征。

public interface IFlyable
{
    void Fly();
}

public class Bird : IAnimal, IFlyable
{
    // IAnimal接口的方法实现
    public void Eat() { /* ... */ }
    public void Sleep() { /* ... */ }
    public string Sound() { /* ... */ }

    // IFlyable接口的方法实现
    public void Fly()
    {
        Console.WriteLine("Bird is flying.");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
在这个例子中，Bird类同时实现了IAnimal和IFlyable两个接口，因此它支持动物的基本行为（吃、睡和发声）以及飞行的能力。

4. 接口的使用场景
接口在以下场景中特别有用：

定义插件系统：当你希望创建一个可以动态加载不同实现的系统时，接口是一个很好的选择。插件可以实现相同的接口，但提供不同的实现。
支持多态性：接口允许你编写不依赖于具体实现的代码。这意味着你可以将实现了同一接口的多个类的对象视为相同的类型，并根据需要进行处理。
提高代码的灵活性：通过将代码与实现细节隔离开来，接口允许你更容易地修改和扩展代码。你可以在不修改现有代码的情况下添加新的实现或更改现有实现。
强制实现特定功能：接口可以定义一组必须实现的方法，从而确保任何实现该接口的类都支持特定的功能或行为。

五、特殊接口
C#中还有一些特殊的接口，如IDisposable接口。IDisposable接口定义了一个Dispose方法，用于释放非托管资源。任何实现IDisposable接口的类都应该在其Dispose方法中释放其占用的非托管资源，以防止资源泄漏。

1. 非托管资源
在C#中，资源分为托管资源和非托管资源。托管资源是由.NET运行时自动管理的，如内存中的对象。而非托管资源则是由操作系统或其他非.NET组件管理的，如文件句柄、数据库连接、非托管内存等。由于.NET运行时无法自动管理非托管资源，因此我们需要通过实现IDisposable接口来确保这些资源在使用完毕后得到正确释放。

2. 实现IDisposable接口
实现IDisposable接口需要定义一个名为Dispose的方法，该方法没有参数且没有返回值。在Dispose方法中，我们应该释放所有占用的非托管资源，并将对象设置为不可用状态，以防止在资源已经释放后再次使用。

以下是一个简单的示例，展示了一个实现IDisposable接口的类：

public class ResourceOwner : IDisposable
{
    // 假设这是一个非托管资源，如文件句柄
    private SafeHandle resource;

    public ResourceOwner()
    {
        // 分配非托管资源
        resource = SafeHandle.Allocate();
    }

    // 实现IDisposable接口的Dispose方法
    public void Dispose()
    {
        // 检查资源是否已经被释放
        if (resource != null && !resource.IsInvalid)
        {
            // 释放非托管资源
            resource.Dispose();

            // 将资源设置为null，表示已经释放
            resource = null;

            // 通知垃圾回收器，此对象不再包含任何托管资源
            GC.SuppressFinalize(this);
        }
    }

    // 析构函数（可选），用于在对象被垃圾回收时释放资源
    ~ResourceOwner()
    {
        Dispose(false);
    }

    // 受保护的Dispose方法，带有布尔参数表示是否由析构函数调用
    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            // 释放托管资源（如果有的话）
            // 在这里我们没有托管资源要释放，因此留空
        }

        // 释放非托管资源
        if (resource != null)
        {
            resource.Dispose();
            resource = null;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
在上面的示例中，我们定义了一个名为ResourceOwner的类，它持有一个名为resource的非托管资源（在此示例中，我们使用了一个假设的SafeHandle类来表示非托管资源）。ResourceOwner类实现了IDisposable接口，并在其Dispose方法中释放了resource。此外，我们还提供了一个析构函数（在C#中表示为~ResourceOwner）和一个受保护的Dispose方法（带有布尔参数），以支持在对象被垃圾回收时释放资源。这是实现IDisposable接口的一种常见模式，称为“Dispose模式”或“释放模式”。

3. 使用IDisposable接口的最佳实践
在使用实现IDisposable接口的类时，应始终在不再需要该对象时调用其Dispose方法。这可以通过使用using语句或显式调用Dispose方法来实现。
如果类实现了IDisposable接口，则应该在其析构函数中调用受保护的Dispose(false)方法，以确保在对象被垃圾回收时释放资源。但是，请注意，析构函数并不是释放资源的首选方式，因为它在程序的生命周期中可能不会被及时调用。因此，最好总是显式调用Dispose方法。
避免在Dispose方法中引发异常。如果必须抛出异常，请确保在抛出之前释放所有资源，并将异常包装在另一个异常中，以便调用者可以了解发生了什么问题。
在实现IDisposable接口时，请务必遵循上述的最佳实践，以确保资源的正确管理和释放。

六、接口与抽象类的比较
虽然接口和抽象类在C#中都用于定义抽象成员，但它们之间存在一些关键的区别。

1. 抽象类
抽象类可以包含非抽象成员（字段、属性、方法等），而接口只能包含抽象成员。
抽象类可以使用sealed关键字来防止其他类继承，而接口总是隐式地继承自System.Object，并且可以被任何类继承。
抽象类可以实现接口，而接口不能实现另一个接口（只能继承）。
抽象类中的抽象成员可以是虚成员（virtual），而接口中的成员默认都是抽象的。
2. 接口
接口只能包含抽象成员，即成员没有实现。
接口不能被实例化，只能被类或其他接口实现。
接口支持多重继承，即一个类可以实现多个接口。
接口提供了一种契约机制，用于定义一组需要被实现的行为或特征。
3. 选择使用接口还是抽象类
如果你想要定义一组需要被所有子类共享的行为或状态，那么应该使用抽象类。
如果你想要定义一组契约，这些契约可以由不同的类以不同的方式实现，那么应该使用接口。
在某些情况下，你可能会发现将接口和抽象类结合使用是最合适的，即在一个抽象类中定义一些共享的行为或状态，并使用接口来定义需要被所有子类实现的契约。

七、接口作为参数和返回值
接口可以作为方法参数和返回值的类型，这进一步增强了接口的灵活性和可重用性。

1. 作为方法参数
当方法接受一个接口作为参数时，它可以接受任何实现了该接口的类的实例。这使得方法可以与不同的实现进行交互，而不需要关心具体的实现细节。

public void ProcessData(IMyInterface data)
{
    // 使用data对象的方法、属性等
}
1
2
3
4
2. 作为返回值
当方法返回一个接口时，调用者可以接收任何实现了该接口的类的实例。这使得方法可以在不暴露具体实现的情况下返回数据。

public IMyInterface GetData()
{
    // 返回一个实现了IMyInterface的类的实例
}
1
2
3
4

总结
接口是C#编程中非常重要的概念，它允许我们定义一组行为或特征的契约，并由不同的类来实现这些行为或特征。通过使用接口，我们可以编写更加灵活、可维护和可重用的代码。在选择使用接口还是抽象类时，我们需要根据具体的需求和场景来做出决策。最后，我们还探讨了接口作为方法参数和返回值的用法，这进一步展示了接口在C#编程中的强大功能。
————————————————

                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.csdn.net/molangmolang/article/details/140070819