Re: Factory pattern: issue with this definition "let subclass decide which class to instantiate." - C# Discussion Boards

Re: C#: When one should go for factory method pattern instead of factory pattern

5-Apr-17 7:33

It's like a stake through the heart.

This space for rent

Luc Pattyn5-Apr-17 8:18

Luc Pattyn

5-Apr-17 8:18

Quote:
He doesn't like reading

Yeah, and that is exactly why a few days ago I failed to understand his thread on hashing/encryption collected 30+ replies.

Confused | :confused:

Luc Pattyn [My Articles] Nil Volentibus Arduum

Re: C#: When one should go for factory method pattern instead of factory pattern

Pete O'Hanlon5-Apr-17 8:33

Re: C#: When one should go for factory method pattern instead of factory pattern

5-Apr-17 8:33

It surprised me as well. Granted, I did reply - but that was to warn people that he was a Help Vampire.

This space for rent

OriginalGriff5-Apr-17 8:37

OriginalGriff

5-Apr-17 8:37

In our collective defence, most of 'em were to Gerry - who was trying to defend the indefensible without knowing anything about what he was saying. Big Grin | :-D

Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...

Re: C#: When one should go for factory method pattern instead of factory pattern

Luc Pattyn5-Apr-17 9:02

Luc Pattyn

5-Apr-17 9:02

That is alright then

Smile | :)

Luc Pattyn [My Articles] Nil Volentibus Arduum

Re: C#: When one should go for factory method pattern instead of factory pattern

Eddy Vluggen6-Apr-17 1:48

Eddy Vluggen

6-Apr-17 1:48

Tridip Bhattacharjee wrote:
please tell me a solid scenario when people feel right to choose factory method pattern. thanks

IDbConnection.CreateCommand();

Doesn't even take parameters Smile | :)

Bastard Programmer from Hell Suspicious | :suss:

If you can't read my code, try converting it here[^]

Factory pattern: issue with this definition "let subclass decide which class to instantiate."

Tridip Bhattacharjee5-Apr-17 2:09

Re: Factory pattern: issue with this definition "let subclass decide which class to instantiate."

5-Apr-17 2:09

after searching google for Factory pattern definition i found it is

Factory pattern

In Factory pattern, we create object without exposing the creation logic. In this pattern,
an interface is used for creating an object, but let subclass decide which class to instantiate.
The creation of object is done when it is required.
The Factory method allows a class later instantiation to subclasses.

see my Factory pattern related code and there is no subclass which instantiate class object rather i have class with a static function which create & return class object.

so my question is that above definition is saying "subclass decide which class to instantiate" but in my code there is no subclass or child class rather a separate class create instance. is the above definition is for factory method pattern ?

here is my code

public enum Shipper
    {
        UPS = 1,
        FedEx = 2,
        Purolator = 3
    }

    public interface IShip
    {
        void Ship();
    }

    public class ShipperPurolator : IShip
    {
        public void Ship()
        {
            //-- code logic to implement shipping method for Purolator
            MessageBox.Show("Purolator ship start");
        }
    }

    public class ShipperUPS : IShip
    {
        public void Ship()
        {
            //-- code logic to implement shipping method for Purolator
            MessageBox.Show("UPS ship start");
        }
    }

    public class ShipperFexEx : IShip
    {
        public void Ship()
        {
            //-- code logic to implement shipping method for Purolator
            MessageBox.Show("FedEx ship start");
        }
    }

    public class ShipperFactory
    {
        public static IShip CreateInstance(Shipper enumModuleName)
        {
            IShip objActivity = null;

            switch (enumModuleName)
            {
                case Shipper.UPS:
                    objActivity = new ShipperUPS();
                    break;
                case Shipper.FedEx:
                    objActivity = new ShipperFexEx();
                    break;
                case Shipper.Purolator:
                    objActivity = new ShipperPurolator();
                    break;
                default:
                    break;
            }
            return objActivity;
        }
    }

calling this way

IShip objActivity = null;


        private void btnUPS_Click(object sender, EventArgs e)
        {
            objActivity = ShipperFactory.CreateInstance(Shipper.UPS);
            objActivity.Ship();
        }

        private void btnFedEx_Click(object sender, EventArgs e)
        {
            objActivity = ShipperFactory.CreateInstance(Shipper.FedEx);
            objActivity.Ship();
        }

        private void btnPurolator_Click(object sender, EventArgs e)
        {
            objActivity = ShipperFactory.CreateInstance(Shipper.Purolator);
            objActivity.Ship();
        }

please guide me regarding above definition.

thanks

tbhattacharjee

Pete O'Hanlon5-Apr-17 2:34

Re: Factory pattern: issue with this definition "let subclass decide which class to instantiate."

5-Apr-17 2:34

What you have there is fine. In the GoF (Gang of Four) definition, they are talking about the idea of having something like an abstract base class - the factory method will use this as the return type, but would create concrete versions of the classes that are subclassed off this. As you are using an interface instead (a better choice to my mind), this is your return type.

This space for rent

Eddy Vluggen5-Apr-17 2:54

Eddy Vluggen

5-Apr-17 2:54

Tridip Bhattacharjee wrote:
please guide me regarding above definition.

Open this page[^], and scroll down to the answer that begins with "Let's understand difference between Factory and FactoryMethod with an example".

Bastard Programmer from Hell Suspicious | :suss:

If you can't read my code, try converting it here[^]

Task.Wait() -Why??

Kevin Marois4-Apr-17 6:54

Kevin Marois

4-Apr-17 6:54

See this MSDN example

If Task.Wait blocks, why would you ever want to use it?? If I'm in a WPF app and I launch a task from the main thread, it blocks the UI, so why bother using a thread? If I'm going to block the main thread, why not just put the thread's code in the UI to start with?

Someone please give me a real example of when I would really want to use Task.Wait.

Thanks

If it's not broken, fix it until it is.
Everything makes sense in someone's mind.
Ya can't fix stupid.

Pete O'Hanlon4-Apr-17 7:00

4-Apr-17 7:00

You are assuming here that the only time that you would want to use a Task is off the UI thread. This isn't the case. As an example, suppose you wrote some code to index files in a particular folder - and you then want to finish the task only once the indexing has completed, you could very well create a top level task and then fire off multiple tasks inside - with a Wait on them completing.

This space for rent

Kevin Marois4-Apr-17 7:19

Kevin Marois

4-Apr-17 7:19

So, Task A spawns 3 child tasks, then waits for all 3 to finish.

In this case you would want Task A to run async, correct?

If it's not broken, fix it until it is.
Everything makes sense in someone's mind.
Ya can't fix stupid.

Pete O'Hanlon4-Apr-17 7:26

4-Apr-17 7:26

Yes.

This space for rent

Richard Deeming4-Apr-17 7:38

4-Apr-17 7:38

In that example, it would be better to use Task.WhenAll[^] to wait for the child tasks to complete.

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

Pete O'Hanlon4-Apr-17 7:40

4-Apr-17 7:40

That's true. I was trying more to illustrate the point that waiting on a task or a series of tasks doesn't mean that you created it off a UI thread.

This space for rent

Richard Deeming4-Apr-17 7:48

4-Apr-17 7:48

There are very few situations where it's necessary to block the current thread until a task has completed. The only obvious one that comes to mind is when you're writing a console application, and you want to use async code. And with .NET 4.5 or higher, it's usually better to call task.GetAwaiter().GetResult() rather than task.Wait(), to avoid having any exceptions wrapped in an AggregateException.

static class Program
{
    static void Main()
    {
        MainAsync().GetAwaiter().GetResult();
    }
    
    static async Task MainAsync()
    {
        ...
    }
}

But in most cases, there's usually a better option than blocking the current thread.

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

Kevin Marois4-Apr-17 7:52

Kevin Marois

4-Apr-17 7:52

Richard Deeming wrote:
There are very few situations where it's necessary to block the current thread until a task has completed.

That's why I asked. I can't see a reason to block, and the example I posted shows the Main method of a console app creating a thread that blocks.

It's a typical stupid MSDN example, but I thought I'd ask anyhow.

Thanks

If it's not broken, fix it until it is.
Everything makes sense in someone's mind.
Ya can't fix stupid.

Richard Deeming4-Apr-17 8:04

4-Apr-17 8:04

I guess it's difficult to produce a meaningful real-world example that doesn't end up with the concept you're trying to demonstrate buried in unrelated implementation details. Smile | :)

You just need to imagine that the task is an async method, calling an API that's only available via asynchronous task-returning methods. The Main thread is synchronous, so you're going to have to block at some point to wait for the API calls to complete.

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

Tridip Bhattacharjee5-Apr-17 23:30

5-Apr-17 23:30

this line

MainAsync().GetAwaiter().GetResult();

block the main thread.

thanks

tbhattacharjee

Richard Deeming6-Apr-17 1:30

in which scenario people use factory design patter

6-Apr-17 1:30

Yes - which is exactly what I said in my message, if you'd bothered to read it. D'Oh! | :doh:

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

Tridip Bhattacharjee4-Apr-17 1:58

Re: in which scenario people use factory design patter

4-Apr-17 1:58

we know that in factory design patter we do not create object of any class directly rather create instance of a class by factory class.

The client is an object that requires an instance
of another object (the product) for some purpose. Rather than creating the
product instance directly, the client delegates this responsibility to the factory.
Once invoked, the factory creates a new instance of the product,
passing it back to the client. Put simply, the client uses the
factory to create an instance of the product.

i read this article https://msdn.microsoft.com/en-us/library/ee817667.aspx?f=255&MSPPError=-2147217396

i am looking for a write up on factory design patter which show me when i need to create instance by factory because we can create instance directly but in factory design pattern instance create via factory. so what is the significance of factory design patter.

so if anyone search google there is many article exist on factory design pattern but i do not find any article which tell me scenario when i will not create instance directly rather will create instance via factory.

so please tell me few scenario with example code from where i can see when people would not prefer creating instance of any class directly rather will create instance via factory.

thanks

tbhattacharjee

Eddy Vluggen4-Apr-17 2:29

Eddy Vluggen

4-Apr-17 2:29

Tridip Bhattacharjee wrote:
i am looking for a write up on factory design patter which show me when i need to create instance by factory because we can create instance directly but in factory design pattern instance create via factory. so what is the significance of factory design patter.

A nice idea would be to create a factory if there are more than a single class than can be used to perform the action.

Simple and usefull example can be found in the DbProviderFactory. Instead of programming against the SqlConnection and SqlCommand, you program against the interfaces IDbConnection and IDbCommand. Next, let the factory decide which actual class to create. That way the user can configure suddenly whether to use the SqlConnection, an OracleConnection, or something completely different.

Another nice idea for factories is that they can also be combined with the Object Pool Pattern. See the TaskFactory for a nice example of that.

It's similar to the strategy-pattern, with the difference that a factory is for creating objects.

Bastard Programmer from Hell Suspicious | :suss:

If you can't read my code, try converting it here[^]

Re: in which scenario people use factory design patter

Tridip Bhattacharjee4-Apr-17 3:48

Re: in which scenario people use factory design patter

4-Apr-17 3:48

thanks for nice answer. can you please include a article link sir which show how i can use DbProviderFactory to connect sql server ,oracle, oldedb or use dsn to connect any db.

thanks

tbhattacharjee

Pete O'Hanlon4-Apr-17 4:14