Difference between design patterns ?

Factory Pattern: We implement the factory design pattern in a C# program.A factory creates objects With this pattern, we develop an abstraction that isolates the logic for determining which type of class to create.

The factory design pattern relies on a type hierarchy. The classes must all implement an interface or derive from a base class. We use an abstract class as the base. The Manager, Clerk and Programmer classes derive from Position.

Summary. We looked the factory design pattern, which is used to instantiate objects based on another data type such as integers. Factories can be used to reduce code bloat and also make it easier to modify which objects need to be created.

there are two examples

using System;
class Program
{
abstract class Position
{
public abstract string Title { get; }
}
class Manager : Position
{
public override string Title
{
get
{
return "Manager";
}
}
}
class Clerk : Position
{
public override string Title
{
get
{
return "Clerk";
}
}
}
class Programmer : Position
{
public override string Title
{
get
{
return "Programmer";
}
}
}
static class Factory
{
///
/// Decides which class to instantiate.
///
public static Position Get(int id)
{
switch (id)
{
case 0:
return new Manager();
case 1:
case 2:
return new Clerk();
case 3:
default:
return new Programmer();
}
}
}
static void Main()
{
for (int i = 0; i <= 3; i++)
{
var position = Factory.Get(i);
Console.WriteLine("Where id = {0}, position = {1} ", i, position.Title);
}
}
}

Output

Where id = 0, position = Manager

Where id = 1, position = Clerk

Where id = 2, position = Clerk

Where id = 3, position = Programmer

Another example

using System;
namespace Factory
{
///
/// The 'Product' interface
///
public interface IFactory
{
void Drive(int miles);
}
///
/// A 'ConcreteProduct' class
///
public class Scooter : IFactory
{
public void Drive(int miles)
{
Console.WriteLine("Drive the Scooter : " + miles.ToString() + "km");
}
}
///
/// A 'ConcreteProduct' class
///
public class Bike : IFactory
{
public void Drive(int miles)
{
Console.WriteLine("Drive the Bike : " + miles.ToString() + "km");
}
}
///
/// The Creator Abstract Class
///
public abstract class VehicleFactory
{
public abstract IFactory GetVehicle(string Vehicle);
}
///
/// A 'ConcreteCreator' class
///
public class ConcreteVehicleFactory : VehicleFactory
{
public override IFactory GetVehicle(string Vehicle)
{
switch (Vehicle)
{
case "Scooter":
return new Scooter();
case "Bike":
return new Bike();
default:
throw new ApplicationException(string.Format("Vehicle '{0}' cannot be created", Vehicle));
}
}
}
///
/// Factory Pattern Demo
///
class Program
{
static void Main(string[] args)
{
VehicleFactory factory = new ConcreteVehicleFactory();
IFactory scooter = factory.GetVehicle("Scooter");
scooter.Drive(10);
IFactory bike = factory.GetVehicle("Bike");
bike.Drive(20);
Console.ReadKey();
}
}
}

Dependency Injection (DI) is a technique to create a dependency or dependencies outside the class that uses it. The dependencies are injected from the code that calls the class and any information about their creation are kept away from the inside of the class. This is also why DI is an implementation of the Inversion of control (IoC) principle.

To further explain the dependency injection design pattern, the inversion of control

Inversion of Control Principle

Normally, the flow of the program logic is determined by objects that are bound to one another. With the inversion of control, the flow depends on the defined abstractions to be implemented that is built up during program execution. This principle can be achieved by techniques like dependency injection. In IoC, the code could also be linked statically during compilation to the defined interface functions, but finding the implementation of the function to execute by reading its description from external configuration instead of with a direct reference in the code itself.

There are three ways can inject the objects

1- Through constructor

2- Through properties

3-Through method

Example

public interface IEmailService
{
void SendMail(string emailAddress, string message)
}
public class GoogleEmailService: IEmailService
{
public SendMail(string emailAddress, string message)
{
//Send an email using google
}
}
public class OutlookEmailService: IEmailService
{
public void SendMail(string emailAddress, string message)
{
//Send an email using outlook
}
}
public class UserLogic
{
private GoogleOAuthService _authService;
private IEmailService _emailService;
public UserLogic(IEmailSevice emailService)
{
_authService = new GoogleOAuthService();
_emailService = emailService;
}
...
}
public class UserLogic
{
private GoogleOAuthService _authService;
private IEmailService _emailService;
public IEmailService EmailService
{
get
{
return _emailService;
}
set
{
_emailService = value;
}
}
public UserLogic()
{
_authService = new GoogleOAuthService();
}
...
}
public class UserLogic
{
private GoogleOAuthService _authService;
public UserLogic()
{
_authService = new GoogleOAuthService();
_emailService = new OutlookEmailService() // or Google;
}
public void Register(string emailAddress, string password, IEmailService emailService)
{
var authResult = _authService.RegisterUser(emailAddress,password);
emailService.SendMail(emailAddress, authResult.ConfirmationMessage);
}
}

4 Replies

Know the answer? Post it — somebody with the same question will find it here.

Mageshwaran R6y ago
Hi,
please refer this link:
https://www.slideshare.net/umarali1981/design-patterns-difference-between
0
Laxmidhar Sahoo7y ago
@Gaurav Thank you
0
Gaurav Gahlot7y ago
Hello Sheetal,

Laxmidhar has well explained the Abstract factory part. For dependency injection, I would highly recommend you check the series of articles I have written at the below URL. It will definitely help you get in depth knowledge of DI.

https://www.quickdevnotes.com/tag/dependency-injection/page/2/

@Laxmidhar:
Good job with factory part. However, the examples for dependency injection does not seem to be correct. I'm not sure why you would want to instantiate the dependencies like this:
public class UserLogic
{
    private GoogleOAuthService _authService;

    public UserLogic(IEmailSevice emailService)
    {
        _authService = new GoogleOAuthService();
        _emailService = new OutlookEmailService() // or Google;
    }
}
Because it takes away the soul purpose of using DI in the first place. I hope you would change your code samples and make them as good as factory ones.

Thank you!
+1
Laxmidhar Sahoo7y ago
Factory Pattern: We implement the factory design pattern in a C# program.A factory creates objects With this pattern, we develop an abstraction that isolates the logic for determining which type of class to create.

The factory design pattern relies on a type hierarchy. The classes must all implement an interface or derive from a base class. We use an abstract class as the base. The Manager, Clerk and Programmer classes derive from Position.

Summary. We looked the factory design pattern, which is used to instantiate objects based on another data type such as integers. Factories can be used to reduce code bloat and also make it easier to modify which objects need to be created.

there are two examples
using System;

class Program
{
    abstract class Position
    {
        public abstract string Title { get; }
    }

    class Manager : Position
    {
        public override string Title
        {
            get
            {
                return "Manager";
            }
        }
    }

    class Clerk : Position
    {
        public override string Title
        {
            get
            {
                return "Clerk";
            }
        }
    }

    class Programmer : Position
    {
        public override string Title
        {
            get
            {
                return "Programmer";
            }
        }
    }

    static class Factory
    {
        ///

        /// Decides which class to instantiate.
        ///
        public static Position Get(int id)
        {
            switch (id)
            {
                case 0:
                    return new Manager();
                case 1:
                case 2:
                    return new Clerk();
                case 3:
                default:
                    return new Programmer();
            }
        }
    }

    static void Main()
    {
        for (int i = 0; i <= 3; i++)
        {
            var position = Factory.Get(i);
            Console.WriteLine("Where id = {0}, position = {1} ", i, position.Title);
        }
    }
}
Output

Where id = 0, position = Manager

Where id = 1, position = Clerk

Where id = 2, position = Clerk

Where id = 3, position = Programmer

Another example
using System;
namespace Factory
{
///

/// The 'Product' interface
///
public interface IFactory
{
void Drive(int miles);
}

///

/// A 'ConcreteProduct' class
///
public class Scooter : IFactory
{
public void Drive(int miles)
{
Console.WriteLine("Drive the Scooter : " + miles.ToString() + "km");
}
}

///

/// A 'ConcreteProduct' class
///
public class Bike : IFactory
{
public void Drive(int miles)
{
Console.WriteLine("Drive the Bike : " + miles.ToString() + "km");
}
}

///

/// The Creator Abstract Class
///
public abstract class VehicleFactory
{
public abstract IFactory GetVehicle(string Vehicle);

}

///

/// A 'ConcreteCreator' class
///
public class ConcreteVehicleFactory : VehicleFactory
{
public override IFactory GetVehicle(string Vehicle)
{
switch (Vehicle)
{
case "Scooter":
return new Scooter();
case "Bike":
return new Bike();
default:
throw new ApplicationException(string.Format("Vehicle '{0}' cannot be created", Vehicle));
}
}

}

///

/// Factory Pattern Demo
///
class Program
{
static void Main(string[] args)
{
VehicleFactory factory = new ConcreteVehicleFactory();

IFactory scooter = factory.GetVehicle("Scooter");
scooter.Drive(10);

IFactory bike = factory.GetVehicle("Bike");
bike.Drive(20);

Console.ReadKey();

}
}
}
Dependency Injection (DI) is a technique to create a dependency or dependencies outside the class that uses it. The dependencies are injected from the code that calls the class and any information about their creation are kept away from the inside of the class. This is also why DI is an implementation of the Inversion of control (IoC) principle.

To further explain the dependency injection design pattern, the inversion of control

Inversion of Control Principle

Normally, the flow of the program logic is determined by objects that are bound to one another. With the inversion of control, the flow depends on the defined abstractions to be implemented that is built up during program execution. This principle can be achieved by techniques like dependency injection. In IoC, the code could also be linked statically during compilation to the defined interface functions, but finding the implementation of the function to execute by reading its description from external configuration instead of with a direct reference in the code itself.

There are three ways can inject the objects

1- Through constructor

2- Through properties

3-Through method

Example
public interface IEmailService
{
    void SendMail(string emailAddress, string message)
}

public class GoogleEmailService: IEmailService
{
    public SendMail(string emailAddress, string message)
    {
        //Send an email using google
    }
}

public class OutlookEmailService: IEmailService
{
    public void SendMail(string emailAddress, string message)
    {
        //Send an email using outlook
    }
}


public class UserLogic
{
    private GoogleOAuthService _authService;
    private IEmailService _emailService;

    public UserLogic(IEmailSevice emailService)
    {
        _authService = new GoogleOAuthService();
        _emailService = emailService;
    }
    ...
}

public class UserLogic
{
    private GoogleOAuthService _authService;
    private IEmailService _emailService;

    public IEmailService EmailService
    {
        get
        {
            return _emailService;
        }
        set
        {
            _emailService = value;
        }
    }

    public UserLogic()
    {
        _authService = new GoogleOAuthService();
    }
    ...
}



public class UserLogic
{
    private GoogleOAuthService _authService;

    public UserLogic()
    {
        _authService = new GoogleOAuthService();
        _emailService = new OutlookEmailService() // or Google;
    }

    public void Register(string emailAddress, string password, IEmailService emailService)
    {
        var authResult = _authService.RegisterUser(emailAddress,password);
        emailService.SendMail(emailAddress, authResult.ConfirmationMessage);
    }
}
+2