Applying the Law of Demeter in C#: Creating Maintainable and Modular Code

Welcome to the third lesson of the "Applying Clean Code Principles" course. In our journey so far, we've discussed the importance of the DRY (Don't Repeat Yourself) principle to eliminate redundancy in code. We followed that with the KISS (Keep It Simple, Stupid) principle, which highlights the value of simplicity in software development. Today, our focus is on the Law of Demeter — a key guideline in object-oriented programming. By limiting the knowledge that an object has about other objects, this lesson will guide you in crafting more maintainable and modular code. 🤓

The Law of Demeter was introduced by Karl J. Lieberherr and suggests that an object should only communicate with its immediate collaborators, avoiding the entire system. By reducing dependency between parts, you'll find your code easier to maintain and scale. In simple terms, a method X of the class C should only call methods of:

• Class C itself
• An object created by X
• An object passed as an argument to X
• An object held in an instance variable of C
• A static field

With these principles, you control how parts of your application interact, leading to a more organized structure. Let's explore how this works with examples. 🚀

For the first point, a method should only access its own class's methods:

class Car {
    public void Start() {
        // First Rule: Accessing methods within the same class
        this.CheckFuel(); // Accessing own class method
        this.Ignite();    // Accessing own class method
    }
    
    private void CheckFuel() {
        Console.WriteLine("Checking fuel level...");
    }
    
    private void Ignite() {
        Console.WriteLine("Igniting the engine...");
    }
}

In this example, the Start method interacts solely with methods within the Car class itself. This shows how you maintain clear boundaries adhering to the Law of Demeter.

Next, a method can interact with the objects it creates:

class Library {
    public Book BorrowBook(string title) {
        // Second Rule: Interacting with objects created by the method
        Book book = new Book(title); // Creating a new object
        book.Issue();                // Interacting with the created object
        return book;
    }
}

class Book {
    private string title;
    
    public Book(string title) {
        this.title = title;
    }
    
    public void Issue() {
        Console.WriteLine("Book issued: " + title);
    }
}

Here, the Library class creates a Book and calls the Issue method on it. This usage pattern complies with the Law of Demeter, where Library interacts with the newly created Book. 📚