Σε ποιες περιπτώσεις και για ποιους σκοπούς…

Οι διεπαφές στη C# χρησιμοποιούνται για τους ακόλουθους σκοπούς:

Ορισμός συμβολαίου: Μια διεπαφή ορίζει ένα σύνολο μελών (μεθόδους, ιδιότητες, γεγονότα, δείκτες), τα οποία μια κλάση ή δομή που υλοποιεί αυτή τη διεπαφή πρέπει να υλοποιήσει. Αυτό διασφαλίζει ομοιομορφία στη συμπεριφορά διαφορετικών τύπων.
```
// Ορισμός διεπαφής
public interface IDrawable
{
    void Draw();
    int LineThickness { get; set; }
}

// Κλάση που υλοποιεί τη διεπαφή
public class Circle : IDrawable
{
    public int LineThickness { get; set; }

    public void Draw()
    {
        // Λογική σχεδίασης κύκλου
    }
}
```
Πολυμορφισμός: Η χρήση διεπαφών επιτρέπει την εργασία με αντικείμενα διαφορετικών τύπων μέσω γενικού τύπου διεπαφής. Αυτό επιτυγχάνεται επειδή οποιαδήποτε αναφορά σε αντικείμενο που υλοποιεί μια διεπαφή μπορεί να μετατραπεί στον τύπο αυτής της διεπαφής.
```
// Μέθοδος που λειτουργεί με οποιοδήποτε αντικείμενο που υλοποιεί το IDrawable
public void Render(IDrawable item)
{
    item.Draw(); // Καλείται η συγκεκριμένη υλοποίηση της μεθόδου Draw
}

// Χρήση:
IDrawable circle = new Circle();
Render(circle); // Θα κληθεί η υλοποίηση Draw() από την κλάση Circle
```

Πολλαπλή κληρονομικότητα (Multiple Inheritance): Η C# δεν υποστηρίζει πολλαπλή κληρονομικότητα κλάσεων, αλλά επιτρέπει σε μια κλάση ή δομή να υλοποιεί πολλές διεπαφές. Αυτό επιτρέπει στον τύπο να έχει συμπεριφορά που ορίζεται σε διαφορετικά "συμβόλαια".

public interface ISaveable
{
    void Save();
}

public interface ILoadable
{
    void Load();
}

// Κλάση που υλοποιεί πολλές διεπαφές
public class ConfigurationManager : ISaveable, ILoadable
{
    public void Save()
    {
        // Λογική αποθήκευσης
    }

    public void Load()
    {
        // Λογική φόρτωσης
    }
}

Αδύναμη συσχέτιση (Decoupling): Η χρήση διεπαφών μειώνει την εξάρτηση μεταξύ των συστατικών. Αντί να εξαρτάται από μια συγκεκριμένη κλάση, ένα συστατικό μπορεί να εξαρτάται από μια διεπαφή. Αυτό διευκολύνει την αντικατάσταση υλοποιήσεων και τον έλεγχο.

public interface ILogger
{
    void LogMessage(string message);
}

public class FileLogger : ILogger
{
    public void LogMessage(string message)
    {
        // Λογική εγγραφής σε αρχείο
    }
}

public class DatabaseLogger : ILogger
{
    public void LogMessage(string message)
    {
        // Λογική εγγραφής στη βάση δεδομένων
    }
}

public class ProcessingEngine
{
    private readonly ILogger _logger;

    // Εξάρτηση από διεπαφή, όχι από συγκεκριμένη υλοποίηση
    public ProcessingEngine(ILogger logger)
    {
        _logger = logger;
    }

    public void ProcessData()
    {
        // ...
        _logger.LogMessage("Δεδομένα επεξεργάστηκαν.");
    }
}

Επεκτασιμότητα: Οι διεπαφές επιτρέπουν την εύκολη προσθήκη νέων υλοποιήσεων της υπάρχουσας συμπεριφοράς χωρίς να αλλάζει ο κώδικας που χρησιμοποιεί αυτή τη διεπαφή.
Τεκμηρίωση και αυτοτελής τεκμηρίωση: Μια καλά ονοματοδοτημένη διεπαφή με σχόλια στα μέλη της λειτουργεί ως μορφή τεκμηρίωσης, περιγράφοντας τη συμπεριφορά που αναμένεται από τα αντικείμενα που υλοποιούν αυτή τη διεπαφή.

Σε ποιες περιπτώσεις και για ποιους σκοπούς χρησιμοποιούμε interfaces σε C#;