Expect everything to change...

It's often useful to represent things as a compound. A 2D coordinate consists of an x value and y value. An amount of money consists of a number and a currency. A date range consists of start and end dates, which themselves can be compounds of year, month, and day.

I run into the question of whether two compound objects are the same. Objects that are equal due to the value of their properties, in this case their x and y coordinates, are called value objects.

In some noon functional languages you will need to override the default equals method with the tests for the values.

One of the nice consequences of value objects is that I don't need to care about whether I have a reference to the same object in memory or a different reference with an equal value.

Aliasing Bug

To avoid aliasing bugs I follow a simple but important rule: value objects should be immutable. If I want to change my object, I create a new object instead. With objects I can usually do this by simply not providing any setting methods.

Example

Interface

interface IPaymentGateway
{
    void MakePayment(Product product);        
}

Concrete implementations

public class BankOne : IPaymentGateway
{
    public void MakePayment(Product product)
    {
        // The bank specific API call to make the payment
        Console.WriteLine("Using bank1 to pay for {0}, amount {1}", product.Name, product.Price);
    }
}

public class BankTwo : IPaymentGateway
{
    public void MakePayment(Product product)
    {
        // The bank specific API call to make the payment
        Console.WriteLine("Using bank2 to pay for {0}, amount {1}", product.Name, product.Price);
    }
}

enum PaymentMethod
{
    BANK_ONE,
    BANK_TWO
}

Factory

public class PaymentGatewayFactory
{
    public virtual IPaymentGateway CreatePaymentGateway(PaymentMethod method, Product product)
    {
        IPaymentGateway gateway = null;

        switch(method)
        {
            case PaymentMethod.BANK_ONE:
                gateway = new BankOne();
                break;
            case PaymentMethod.BANK_TWO:
                gateway = new BankTwo();
                break;
        }

        return gateway;
    }
}

Usage

public class PaymentProcessor
{
    IPaymentGateway gateway = null;

    public void MakePayment(PaymentMethod method, Product product)
    {
        PaymentGatewayFactory factory = new PaymentGatewayFactory();
        this.gateway = factory.CreatePaymentGateway(method, product);

        this.gateway.MakePayment(product);
    }
}

• 1) Single Responsibility Principle – Class/Function should do only one task or Class/Function should have only one reason to change.
• 2) Open Close Principle – Class/Function is open for extension but close for modification.
• 3) Liskov Substitution type – If type S is derived from Type T then object of Type T can be replaced by object of Type S.

Simple Example of Design Pattern

namespace BasicDecoratorPattern
{
    public class Client
    {
        public Client()
        {
            IBaseService realTimeService = new BasicServiceImplementaion();

            IBaseService basicRealTimeServiceDecorator1 = new Decorator1OnBasic(realTimeService);
            IBaseService basicRealTimeServiceDecorator2 = new Decorator2OnBasic(realTimeService);

            basicRealTimeServiceDecorator1.Print();
            basicRealTimeServiceDecorator2.Print();
        }
    }

    public interface IBaseService
    {
        void Print();
    }

    public class BasicServiceImplementaion : IBaseService
    {
        public void Print()
        {
            Console.WriteLine("Basic Item");
        }
    }

    public class Decorator1OnBasic : IBaseService
    {
        private readonly IBaseService BasicRealTimeService;
        public Decorator1OnBasic(IBaseService service)
        {
            BasicRealTimeService = service;
        }

        public void Print()
        {
            BasicRealTimeService.Print();
            Console.WriteLine("Extra functionality from Decorator ONE");
        }
    }

    public class Decorator2OnBasic : IBaseService
    {
        private readonly IBaseService BasicRealTimeService;
        public Decorator2OnBasic(IBaseService service)
        {
            BasicRealTimeService = service;
        }

        public void Print()
        {
            BasicRealTimeService.Print();
            Console.WriteLine("Extra functionality from Decorator SECOND");
        }
    }
}

Background

Sample Scenario

Technique #1 - Using Pure Object Oriented (OO) programming concepts.

Publisher

public interface IPublisher
{
	// Registers a new subscriber on the list of subscribers it has to 
    // notify whenever WeatherData has changed
    void RegisterSubscriber(ISubscriber subscriber);

    // Removes a registered subscriber from the publisher's notification list
    void RemoveSubscriber(ISubscriber subscriber);

    // This method actually invokes a method on the subscriber object to
    // notify that some new WeatherData is available
    void NotifySubscribers();
}

public class WeatherDataProvider : IPublisher
{
    List ListOfSubscribers;
    WeatherData data;
    public WeatherDataProvider()
    {
        ListOfSubscribers = new List();
    }
    public void RegisterSubscriber(ISubscriber subscriber)
    {
        ListOfSubscribers.Add(subscriber);
    }

    public void RemoveSubscriber(ISubscriber subscriber)
    {
        ListOfSubscribers.Remove(subscriber);
    }

    public void NotifySubscribers()
    {
        foreach (var sub in ListOfSubscribers)
        {
            sub.Update(data);
        }
    }

    private void MeasurementsChanged()
    {
        NotifySubscribers();
    }
    public void SetMeasurements(float temp, float humid, float pres)
    {
        data = new WeatherData(temp, humid, pres);           
        MeasurementsChanged();
    }
}

Subscriber

public interface ISubscriber
{
    void Update(WeatherData data);
}

public class CurrentConditionsDisplay : ISubscriber
{
    WeatherData data;
    IPublisher weatherData;

    public CurrentConditionsDisplay(IPublisher weatherDataProvider)
    {
        weatherData = weatherDataProvider;
        weatherData.RegisterSubscriber(this);
    }

    public void Display()
    {
        Console.WriteLine("Current Conditions : Temp = {0}Deg | Humidity = {1}% | Pressure = {2}bar", data.Temperature, data.Humidity, data.Pressure);
    }
   
    public void Update(WeatherData data)
    {
        this.data = data;
        Display();
    }
}

Technique #3 - Using IObservable and IObserver.

public class WeatherDataProvider : IObservable
    {
        List> observers;

        public WeatherDataProvider()
        {
            observers = new List>();
        }

        public IDisposable Subscribe(IObserver observer)
        {
            if (!observers.Contains(observer))
            {
                observers.Add(observer);
            }
            return new UnSubscriber(observers, observer);
        }

        private class UnSubscriber : IDisposable
        {
            private List> lstObservers;
            private IObserver observer;

            public UnSubscriber(List> ObserversCollection, IObserver observer)
            {
                this.lstObservers = ObserversCollection;
                this.observer = observer;
            }

            public void Dispose()
            {
                if (this.observer != null)
                {
                    lstObservers.Remove(this.observer);
                }
            }
        }

        private void MeasurementsChanged(float temp, float humid, float pres)
        {
            foreach (var obs in observers)
            {
                obs.OnNext(new WeatherData(temp, humid, pres));
            }
        }

        public void SetMeasurements(float temp, float humid, float pres)
        {
            MeasurementsChanged(temp, humid, pres);
        }
    }

public class CurrentConditionsDisplay : IObserver
{
    WeatherData data;
    private IDisposable unsubscriber;

    public CurrentConditionsDisplay()
    {

    }
    public CurrentConditionsDisplay(IObservable provider)
    {
        unsubscriber = provider.Subscribe(this);
    }
    public void Display()
    {
        Console.WriteLine("Current Conditions : Temp = {0}Deg | 
                            Humidity = {1}% | Pressure = {2}bar", 
                            data.Temperature, data.Humidity, data.Pressure);
    }

    public void Subscribe(IObservable provider)
    {
        if (unsubscriber == null)
        {
            unsubscriber = provider.Subscribe(this);
        }
    }

    public void Unsubscribe()
    {
        unsubscriber.Dispose();
    }

    // Pass the observer a T object that has current data, changed data, or fresh data.
    public void OnNext(WeatherData value)
    {
        this.data = value;
        Display();
    }

    // Notify the observer that some error condition has occurred
    public void OnError(Exception error)
    {
        Console.WriteLine("Some error has occurred..");
    }

    // Notify the observer that it has finished sending notifications
    public void OnCompleted()
    {
        Console.WriteLine("Additional temperature data will not be transmitted.");
    }
}

What are Design Patterns?

Creational Patterns

Structural Patterns

Behavioural Patterns