C# Explicit Interface — Silent NotImplementedException

using System;

// The interface — a pure contract describing a capability.
// No fields, no constructor, no implementation (pre-C# 8 style).
public interface IGreeter
{
    // Any class implementing IGreeter MUST provide this method.
    // Access modifiers are implicitly public on interface members.
    string BuildGreeting(string recipientName);

    // Read-only property — implementors must expose a Name.
    string GreeterName { get; }
}

// FormalGreeter honours the contract in one way...
public class FormalGreeter : IGreeter
{
    public string GreeterName => "Corporate Bot";

    public string BuildGreeting(string recipientName)
    {
        // Formal implementation — very stiff.
        return $"Good day, {recipientName}. I trust you are well.";
    }
}

// CasualGreeter honours the same contract in a completely different way.
public class CasualGreeter : IGreeter
{
    public string GreeterName => "Buddy Bot";

    public string BuildGreeting(string recipientName)
    {
        // Casual implementation — same contract, totally different personality.
        return $"Hey {recipientName}! What's up?";
    }
}

public class Program
{
    // Notice: the parameter type is IGreeter, not FormalGreeter or CasualGreeter.
    // This method has NO idea which concrete class it receives — and it doesn't need to.
    static void PrintGreeting(IGreeter greeter, string name)
    {
        Console.WriteLine($"[{greeter.GreeterName}] says: {greeter.BuildGreeting(name)}");
    }

    static void Main()
    {
        IGreeter formal = new FormalGreeter();
        IGreeter casual = new CasualGreeter();

        PrintGreeting(formal, "Alice");  // Passes a FormalGreeter through IGreeter
        PrintGreeting(casual, "Bob");    // Passes a CasualGreeter through the same slot
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

// --- The Contract ---
// ProductService will ONLY ever know about this interface.
public interface IProductRepository
{
    IEnumerable<Product> GetAllProducts();
    Product? GetById(int productId);
    void AddProduct(Product product);
}

// --- The Domain Model ---
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
}

// --- Real Implementation (used in production) ---
// Imagine this hits SQL Server. We keep it simple here.
public class InMemoryProductRepository : IProductRepository
{
    // Simulates a database table in memory.
    private readonly List<Product> _products = new()
    {
        new Product { Id = 1, Name = "Mechanical Keyboard", Price = 129.99m },
        new Product { Id = 2, Name = "USB-C Hub",           Price = 49.99m  }
    };

    public IEnumerable<Product> GetAllProducts() => _products;

    public Product? GetById(int productId)
        => _products.FirstOrDefault(p => p.Id == productId);

    public void AddProduct(Product product)
    {
        // Auto-increment ID, just like a real DB sequence would.
        product.Id = _products.Count + 1;
        _products.Add(product);
    }
}

// --- Business Logic Layer ---
// ProductService has NO knowledge of how data is stored.
// It only talks to IProductRepository — could be SQL, Mongo, a flat file, anything.
public class ProductService
{
    private readonly IProductRepository _repository;

    // The repository is INJECTED — ProductService doesn't create it.
    public ProductService(IProductRepository repository)
    {
        _repository = repository;
    }

    public void DisplayAllProducts()
    {
        var products = _repository.GetAllProducts();
        Console.WriteLine("=== Product Catalogue ===");
        foreach (var product in products)
        {
            // Business formatting logic lives here, not in the repository.
            Console.WriteLine($"  [{product.Id}] {product.Name} — ${product.Price:F2}");
        }
    }

    public void AddNewProduct(string name, decimal price)
    {
        var newProduct = new Product { Name = name, Price = price };
        _repository.AddProduct(newProduct);
        Console.WriteLine($"Added: '{name}' with ID {newProduct.Id}");
    }
}

public class Program
{
    static void Main()
    {
        // Wire up the dependency: tell the app which concrete class backs the interface.
        // In ASP.NET Core this line lives in Program.cs / Startup.cs.
        IProductRepository repository = new InMemoryProductRepository();
        var service = new ProductService(repository);

        service.DisplayAllProducts();
        service.AddNewProduct("Wireless Mouse", 35.00m);
        service.DisplayAllProducts();
    }
}

using System;

// Two interfaces with a conflicting method signature.
public interface ICsvExporter
{
    // Export to CSV format.
    string Export(string filePath);
}

public interface IJsonExporter
{
    // Export to JSON format — same signature, totally different intent.
    string Export(string filePath);
}

public class DataExporter : ICsvExporter, IJsonExporter
{
    // Explicit implementation for ICsvExporter.
    // Note: NO access modifier — explicit implementations are always private by default.
    string ICsvExporter.Export(string filePath)
    {
        return $"Writing CSV data to: {filePath}.csv";
    }

    // Explicit implementation for IJsonExporter.
    string IJsonExporter.Export(string filePath)
    {
        return $"Writing JSON data to: {filePath}.json";
    }

    // You can still have a regular public method on the class itself.
    public string ExportSummary()
    {
        return "DataExporter supports both CSV and JSON formats.";
    }
}

public class Program
{
    static void Main()
    {
        var exporter = new DataExporter();

        // exporter.Export("report") — this would NOT compile.
        // Explicit implementations are only reachable via the interface reference.

        // Cast to the specific interface to get the right behaviour.
        ICsvExporter csvExporter   = exporter;
        IJsonExporter jsonExporter = exporter;

        Console.WriteLine(csvExporter.Export("sales_report"));
        Console.WriteLine(jsonExporter.Export("sales_report"));
        Console.WriteLine(exporter.ExportSummary());
    }
}

using System;
using System.Collections.Generic;

// Base interface — read-only capability.
public interface IReadableRepository<T>
{
    T? GetById(int id);
    IEnumerable<T> GetAll();

    // Default method added in C# 8 — existing implementors get this for free.
    // They can override it, but they don't HAVE to.
    bool Exists(int id) => GetById(id) != null;  // Default implementation uses GetById
}

// Extended interface — adds write capability on top of read.
public interface IWritableRepository<T> : IReadableRepository<T>
{
    void Add(T item);
    void Delete(int id);
}

public class Note
{
    public int Id { get; set; }
    public string Content { get; set; } = string.Empty;
}

// Implements the full read-write contract.
public class NoteRepository : IWritableRepository<Note>
{
    private readonly List<Note> _notes = new()
    {
        new Note { Id = 1, Content = "Buy groceries" },
        new Note { Id = 2, Content = "Review pull request" }
    };

    public Note? GetById(int id) => _notes.Find(n => n.Id == id);
    public IEnumerable<Note> GetAll() => _notes;

    public void Add(Note note)
    {
        note.Id = _notes.Count + 1;
        _notes.Add(note);
    }

    public void Delete(int id) => _notes.RemoveAll(n => n.Id == id);

    // We're NOT overriding Exists() — we're happy with the default implementation.
}

public class Program
{
    static void Main()
    {
        IWritableRepository<Note> notes = new NoteRepository();

        // Exists() comes from the default interface method — no override needed.
        Console.WriteLine($"Note 1 exists: {notes.Exists(1)}");   // Uses default
        Console.WriteLine($"Note 99 exists: {notes.Exists(99)}"); // Uses default

        notes.Add(new Note { Content = "Ship the feature" });
        notes.Delete(1);

        Console.WriteLine("\nRemaining notes:");
        foreach (var note in notes.GetAll())
        {
            Console.WriteLine($"  [{note.Id}] {note.Content}");
        }
    }
}

using System;
using System.Collections.Generic;

// Bad: Fat interface
public interface IDataManager
{
    void Connect();
    void Disconnect();
    IEnumerable<string> Query(string sql);
    int Insert(string table, Dictionary<string, object> data);
    void Update(string table, int id, Dictionary<string, object> data);
    void Delete(string table, int id);
    void ExportToCsv(string filePath);
    void Backup();
}

// Good: Segregated interfaces
public interface IConnectionManager
{
    void Connect();
    void Disconnect();
}

public interface IReadOnlyRepository
{
    IEnumerable<string> Query(string sql);
}

public interface IWriteOnlyRepository
{
    int Insert(string table, Dictionary<string, object> data);
    void Update(string table, int id, Dictionary<string, object> data);
    void Delete(string table, int id);
}

public interface IDataExporter
{
    void ExportToCsv(string filePath);
}

public interface IDataBackup
{
    void Backup();
}

// A class that only reads data now only implements what it needs
public class ReadOnlyReportService : IReadOnlyRepository
{
    public IEnumerable<string> Query(string sql)
    {
        // Real query logic
        Console.WriteLine($"Executing query: {sql}");
        return new[] { "row1", "row2" };
    }
}

// A full data manager implements all relevant interfaces
public class FullSqlDataManager : IConnectionManager, IReadOnlyRepository, IWriteOnlyRepository, IDataExporter, IDataBackup
{
    public void Connect() => Console.WriteLine("Connected");
    public void Disconnect() => Console.WriteLine("Disconnected");
    public IEnumerable<string> Query(string sql) { Console.WriteLine($"Query: {sql}"); return new[] { "result" }; }
    public int Insert(string table, Dictionary<string, object> data) { Console.WriteLine($"Insert into {table}"); return 1; }
    public void Update(string table, int id, Dictionary<string, object> data) => Console.WriteLine($"Update {table}:{id}");
    public void Delete(string table, int id) => Console.WriteLine($"Delete from {table}:{id}");
    public void ExportToCsv(string filePath) => Console.WriteLine($"Export to {filePath}");
    public void Backup() => Console.WriteLine("Backup completed");
}

public class Program
{
    static void Main()
    {
        // Report service only uses read interface
        IReadOnlyRepository reader = new ReadOnlyReportService();
        var data = reader.Query("SELECT * FROM Products");
        Console.WriteLine(string.Join(", ", data));

        // Admin tool uses full set
        var full = new FullSqlDataManager();
        ((IConnectionManager)full).Connect();
        ((IWriteOnlyRepository)full).Insert("Products", new() { { "Name", "Laptop" } });
    }
}