DEV Community: Bardia Mostafavi

SIMD, a parallel processing at hardware level in C#.

Bardia Mostafavi — Wed, 30 Nov 2022 21:40:53 +0000

SIMD is an acronym of Single Instruction Multiple Data.

It is a feature that lets us performing an operation on multiple chunks of data in one execution on a single core of CPUs like you see in the image:

So for example if you want to sum elements in two arrays one by one and make a new array as the result you can use SIMD instead of using traditional ways like LINQ or For loop, and because it is located in hearts of CPUs , It does its job at hardware level so in comparison to traditional ways, more performance can be gained without doing unnecessary multi threading, but as you have already known, in software developing we can't say we prefer SIMD to multi threading ! because all of these patterns have their own usage and their own cons and pros.

SIMD does its job with bigger registers in hearts of CPUs which can hold more bits to execute at one execution cycle, e.g. 256 bit of a register can holds 8x 32bits of data. and CPUs know how to handle these registers by their the instruction of set extensions (e.g. SSE and AVX extensions), and as I know the both Intel and Amd CPUs have had these features for many years.

C# gives us some accelerated SIMD types like Vector4,3,2, Matrix2x3, Plane, etc. and each of them can do some specific operations.

Note that if you want to use SIMD operations you have to use RyuJIT compiler which is included in .NET Core and in .NET Framework 4.6 and later.
You'd better know that this feature has already been implemented in other languages too. So let me wrap it up by an example in C#.

Test-Case: we want to sum 10000 elements of two arrays one by one and put the result in a new array. we do this with 3 different ways and print out the DotnetBenchmark.

[MemoryDiagnoser]
public class Counter
{
    private readonly int[] _left;
    private readonly int[] _right;

    public Counter()
    {
        _left = Faker.BuildArray(10000);
        _right = Faker.BuildArray(10000);
    }

    [Benchmark]
    public int[] VectorSum()
    {
        var vectorSize = Vector<int>.Count;
        var result = new Int32[_left.Length];
        for (int i = 0; i < _left.Length ; i += vectorSize)
        {
            var v1 = new Vector<int>(_left, i);
            var v2 = new Vector<int>(_right, i);
            (v1 + v2).CopyTo(result, i);
        }
        return result;
    }

    [Benchmark]
    public int[] LinQSum()
    {
        var result = _left.Zip(_right, (l, r) => l + r).ToArray();
        return result;
    }

    [Benchmark]
    public int[] ForSum()
    {
        var result = new Int32[_left.Length];  
        for (int i = 0; i <= _left.Length - 1; i++)
        {
            result[i] = _left[i] + _right[i];
        }
        return result;
    }
}

public static class Faker
{
    public static int[] BuildArray(int length)
    {
        var list = new List<int>();
        var rnd = new Random(DateTime.Now.Millisecond);     
        for (int i = 1; i <= length; i++)
        {
            list.Add(rnd.Next(1,99));
        }
        return list.ToArray();
    }
}

As you can see on the benchmark, SIMD has defeated both For-Loop and LINQ methods by 2x, 27x faster, and actually I've written these methods readable and easy and they are managed, and you can find even better performance in unmanaged codes, At the end I think it would be better to use this feature when you were ensured by the performance that you are going to gain.
more information.

Behavioral Design Patterns In C#

Bardia Mostafavi — Thu, 04 Nov 2021 10:03:26 +0000

if you are new , I highly recommend you to read my first and second articles which are about Creational Design Patterns and Structural Design Patterns In C#.

As we explained in earlier post , we have three main categories in Design Patterns :

Creational
Structural
Behavioral

Behavioral Design Patterns mainly focus on the communication between objects and the interactions between them by algorithm and their responsibilities.

Chain of Responsibility

this pattern is use to passing request along multiple handler, so it prevents from coupling request to handle by one handler.

    public interface IHandler
    {
        public IHandler SetNext(IHandler handler);

        public object Handle(object input);
    }

    public class Handler : IHandler
    {
        private IHandler _handler;

        public IHandler SetNext(IHandler handler)
        {
            _handler = handler;

            return handler;
        }

        public virtual object Handle(object input)
        {
            return _handler?.Handle(input);
        }
    }

    public class HandlerA : Handler
    {
        public override object Handle(object input)
        {
            if (input as string == "A")
            {
                Console.WriteLine("HandlerA said : gotcha you ! that's enough go back");
                return true;
            }

            Console.WriteLine("HandlerA said : i can not do anything calling next handler");
            return base.Handle(input);
        }
    }

    public class HandlerB : Handler
    {
        public override object Handle(object input)
        {
            if (input as string == "B")
            {
                Console.WriteLine("HandlerB said : gotcha you ! that's enough go back");
                return true;
            }

            Console.WriteLine("HandlerB said : i can not do anything calling next handler");
            return base.Handle(input);
        }
    }

    public class HandlerC : Handler
    {
        public override object Handle(object input)
        {
            if (input as string == "C")
            {
                Console.WriteLine("HandlerC said : gotcha you ! that's enough go back");
                return true;
            }

            Console.WriteLine("HandlerC said : chain is useless for you , this is end of the road bro.");
            return base.Handle(input);
        }
    }

    public static class ChainOfResponsibilityExample
    {
        public static void Test()
        {
            var handlerA = new HandlerA();
            var handlerB = new HandlerB();
            var handlerC = new HandlerC();

            handlerA.SetNext(handlerB).SetNext(handlerC);

            var resultOne = handlerA.Handle("A");
            var resultTwo = handlerA.Handle("B");
            var resultThree = handlerA.Handle("C");
            var resultFour = handlerA.Handle("D");
        }

        //results:
        //
        // resultOne :
        // HandlerA said : gotcha you ! that's enough go back
        //
        // resultTwo :
        // HandlerA said : i can not do anything calling next handler
        // HandlerB said : gotcha you ! that's enough go back
        //
        // resultThree :
        // HandlerA said : i can not do anything calling next handler
        // HandlerB said : i can not do anything calling next handler
        // HandlerC said : gotcha you ! that's enough go back
        //
        // resultFour :
        // HandlerA said : i can not do anything calling next handler
        // HandlerB said : i can not do anything calling next handler
        // HandlerC said : chain is useless for you , this is end of the road bro.

Command

this pattern is use to transform request to a object so you can delay or queue or parameterize request. and do undoable operations.

    public interface ICommand
    {
        public void Execute();
    }

    public class ExampleCommand : ICommand
    {
        private readonly string _parameter;

        public ExampleCommand(string parameter)
        {
            _parameter = parameter;
        }

        public void Execute()
        {
            Console.WriteLine(_parameter);
        }
    }

    public static class Invoker
    {
        public static void SendAction(ICommand command)
        {
            command.Execute();
        }
    }

    public static class CommandExample
    {
        public static void Test()
        {
            var command = new ExampleCommand("Query filter setup and executed");

            Invoker.SendAction(command);
        }

        //results:
        //Query filter setup and executed
    }

Iterator

its main goal is to traverse elements of collection without exposing them.

    public abstract class IteratorBase
    {
        public abstract bool EndOfDocument();
        public abstract object Current();
        public abstract object Next();
        public abstract object First();
    }

    public class Iterator : IteratorBase
    {
        private readonly List<object> _customList;
        private int current = 0;

        public Iterator(List<object> customList)
        {
            _customList = customList;
        }

        public override bool EndOfDocument()
        {
            if (current >= _customList.Count - 1)
                return true;
            return false;
        }

        public override object Current()
        {
            return _customList[0];
        }

        public override object Next()
        {
            if (current < _customList.Count - 1)
                return _customList[++current];

            return null;
        }

        public override object First()
        {
            return _customList[0];
        }
    }

    public static class IteratorExample
    {
        public static void Test()
        {
            var ourList = new List<object>() {"a", "b", "c", "d"};

            var iterator = new Iterator(ourList);

            Console.WriteLine("lets Iterate on list");

            var item = iterator.First();
            while (item != null)
            {
                Console.WriteLine(item);
                item = iterator.Next();
            }

            if (iterator.EndOfDocument())
                Console.WriteLine("Iterate done");
        }

        //results:
        // lets Iterate on list
        // a
        // b
        // c
        // d
        // Iterate done
    }

Interpreter

it is use for get different type and behavior on same context , and usually use in language scenario in software design.

    internal class Context
    {
        public string Value { get; private set; }

        public Context(string value)
        {
            Value = value;
        }
    }

    internal abstract class Interpreter    
    {    
        public abstract void Interpret(Context context);    
    }

    internal class EnglishInterpreter : Interpreter
    {
        public override void Interpret(Context context)
        {
            switch (context.Value)
            {
                case "1" :
                    Console.WriteLine("One");
                    break;
                case "2" : 
                    Console.WriteLine("Two");
                    break;
            }
        }
    }

    internal class FarsiInterpreter : Interpreter
    {
        public override void Interpret(Context context)
        {
            switch (context.Value)
            {
                case "3" :
                    Console.WriteLine("سه");
                    break;
                case "4" : 
                    Console.WriteLine("چهار");
                    break;
            }
        }
    }

    public static class InterpreterExample
    {
        public static void Test()
        {
            var interpreters = new List<Interpreter>()
            {
                new EnglishInterpreter(),
                new FarsiInterpreter()
            };

            var context = new Context("2");

            interpreters.ForEach(c => c.Interpret(context));
        }

        //results:
        //two
    }

Mediator

the goal of this pattern is to decoupling direct communication between objects and forces them to pass from a mediator object for communicating.

    public interface IMediator
    { 
        public void Send(string message, Caller caller);
    }

    public class Mediator : IMediator
    {
        public CallerA CallerA { get; set; }
        public CallerB CallerB { get; set; }

        public void Send(string message, Caller caller)
        {
            if (caller.GetType() == typeof(CallerA))
            {
                CallerB.ReceiveRequest(message);
            }
            else
            {
                CallerA.ReceiveRequest(message);
            }
        }
    }

    public abstract class Caller
    {
        protected readonly IMediator _mediator;

        public Caller(IMediator mediator)
        {
            _mediator = mediator;
        } 
    }

    public class CallerA : Caller
    {
        public void SendRequest(string msg)
        {
           _mediator.Send(msg,this);
        }

        public void ReceiveRequest(string msg)
        {
            Console.WriteLine("CallerA Received : " + msg);
        }

        public CallerA(IMediator mediator) : base(mediator)
        {

        }
    }

    public class CallerB : Caller
    {
        public void SendRequest(string msg)
        {
            _mediator.Send(msg,this);
        }

        public void ReceiveRequest(string msg)
        {
            Console.WriteLine("CallerB Received : " + msg);
        }

        public CallerB(IMediator mediator) : base(mediator)
        {

        }
    }

    public static class MediatorExample
    {
        public static void Test()
        {
            var mediator = new Mediator();
            var callerA = new CallerA(mediator);
            var callerB = new CallerB(mediator);

            mediator.CallerA = callerA;
            mediator.CallerB = callerB;

            callerA.SendRequest("hello how are you ?");
            callerB.SendRequest("fine tnx");


        }

        //results:
        //CallerB Received : hello how are you ?
        //CallerA Received : fine tnx
    }

Memento

this pattern is use for saving state of object with considering state encapsulation. so you can restores object's first state even after multiple manipulation.

    public class Memento
    {
        private readonly string _state;

        public Memento(string state)
        {
            _state = state;
        }

        public string GetState()
        {
            return _state;
        }
    }

    public class CareTaker
    {
        private Memento _memento;

        public void SaveMemento(Originator originator)
        {
            _memento = originator.CreateMemento();
        }

        public void RestoreMemento(Originator originator)
        {
            originator.RestoreState(_memento);
        }
    }


    public class Originator
    {
        public string State { get; set; }

        public Originator(string state)
        {
            State = state;
        }

        public Memento CreateMemento()
        {
            return new Memento(State);
        }

        public void RestoreState(Memento memento)
        {
            State = memento.GetState();
        }
    }

    public static class MementoExample
    {
        public static void Test()
        {
            var originator = new Originator("First Value");

            var careTaker = new CareTaker();

            careTaker.SaveMemento(originator);

            Console.WriteLine(originator.State);

            originator.State = "Second Value";

            Console.WriteLine(originator.State);

            careTaker.RestoreMemento(originator);

            Console.WriteLine(originator.State);
        }

        //results:
        //First Value
        //Second Value
        //First Value
    }

Observer

it is use to handle one to many communication between objects , so if one object's state changed , its dependent objects will notify and will update.

    public class Updater
    {
        public string NewState { get; }

        private readonly List<ObserverBase> _observers = new List<ObserverBase>();

        public Updater(string newState)
        {
            NewState = newState;
        }

        public void AddObserver(ObserverBase observerBase)
        {
            _observers.Add(observerBase);
        }

        public void BroadCast()
        {
            foreach (var observer in _observers)
            {
                observer.Update();
            }
        }
    }

    public abstract class ObserverBase
    {
        public abstract void Update();
    }

    public class Observer : ObserverBase
    {
        private readonly string _name;
        public string State;
        private readonly Updater _updater;

        public Observer(string name, string state, Updater updater)
        {
            _name = name;
            State = state;
            _updater = updater;
        }

        public override void Update()
        {
            State = _updater.NewState;
            Console.WriteLine($"Observer {_name} State Changed to : " + State);
        }
    }

    public static class ObserverExample
    {
        public static void Test()
        {
            var updater = new Updater("Fire");

            updater.AddObserver(new Observer("1", "dust", updater));
            updater.AddObserver(new Observer("2", "water", updater));
            updater.AddObserver(new Observer("3", "air", updater));

            updater.BroadCast();
        }

        //results:
        //Observer 1 State Changed to : Fire
        //Observer 2 State Changed to : Fire
        //Observer 3 State Changed to : Fire
    }

State

with this pattern object can change its behavior whenever its state changed.

    internal interface IState
    {
        public void Handle(Context context);
    }

    internal class StateA : IState
    {
        public void Handle(Context context)
        {
            context.State = new StateB();
        }
    }

    internal class StateB : IState
    {
        public void Handle(Context context)
        {
            context.State = new StateA();
        }
    }

    internal class Context
    {
        private IState _state;
        public IState State
        {
            get => _state;
            set
            {
                _state = value;
                Console.WriteLine("State: " + _state.GetType().Name);
            }
        }

        public Context(IState state)
        {
            State = state;
        }

        public void Action()
        {
            State.Handle(this);
        }
    }

    public static class StateExample
    {
        public static void Test()
        {
            var context = new Context(new StateA());

            context.Action();
            context.Action();
            context.Action();
            context.Action();
        }

        //results:
        //State: StateA
        //State: StateB
        //State: StateA
        //State: StateB
        //State: StateA
    }

Strategy

this pattern is use to encapsulate family of algorithm and makes them interchangeable . so they can independently change without any tight coupling.

    internal interface IStrategy
    {
        public void AlgorithmAction();
    }

    internal class AlgorithmStrategyA : IStrategy
    {
        public void AlgorithmAction()
        {
            Console.WriteLine("Strategy A is taking place");
        }
    }

    internal class AlgorithmStrategyB : IStrategy
    {
        public void AlgorithmAction()
        {
            Console.WriteLine("Strategy B is taking place");
        }
    }

    internal class Context
    {
        private readonly IStrategy _strategy;

        public Context(IStrategy strategy)
        {
            _strategy = strategy;
        }

        public void GeneralAction()
        {
            _strategy.AlgorithmAction();
        }
    }

    public static class StrategyExample
    {
        public static void Test()
        {
            var context = new Context(new AlgorithmStrategyA());

            context.GeneralAction();

            context = new Context(new AlgorithmStrategyB());

            context.GeneralAction();
        }

        //results:
        //Strategy A is taking place
        //Strategy B is taking place

    }

Template Method

in simple word , this pattern includes number of operations on base class and it allows subclasses to only override some of the them.

    internal abstract class TemplateBase
    {
        public void Operate()
        {
            FirstAction();
            SecondAction();
        }

        private void FirstAction()
        {
            Console.WriteLine("First action from template base and it is necessary");
        }

        protected virtual void SecondAction()
        {
            Console.WriteLine("Second action from template base and it is overrideable");
        }
    }

    internal class  TemplateMethodA : TemplateBase
    {

    }

    internal class  TemplateMethodB : TemplateBase
    {
        protected override void SecondAction()
        {
            Console.WriteLine("Second action from templateMethodC");
        }
    }

    internal class  TemplateMethodC : TemplateBase
    {
        protected override void SecondAction()
        {
            Console.WriteLine("Second action from templateMethodC");
        }
    }

    public static class TemplateMethod
    {
        public static void Test()
        {
            var templateMethodA = new TemplateMethodA();
            var templateMethodB = new TemplateMethodB();
            var templateMethodC = new TemplateMethodC();

            templateMethodA.Operate();
            templateMethodB.Operate();
            templateMethodC.Operate();

        }

        //results:
       //First action from template base and it is necessary
       //Second action from template base and it is overrideable

       //First action from template base and it is necessary
       //Second action from templateMethodB

       //First action from template base and it is necessary 
       //Second action from templateMethodC
    }

Visitor

the main goal is to add new behavior to class hierarchy without any changing in their code.

    internal interface IVisitor
    {
        public void VisitItem(ItemBase item);
    }

    internal class VisitorA : IVisitor
    {
        public void VisitItem(ItemBase item)
        {
            Console.WriteLine("{0} visited by {1}",item.GetType().Name , this.GetType().Name);
        }
    }

    internal class VisitorB : IVisitor
    {
        public void VisitItem(ItemBase item)
        {
            Console.WriteLine("{0} visited by {1}",item.GetType().Name , this.GetType().Name);
        }
    }

    internal abstract class ItemBase
    {
        public abstract void Accept(IVisitor visitor);
    }

    internal class ItemA : ItemBase
    {
        public override void Accept(IVisitor visitor)
        {
            visitor.VisitItem(this);
        }

        public void ExtraOperationA()
        {

        }
    }

    internal class ItemB : ItemBase
    {
        public override void Accept(IVisitor visitor)
        {
            visitor.VisitItem(this);
        }

        public void ExtraOperationB()
        {

        }
    }

    internal class StructureBuilder
    {
        readonly List<ItemBase> _items = new();
        public void AddItem(ItemBase element)
        {
            _items.Add(element);
        }
        public void Accept(IVisitor visitor)
        {
            foreach (var item in _items)
            {
                item.Accept(visitor);
            }
        }
    }

    public static class VisitorExample
    {
        public static void Test()
        {
            var structure = new StructureBuilder();

            structure.AddItem(new ItemA());
            structure.AddItem(new ItemB());


            structure.Accept(new VisitorA());
            structure.Accept(new VisitorB());
        }

        //results:
        //ItemA visited by VisitorA
        //ItemB visited by VisitorA
        //ItemA visited by VisitorB
        //ItemB visited by VisitorB
    }

Structural Design Patterns In C#

Bardia Mostafavi — Mon, 25 Oct 2021 05:39:35 +0000

if you are new , I highly recommend you to read my first article which is about Creational Design Patterns In C#.
As we explained in earlier post , we have three main categories in Design Patterns :

Creational
Structural
Behavioral

Structural Design Patterns help you to put types and object and other stuff together to create bigger struct but at same time, its keep high flexibility and optimum performance for you. there are seven patterns exists in this family :

Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Proxy

Adapter

as its name implies , adapter pattern adjusts communication between two alien types and make them understand each other.

    public class AlienType
    {
        public string SayJupiterianHi()
        {
            return "Hello Man from Earth, I am from JUPITER";
        }
    }
    public interface IAdapter
    {
        string SayHi();
    }
    public class Adapter : IAdapter
    {
        private readonly AlienType _alienType;

        public Adapter(AlienType alienType)
        {
            _alienType = alienType;
        }

        public string SayHi()
        {
            return _alienType.SayJupiterianHi();
        }
    }
    public static class AdapterExample
    {
        public static void Test()
        {
            var adapter = new Adapter(new AlienType());
            Console.WriteLine(adapter.SayHi());
        }

        //result:
        //Hello Man from Earth, I am from JUPITER
    }

Bridge

this pattern separate interface or abstraction from its implementation, so for example you may have using two different technologies in two implementations.

    public interface IBridge
    {
        void PrintDetails();
    }
    public class BridgeA : IBridge
    {
        public void PrintDetails()
        {
            Console.WriteLine("data across Bridge A");
        }
    }
    public class BridgeB : IBridge
    {
        public void PrintDetails()
        {
            Console.WriteLine("data across Bridge B");
        }
    }
    public interface IBridgeUser
    {
        public IBridge Bridge { get; set; }
        void PrintDetails();
    }
    public class BridgeUser : IBridgeUser
    {
        public IBridge Bridge { get; set; }

        public void PrintDetails()
        {
            Bridge.PrintDetails();
        }
    }    
    public static class BridgeExample
    {
        public static void Test()
        {
            var bridgeUser = new BridgeUser();

            bridgeUser.Bridge = new BridgeA();
            bridgeUser.PrintDetails();

            bridgeUser.Bridge = new BridgeB();
            bridgeUser.PrintDetails();
        }

        //result:
        //data across Bridge A
        //data across Bridge B
    }

Composite

in simple word , we put objects in one bigger object with tree structure so we can present hierarchie, and also this pattern let you to treat uniformly with single object or composite object.

    public abstract class Animal
    {
        protected string Name;
        protected Animal(string name)
        {
            Name = name;
        }
        public virtual void Add(Animal animal)
        {
            throw new NotImplementedException();
        } 
        public virtual void PrintTree(int indent)
        {
            throw new NotImplementedException();
        }
    }

    public class Species : Animal
    {
        public Species(string name) : base(name)
        {

        } 
        public override void PrintTree(int indent)
        {
            Console.WriteLine(new String('-', indent) + " " + Name);
        }
    }

    public class SpeciesComposite : Animal
    {
        private readonly List<Animal> _animals = new List<Animal>();

        public SpeciesComposite(string name) : base(name)
        {

        }  
        public override void Add(Animal animal)
        {
            _animals.Add(animal);
        }
        public override void PrintTree(int indent)
        {
            Console.WriteLine(new String('-', indent) + "+ " + Name);
            // Display each child element on this node
            foreach (var animal in _animals)
            {
                animal.PrintTree(indent + 2);
            }
        }
    }   

    public static class CompositeExample
    {
        public static void Test()
        {
            var mammal = new SpeciesComposite("Mammal");
            var carnivore = new SpeciesComposite("Carnivore");
            var nonCarnivore = new SpeciesComposite("Non-Carnivore");

            var tiger = new Species("Tiger");
            var leopard = new Species("Leopard");
            var sheep = new Species("Sheep");
            var cow = new Species("Cow");

            carnivore.Add(tiger);
            carnivore.Add(leopard);

            nonCarnivore.Add(sheep);
            nonCarnivore.Add(cow);

            mammal.Add(carnivore);
            mammal.Add(nonCarnivore);

            mammal.PrintTree(1);
        }

        //result:
        //-+ Mammal
        //---+ Carnivore
        //----- Tiger
        //----- Leopard
        //---+ Non-Carnivore
        //----- Sheep
        //----- Cow
    }

Decorator

this pattern helps you to extend your object responsibilities dynamically with less subclassing.

    public interface ICar
    {
        public string Tire { get; }
        public string Engine { get; }

        public abstract void ShowParts();
    }
    public class NormalCar : ICar
    {
        public string Tire => "Pirelli";
        public string Engine => "v4";

        public void ShowParts()
        {
            Console.WriteLine(this.ToJson());
        }
    }
    public class SportCarDecorator : ICar
    {
        private readonly ICar _car;

        public SportCarDecorator(ICar car)
        {
            _car = car;
        }

        public string Tire => _car.Tire;

        public string Engine => _car.Engine;

        public string Nitro => "NOS";

        public void ShowParts()
        {
            Console.WriteLine(this.ToJson());
        }
    } 
    public static class DecoratorExample
    {
        public static void Test()
        {
            var normalCar = new NormalCar();
            normalCar.ShowParts();

            var decoratedCar = new SportCarDecorator(normalCar);
            decoratedCar.ShowParts();
        }

        //result:
        //{"Tire":"Pirelli","Engine":"v4"}
        //{"Tire":"Pirelli","Engine":"v4","Nitro":"NOS"}
    }

Facade

This pattern gathers all interfaces or complex systems of classes or frameworks or etc , and make using of them simplify for you.

    public class Facade
    {
        private readonly SubSys1 _subSys1;
        private readonly SubSys2 _subSys2;

        public Facade(SubSys1 subSys1,SubSys2 subSys2)
        {
            _subSys1 = subSys1;
            _subSys2 = subSys2;
        }

        public void Action()
        {
            _subSys1.Action();
            _subSys2.Action();
        }
    }    
    public class SubSys1
    {
        public void Action()
        {
            Console.WriteLine("i am action by subsys1");
        }
    }    
    public class SubSys2
    {
        public void Action()
        {
            Console.WriteLine("i am action by subsys2");
        }
    }    
    public static class FacadeExample
    {
        public static void Test()
        {
            var subsys1 = new SubSys1();
            var subsys2 = new SubSys2();

            var facade = new Facade(subsys1, subsys2);
            facade.Action();
        }

        //result:
        //i am action by subsys1
        //i am action by subsys2
    }

Flyweight

Mainly target of using this pattern is to save your memory by using shared objects.

    public class Flyweight
    {
        private readonly List<KeyValuePair<string, Heavy>> _sharedObjects = new();

        public Flyweight()
        {
            _sharedObjects.Add(new KeyValuePair<string, Heavy>("A",new Heavy()));
            _sharedObjects.Add(new KeyValuePair<string, Heavy>("B",new Heavy()));
            _sharedObjects.Add(new KeyValuePair<string, Heavy>("C",new Heavy()));
        }

        public Heavy GetObject(string key)
        {
            return _sharedObjects.SingleOrDefault(c => c.Key == key).Value;
        }
    }
    public interface IHeavy
    {
        public void Operation(string name);
    }
    public class Heavy : IHeavy
    {
        public void Operation(string name)
        {
            Console.WriteLine(name);
        }
    }
    public static class FlyweightExample
    {
        public static void Test()
        {
            var flyweight = new Flyweight();
            flyweight.GetObject("A").Operation("Hey");
            flyweight.GetObject("B").Operation("We Are Using");
            flyweight.GetObject("C").Operation("Shared Memory");

            var heavy = new Heavy();
            heavy.Operation("But I am bad and use my own memory");
        }

        //result:
        //Hey
        //We Are Using
        //Shared Memory
        //But I am bad and use my own memory
    }

Proxy

This pattern use a middle type to control access to main type.

    public abstract class MainAbstraction
    {
        public abstract void Call();
    }
    public class Main : MainAbstraction
    {
        public override void Call()
        {
            Console.WriteLine("calling by Main class");
        }
    }
    public class Proxy : MainAbstraction
    {
        private Main _main;

        public Proxy(Main main)
        {
            _main = main;
        }

        public override void Call()
        {
            _main ??= new Main();

            Console.WriteLine("proxy do some work before calling");

            _main.Call();
        }
    }
    public static class ProxyExample
    {
        public static void Test()
        {
            var proxy = new Proxy(new Main());

            proxy.Call();
        }

        //result:
        //proxy do some work before calling
        //calling by Main class
    }

That's it. Congratulation ! now you have been familiar with the basic patterns of Structural Design. I will explain the last main category in two different articles because the Behavioral Design includes many patterns and it is better to split it into two articles.

Creational Design Patterns In C#

Bardia Mostafavi — Sun, 24 Oct 2021 10:37:09 +0000

What is a Design Pattern !?

In a simple word , Design Pattern is a standard solution for handling specific situation. thus you can use it to save your time so do not have to reinvent the wheel, and most important of that you use it because this is standard and optimum solution and approved by all other real programmers. just what you need is to check the situation and pick a best and relevant design pattern and adjust it for using in your code. but keep in mind do not use them everywhere, sometime simple code do the work better and no need for overusing of Design Patterns.

Basically, there are three main categories in Design Patterns :

Creational
Structural
Behavioral

Creational Design Patterns are mainly focused on creation of objects. So for example they can make creation of big object easy and reusable. there are five different patterns exist in Creational category with different usage :

Abstract Factory
Factory Method
Builder
Prototype
Singleton

Abstract Factory

This pattern use for creating of families of related objects so we have interface or abstract class as factory which have multiple methods that usually return related type.

First make some related type :

    public interface ITechCompany
    {
        void PrintDetail();
    }
    public interface ICarCompany
    {
        void PrintDetail();
    }
    //family #1
    public class Asus : ITechCompany
    {
        public void PrintDetail()
        {
            Console.WriteLine("i am detail of asus company");
        }
    }
    public class Dell : ITechCompany
    {
        public void PrintDetail()
        {
            Console.WriteLine("i am detail of dell company");
        }
    }
    //family #2
    public class Benz : ICarCompany
    {
        public void PrintDetail()
        {
            Console.WriteLine("i am detail of Benz company");
        }
    }
    public class Audi : ICarCompany
    {
        public void PrintDetail()
        {
            Console.WriteLine("i am detail of Audi company");
        }
    }

Second implement of the Pattern :

    public interface ICompanyFactory
    {
        ITechCompany CreateTechCompany();
        ICarCompany CreateCarCompany();
    } 
    public class CompanyFactoryA : ICompanyFactory
    {
        public ITechCompany CreateTechCompany()
        {
            return new Asus();
        }
        public ICarCompany CreateCarCompany()
        {
            return new Benz();
        }
    }
    public class CompanyFactoryB : ICompanyFactory
    {
        public ITechCompany CreateTechCompany()
        {
            return new Dell();
        }
        public ICarCompany CreateCarCompany()
        {
            return new Audi();
        }
    }
    public static class AbstractFactoryExample
    {
        public static void Test()
        {
            var factoryA = new CompanyFactoryA();
            var carA = factoryA.CreateCarCompany();
            var techA = factoryA.CreateTechCompany();
            carA.PrintDetail(); 
            techA.PrintDetail();

            var factoryB = new CompanyFactoryB();
            var carB = factoryB.CreateCarCompany();
            var techB = factoryB.CreateTechCompany();
            carB.PrintDetail();
            techB.PrintDetail();
        }
        //result :
        //i am detail of Benz company
        //i am detail of asus company
        //i am detail of Audi company
        //i am detail of dell company
    }

Factory Method

To be honestly , factory method pattern is like abstract factory but with difference in one thing , abstract factory is an object with a multiple factory method , you can use this method for high flexibility.

implement of the Pattern (we are using family types that we have been declared earlier):

    public interface ITechCompanyCreator
    {
        ITechCompany CreateTechCompany();
    }
    public class TechCompanyCreatorA : ITechCompanyCreator
    {
        public ITechCompany CreateTechCompany()
        {
            return new Asus();
        }
    }
    public class TechCompanyCreatorB : ITechCompanyCreator
    {
        public ITechCompany CreateTechCompany()
        {
            return new Dell();
        }
    }
    public static class FactoryMethodExample
    {
        public static void Test()
        {
            var creatorA = new TechCompanyCreatorA();
            var techA = creatorA.CreateTechCompany();
            techA.PrintDetail();

            var creatorB = new TechCompanyCreatorB();
            var techB = creatorB.CreateTechCompany();
            techB.PrintDetail();
        }
        //result :
        //i am detail of Asus company
        //i am detail of Dell company
    }

Builder

This pattern use for creating big object with lots of possible configuration.

    public interface IBuilder
    {
        Contact Build();
    }
    public class ContactBuilder : IBuilder
    {
        private readonly Contact _contact = new Contact();
        public ContactBuilder WithName(string name)
        {
            _contact.Name = name;
            return this;
        }
        public ContactBuilder WithFamily(string family)
        {
            _contact.Family = family;
            return this;
        }
        public ContactBuilder WithAge(int age)
        {
            _contact.Age = age;
            return this;
        }
        public Contact Build()
        {
            return _contact;
        }
    }
    public class Contact
    {
        public string Name { get; set; }
        public string Family { get; set; }
        public int Age { get; set; }
    }
    public static class BuilderExample
    {
        public static void Test()
        {
            var contact = new ContactBuilder()
                          .WithName("name")
                          .WithFamily("family")
                          .WithAge(10)
                          .Build();
            Console.WriteLine(contact.ToJson());
        }      
        //result :
        //{"Name":"name","Family":"family","Age":10}
    }

Prototype

This pattern use for taking clone of any object with any complexity with decoupling clone from origin object.

    public class Person
    {
        public string Name { get; set; }
        public Family Family { get; set; }
        public int Age { get; set; }

        //Pattern        
        public Person ShallowCopy()
        {
            return (Person) this.MemberwiseClone();
        }
        public Person DeepCopy()
        {
            var clone =  (Person) this.MemberwiseClone();
            clone.Name = new string(Name);
            clone.Family = new Family
            {
                MiddleName = new string(Family.MiddleName),
                LastName = new string(Family.LastName)
            };
            return clone;
        }    
    }
    public class Family
    {
        public string MiddleName { get; set; }
        public string LastName { get; set; }
    }

    public static class PrototypeExample
    {

        public static void Test()
        {
            var person = new Person
            {
                Name = "David",
                Family = new Family
                {
                    MiddleName = "Junior",
                    LastName = "Nolan"
                },
                Age = 20
            };

            var shallowCopied = person.ShallowCopy();
            var deepCopied = person.DeepCopy();

            person.Age = 55;
            person.Name = "rookie";
            person.Family.LastName = "bishop";

            Console.WriteLine(person.ToJson());
            Console.WriteLine(shallowCopied.ToJson());
            Console.WriteLine(deepCopied.ToJson());
        }

        //result:
        //{"Name":"rookie","Family":{"MiddleName":"Junior","LastName":"bishop"},"Age":55}  => person
        //{"Name":"David","Family":{"MiddleName":"Junior","LastName":"bishop"},"Age":20}  => shallowcopy
        //{"Name":"David","Family":{"MiddleName":"Junior","LastName":"Nolan"},"Age":20}  => deepcopy
    }

Singleton

With this pattern we ensure that we have one instance of object in runtime with one general global access.

    public class Singleton
    {
        private Singleton()
        {
        }

        private static Singleton _instance;

        public static Singleton GetInstance()
        {
            if (_instance == null)
                _instance = new Singleton();
            return _instance;
        }
    }
    public static class SingletonExample
    {
        public static void Test()
        {
            var instance1 = Singleton.GetInstance();
            var instance2 = Singleton.GetInstance();

            if (instance1.Equals(instance2))
                Console.WriteLine("Yes");
            else
                Console.WriteLine("No");
        }
        //result:
        //Yes
    }

Ok , That's enough, now you know about the basic of creational patterns , i will explain two other categories in two different articles later.