The Singleton Pattern Across Languages

The Singleton pattern restricts a class to a single instance and provides a global access point to that instance. This pattern is useful in scenarios where a single resource, such as a configuration manager or logging service, is shared across an application.

Singleton in C#

public class Logger {
    private static Logger instance;
    private Logger() {}

    public static Logger Instance {
        get {
            if (instance == null) {
                instance = new Logger();
            }
            return instance;
        }
    }

    public void Log(string message) {
        Console.WriteLine(message);
    }
}

Singleton in JavaScript

class Logger {
    constructor() {
        if (Logger.instance) {
            return Logger.instance;
        }
        Logger.instance = this;
    }

    log(message) {
        console.log(message);
    }
}

const logger = new Logger();
Object.freeze(logger);
export default logger;

In both C# and JavaScript, the Singleton pattern ensures that only one `Logger` instance exists, providing a consistent way to handle logging across an application.

The Factory Pattern Across Languages

The Factory pattern provides an interface for creating objects without specifying their concrete class. This pattern is particularly useful for handling different object types that share a common interface or superclass.

Factory Pattern in C#

public interface IShape {
    void Draw();
}

public class Circle : IShape {
    public void Draw() {
        Console.WriteLine("Drawing a Circle");
    }
}

public class Rectangle : IShape {
    public void Draw() {
        Console.WriteLine("Drawing a Rectangle");
    }
}

public class ShapeFactory {
    public static IShape GetShape(string shapeType) {
        return shapeType switch {
            "Circle" => new Circle(),
            "Rectangle" => new Rectangle(),
            _ => throw new ArgumentException("Invalid shape type")
        };
    }
}

Factory Pattern in JavaScript

class Circle {
    draw() {
        console.log("Drawing a Circle");
    }
}

class Rectangle {
    draw() {
        console.log("Drawing a Rectangle");
    }
}

class ShapeFactory {
    static getShape(shapeType) {
        switch (shapeType) {
            case "Circle":
                return new Circle();
            case "Rectangle":
                return new Rectangle();
            default:
                throw new Error("Invalid shape type");
        }
    }
}

In both languages, the `ShapeFactory` encapsulates object creation, allowing clients to request specific shapes without knowing the underlying implementation details.

The Observer Pattern Across Languages

The Observer pattern defines a one-to-many dependency, where one object (the subject) notifies a list of dependent objects (observers) when its state changes. This pattern is useful in event-driven applications and real-time data updates.

Observer Pattern in C#

public interface IObserver {
    void Update(string message);
}

public class ConcreteObserver : IObserver {
    private string _name;

    public ConcreteObserver(string name) {
        _name = name;
    }

    public void Update(string message) {
        Console.WriteLine($"{_name} received: {message}");
    }
}

public class Subject {
    private List<IObserver> _observers = new List<IObserver>();

    public void Attach(IObserver observer) {
        _observers.Add(observer);
    }

    public void Notify(string message) {
        foreach (var observer in _observers) {
            observer.Update(message);
        }
    }
}

Observer Pattern in JavaScript

class Observer {
    constructor(name) {
        this.name = name;
    }

    update(message) {
        console.log(`${this.name} received: ${message}`);
    }
}

class Subject {
    constructor() {
        this.observers = [];
    }

    attach(observer) {
        this.observers.push(observer);
    }

    notify(message) {
        this.observers.forEach(observer => observer.update(message));
    }
}

In both C# and JavaScript, the Observer pattern enables `Subject` to notify its observers when its state changes, providing a flexible way to handle event-driven data flows.

Applying Cross-Language Patterns for Consistency

Implementing design patterns across different languages provides consistency and enables code reuse within cross-language environments. By establishing common patterns, developers can align coding practices across diverse codebases, making applications easier to understand and maintain.

Best Practices for Cross-Language Patterns

• Choose Patterns Wisely: Use patterns like Singleton and Factory when handling shared resources or object creation across languages.
• Keep Code Consistent: Maintain consistent naming conventions, method names, and structure when implementing patterns across languages.
• Document Patterns and Usage: Clearly document each pattern’s implementation and usage to ensure that team members understand how to work with the codebase.

Conclusion

Cross-language design patterns enable teams to apply consistent, reusable solutions across different programming languages. Patterns like Singleton, Factory, and Observer provide structured approaches to common software challenges, helping teams create scalable, maintainable applications in diverse development environments. By applying these patterns consistently, developers can simplify code management and improve collaboration across projects.