Tuesday, 24 March 2020

C++ - Arrow Vs Dot


The dot operator is applied to the actual object. The arrow operator is used with a pointer to an object.
struct Student {
   char first_name[16];
   int  age;
}  emp;

The (.) dot operator
To assign the value "lala" to the first_name member of object emp, you would write something as follows −
strcpy(std.first_name, "lala");

The (->) arrow operator
If p_emp is a pointer to an object of type Employee, then to assign the value "zara" to the first_name member of object emp, you would write something as follows −
strcpy(p_std->first_name, "lala");
The -> is called the arrow operator. It is formed by using the minus sign followed by a greater than sign.
Simply saying: To access members of a structure, use the dot operator. To access members of a structure through a pointer, use the arrow operator.

C# - Conditional Ternary Operator

VB.Net
Dim foo as String = If(bar = buz, cat, dog)

C# 
condition ? consequent : alternative
a ? b : c ? d : e
a ? b : (c ? d : e)

var smallArray = new int[] {1, 2, 3, 4, 5 };
var largeArray = new int[] {10, 20, 30, 40, 50 };
int index = 7;
ref int refValue = ref((index < 5) ?                  
                                      ref smallArray[index] : ref largeArray[index - 5]);

Monday, 2 March 2020

C# - Design Pattern - Chain Of Responsibility

Example 1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

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

        object Handle(object request);
    }

    abstract class BoilerAbstractHandler : IHandler
    {
        private IHandler _nextHandler;

        public IHandler SetNext(IHandler handler)
        {
            this._nextHandler = handler;
           
            return handler;
        }

        public virtual object Handle(object request)
        {
            if (this._nextHandler != null)
            {
                return this._nextHandler.Handle(request);
            }
            else
            {
                return null;
            }
        }
    }

    class BoilerOneHandler : BoilerAbstractHandler
    {
        public override object Handle(object request)
        {
            if ((request as string) == "MILK")
            {
                return $"Adding {request.ToString()}.\n";
            }
            else
            {
                return base.Handle(request);
            }
        }
    }

    class BoilerTwoHandler : BoilerAbstractHandler
    {
        public override object Handle(object request)
        {
            if (request.ToString() == "SUGAR")
            {
                return $"Adding {request.ToString()}.\n";
            }
            else
            {
                return base.Handle(request);
            }
        }
    }

    class BoilerThreeHandler : BoilerAbstractHandler
    {
        public override object Handle(object request)
        {
            if (request.ToString() == "BUTTER")
            {
                return $"Adding {request.ToString()}.\n";
            }
            else
            {
                return base.Handle(request);
            }
        }
    }

    class Client
    {
        public static void ClientCode(BoilerAbstractHandler handler)
        {
            foreach (var ingredient in new List<string> { "MILK", "SUGAR", "BUTTER" })
            {               

                var result = handler.Handle(ingredient);

                if (result != null)
                {
                    Console.Write($" {result}");
                }
                else
                {
                    Console.WriteLine($" {ingredient} was added.");
                }
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var BoilerOne = new BoilerOneHandler();
            var BoilerTwo = new BoilerTwoHandler();
            var BoilerThree = new BoilerThreeHandler();

            BoilerOne.SetNext(BoilerTwo).SetNext(BoilerThree);

            Console.WriteLine("Chain: BoilerOne > BoilerTwo > BoilerThree\n");
            Client.ClientCode(BoilerOne);
            Console.WriteLine();

            Console.WriteLine("Subchain: BoilerTwo > BoilerThree\n");
            Client.ClientCode(BoilerTwo);
        }
    }
}


Example 2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ChainOfResponsibility01
{
    public class LoanEventArgs : EventArgs
    {
        internal Loan Loan { get; set; }
    }

    /// The 'Handler' abstract class
    abstract class Approver
    {
        // Loan event
        public EventHandler<LoanEventArgs> Loan;

        // Loan event handler
        public abstract void LoanHandler(object sender, LoanEventArgs e);

        // Constructor
        public Approver()
        {
            Loan += LoanHandler;
        }

        public void ProcessRequest(Loan loan)
        {
            OnLoan(new LoanEventArgs { Loan = loan });
        }

        // Invoke the Loan event
        public virtual void OnLoan(LoanEventArgs e)
        {
            if (Loan != null)
            {
                Loan(this, e);
            }
        }

        // Sets or gets the next approver
        public Approver Successor { get; set; }
    }

    /// The 'ConcreteHandler' class
    class Clerk : Approver
    {
        public override void LoanHandler(object sender, LoanEventArgs e)
        {
            if (e.Loan.Amount < 25000.0)
            {
                Console.WriteLine("{0} approved request# {1}",
                this.GetType().Name, e.Loan.Number);
            }
            else if (Successor != null)
            {
                Successor.LoanHandler(this, e);
            }
        }
    }

    /// The 'ConcreteHandler' class
    class AssistantManager : Approver
    {
        public override void LoanHandler(object sender, LoanEventArgs e)
        {
            if (e.Loan.Amount < 45000.0)
            {
                Console.WriteLine("{0} approved request# {1}",
                this.GetType().Name, e.Loan.Number);
            }
            else if (Successor != null)
            {
                Successor.LoanHandler(this, e);
            }
        }
    }

    /// The 'ConcreteHandler' clas
    class Manager : Approver
    {
        public override void LoanHandler(object sender, LoanEventArgs e)
        {
            if (e.Loan.Amount < 100000.0)
            {
                Console.WriteLine("{0} approved request# {1}",
                sender.GetType().Name, e.Loan.Number);
            }
            else if (Successor != null)
            {
                Successor.LoanHandler(this, e);
            }
            else
            {
                Console.WriteLine(
                "Request# {0} requires an executive meeting!",
                e.Loan.Number);
            }
        }
    }

    class Loan
    {
        public double Amount { get; set; }
        public string Purpose { get; set; }
        public int Number { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // Setup Chain of Responsibility
            Approver David = new Clerk();
            Approver George = new AssistantManager();
            Approver Nicky = new Manager();

            David.Successor = George;
            George.Successor = Nicky;

            // Generate and process loan requests
            var loan = new Loan { Number = 2034, Amount = 24000.00, Purpose = "Laptop Loan" };
            David.ProcessRequest(loan);

            loan = new Loan { Number = 2035, Amount = 42000.10, Purpose = "Bike Loan" };
            George.ProcessRequest(loan);

            loan = new Loan { Number = 2036, Amount = 156200.00, Purpose = "House Loan" };
            George.ProcessRequest(loan);

            // Wait for user
            Console.ReadKey();
        }
    }
}


//EnteringData
//Collecting
//Sorting
//Bucketing
//Cleansing

//ProperFormatting