Is using an interface an example of implementing the…

Yes, using interfaces is often part of implementing the Dependency Inversion Principle. The principle states that high-level modules should not depend on low-level modules, but both should depend on abstractions. Interfaces serve as these abstractions.

Instead of a high-level class A directly depending on a low-level class B, both depend on an interface I:

A uses methods defined in I.
B implements the I interface.

Thus, the dependency is "inverted": the high-level module now depends on an abstraction (the interface), not on the specific implementation of the low-level module.

Example:

Without dependency inversion:

// Low-level module
public class FileWriter
{
    public void Write(string data)
    {
        // Logic to write to a file
    }
}

// High-level module
public class ReportGenerator
{
    private FileWriter _writer;

    public ReportGenerator()
    {
        _writer = new FileWriter(); // Direct dependency on a specific implementation
    }

    public void GenerateReport(string reportData)
    {
        _writer.Write(reportData);
    }
}

With dependency inversion (using interface):

// Abstraction (interface)
public interface IDataWriter
{
    void Write(string data);
}

// Low-level module depending on abstraction
public class FileWriter : IDataWriter
{
    public void Write(string data)
    {
        // Logic to write to a file
    }
}

// Another low-level module depending on abstraction
public class DatabaseWriter : IDataWriter
{
    public void Write(string data)
    {
        // Logic to write to a database
    }
}

// High-level module depending on abstraction
public class ReportGenerator
{
    private readonly IDataWriter _writer; // Dependency on abstraction

    // Dependency injected via constructor (dependency injection)
    public ReportGenerator(IDataWriter writer)
    {
        _writer = writer;
    }

    public void GenerateReport(string reportData)
    {
        _writer.Write(reportData);
    }
}

In this case, ReportGenerator (high-level module) depends on IDataWriter (abstraction), not on specific implementations like FileWriter or DatabaseWriter. This allows easy replacement of the data writing implementation without changing ReportGenerator.

Is using an interface an example of implementing the dependency inversion principle?