Skip to main content
Rollback to Revision 3
Source Link
Mast
  • 13.5k
  • 12
  • 54
  • 119

Factory method to create two kinds of cars based on an enum

 //IAuto.cs
    namespace TestDesignPatterns.Auto
    {
        public abstract classinterface IAuto
        {
    
         public abstract  void start();
         public abstract  void stop();
 
        }
    }
    //clsBMW.cs
    namespace TestDesignPatterns.Auto
    {
        public class BMWclsBMW : IAuto
        {
            public BMWvoid start()
            {
            }

          Console.WriteLine("BMW started");
 public override void start()
        }
    {
            public void Console.WriteLinestop("BMW started");
            }
{
         public override void stop()
       Console.WriteLine("BMW {stopped");
            Console.WriteLine("BMW stopped");}
        }
    }

}

namespace TestDesignPatterns.Auto
{
    public class AudiclsAudi : IAuto
    {
        public override void start()
        {
            Console.WriteLine("Audi started");
        }

        public override void stop()
        {
            Console.WriteLine("Audi stopped");
        }
    }
}
//IautoFactory.cs
public interface IAutoFactory
    {
      IAuto CreateAudi();
      IAuto CreateBMWcreateModel(ModelType m);
    }
//clsAutofactory.cs
 public class AutoFactoryclsAutoFactory : IAutoFactory
    {
        public IAuto IAutoFactory.CreateAudicreateModel(ModelType m)
        {
        return new Audi  IAuto instance = null;
            switch (Convert.ToInt32(m);)
    }        {
                case 0:
    IAuto IAutoFactory.CreateBMW               instance = new clsBMW();
    {                break;
        return            
                case 1:
                   instance =  new BMWclsAudi();
                    break;
                default:
                    break;

                   
            } 

            return instance;
        }
    }
 public enum ModelType
    {
        BMW=0,
        Audi=1
    }
//program.cs

             IAutoFactory factory = new AutoFactoryclsAutoFactory();
        
        IAuto audi=model = factory.CreateAudicreateModel(ModelType.Audi);
        audi    model.start();
        audi    model.stop();
            Console.ReadKey();

Factory method to create two kinds of cars

 //IAuto.cs
    namespace TestDesignPatterns.Auto
    {
        public abstract class IAuto
        {

         public abstract void start();
         public abstract void stop();
 
        }
    }
    //clsBMW.cs
    namespace TestDesignPatterns.Auto
    {
        public class BMW : IAuto
        {
            public BMW()
            {
            }

            public override void start()
            {
              Console.WriteLine("BMW started");
            }

         public override void stop()
        {
            Console.WriteLine("BMW stopped");
       }
}

}

namespace TestDesignPatterns.Auto
{
    public class Audi : IAuto
    {
        public override void start()
        {
            Console.WriteLine("Audi started");
        }

        public override void stop()
        {
            Console.WriteLine("Audi stopped");
        }
    }
}
//IautoFactory.cs
public interface IAutoFactory
    {
      IAuto CreateAudi();
      IAuto CreateBMW();
    }
//clsAutofactory.cs
 public class AutoFactory : IAutoFactory
    {
        IAuto IAutoFactory.CreateAudi()
    {
        return new Audi();
    }

    IAuto IAutoFactory.CreateBMW()
    {
        return new BMW();
    }
   }
//program.cs

             IAutoFactory factory = new AutoFactory();
        
        IAuto audi= factory.CreateAudi();
        audi.start();
        audi.stop();
        Console.ReadKey();

Factory method to create two kinds of cars based on an enum

 //IAuto.cs
    namespace TestDesignPatterns.Auto
    {
        public interface IAuto
        {
    
            void start();
            void stop();
        }
    }
    //clsBMW.cs
    namespace TestDesignPatterns.Auto
    {
        public class clsBMW : IAuto
        {
            public void start()
            {
                Console.WriteLine("BMW started");
            }
    
            public void stop()
            {
                Console.WriteLine("BMW stopped");
            }
        }
    }
namespace TestDesignPatterns.Auto
{
    public class clsAudi : IAuto
    {
        public void start()
        {
            Console.WriteLine("Audi started");
        }

        public void stop()
        {
            Console.WriteLine("Audi stopped");
        }
    }
}
//IautoFactory.cs
public interface IAutoFactory
    {
       IAuto createModel(ModelType m);
    }
//clsAutofactory.cs
 public class clsAutoFactory : IAutoFactory
    {
        public IAuto createModel(ModelType m)
        {
            IAuto instance = null;
            switch (Convert.ToInt32(m))
            {
                case 0:
                    instance = new clsBMW();
                    break;
                    
                case 1:
                   instance =  new clsAudi();
                    break;
                default:
                    break;

                   
            } 

            return instance;
        }
    }
 public enum ModelType
    {
        BMW=0,
        Audi=1
    }
//program.cs

            IAutoFactory factory = new clsAutoFactory();
            IAuto model = factory.createModel(ModelType.Audi);
            model.start();
            model.stop();
            Console.ReadKey();
updated the code as per the comments.
Source Link

Factory method to create two kinds of cars based on an enum

 //IAuto.cs
    namespace TestDesignPatterns.Auto
    {
        public interfaceabstract class IAuto
        {
    
          public abstract void start();
          public abstract void stop(); 

        }
    }
    //clsBMW.cs
    namespace TestDesignPatterns.Auto
    {
        public class clsBMWBMW : IAuto
        {
            public void startBMW()
            {
            }

    Console.WriteLine("BMW started");
       public override void start()
        }
    {
            public void stopConsole.WriteLine("BMW started");
            {}
     
         public override void Console.WriteLinestop("BMW stopped");
        {
    }
        }Console.WriteLine("BMW stopped");
       }
}

}

namespace TestDesignPatterns.Auto
{
    public class clsAudiAudi : IAuto
    {
        public override void start()
        {
            Console.WriteLine("Audi started");
        }

        public override void stop()
        {
            Console.WriteLine("Audi stopped");
        }
    }
}
//IautoFactory.cs
public interface IAutoFactory
    {
       IAuto createModelCreateAudi(ModelType);
 m     IAuto CreateBMW();
    }
//clsAutofactory.cs
 public class clsAutoFactoryAutoFactory : IAutoFactory
    {
        public IAuto createModel(ModelType m)
        {
            IAuto instance = null;
            switch (ConvertIAutoFactory.ToInt32CreateAudi(m))
            {
                case 0:
                    instance =return new clsBMWAudi();
                    break;}
                    
                caseIAuto 1:IAutoFactory.CreateBMW()
             {
      instance = return new clsAudiBMW();
                    break;
                default:
                    break;

                   
            }
 
            return instance;
        }
    }
 public enum ModelType
    {
        BMW=0,
        Audi=1
    }
//program.cs

             IAutoFactory factory = new clsAutoFactoryAutoFactory();
         
    IAuto model =  IAuto audi= factory.createModelCreateAudi(ModelType.Audi);
            modelaudi.start();
            modelaudi.stop();
            Console.ReadKey();

Factory method to create two kinds of cars based on an enum

 //IAuto.cs
    namespace TestDesignPatterns.Auto
    {
        public interface IAuto
        {
    
            void start();
            void stop();
        }
    }
    //clsBMW.cs
    namespace TestDesignPatterns.Auto
    {
        public class clsBMW : IAuto
        {
            public void start()
            {
                Console.WriteLine("BMW started");
            }
    
            public void stop()
            {
                Console.WriteLine("BMW stopped");
            }
        }
    }
namespace TestDesignPatterns.Auto
{
    public class clsAudi : IAuto
    {
        public void start()
        {
            Console.WriteLine("Audi started");
        }

        public void stop()
        {
            Console.WriteLine("Audi stopped");
        }
    }
}
//IautoFactory.cs
public interface IAutoFactory
    {
       IAuto createModel(ModelType m);
    }
//clsAutofactory.cs
 public class clsAutoFactory : IAutoFactory
    {
        public IAuto createModel(ModelType m)
        {
            IAuto instance = null;
            switch (Convert.ToInt32(m))
            {
                case 0:
                    instance = new clsBMW();
                    break;
                    
                case 1:
                   instance =  new clsAudi();
                    break;
                default:
                    break;

                   
            }
 
            return instance;
        }
    }
 public enum ModelType
    {
        BMW=0,
        Audi=1
    }
//program.cs

            IAutoFactory factory = new clsAutoFactory();
            IAuto model = factory.createModel(ModelType.Audi);
            model.start();
            model.stop();
            Console.ReadKey();

Factory method to create two kinds of cars

 //IAuto.cs
    namespace TestDesignPatterns.Auto
    {
        public abstract class IAuto
        {

         public abstract void start();
         public abstract void stop(); 

        }
    }
    //clsBMW.cs
    namespace TestDesignPatterns.Auto
    {
        public class BMW : IAuto
        {
            public BMW()
            {
            }

            public override void start()
            {
              Console.WriteLine("BMW started");
            }
 
         public override void stop()
        {
            Console.WriteLine("BMW stopped");
       }
}

}

namespace TestDesignPatterns.Auto
{
    public class Audi : IAuto
    {
        public override void start()
        {
            Console.WriteLine("Audi started");
        }

        public override void stop()
        {
            Console.WriteLine("Audi stopped");
        }
    }
}
//IautoFactory.cs
public interface IAutoFactory
    {
      IAuto CreateAudi();
      IAuto CreateBMW();
    }
//clsAutofactory.cs
 public class AutoFactory : IAutoFactory
    {
        IAuto IAutoFactory.CreateAudi()
    {
        return new Audi();
    }

    IAuto IAutoFactory.CreateBMW()
    {
        return new BMW();
    }
   }
//program.cs

             IAutoFactory factory = new AutoFactory();
         
        IAuto audi= factory.CreateAudi();
        audi.start();
        audi.stop();
        Console.ReadKey();
edited tags
Source Link
200_success
  • 144.2k
  • 22
  • 188
  • 473

Factory method implementation - is it the right approachto create two kinds of cars based on an enum

I am implementing the factory method approach. Is there any flaw in the implementation? Adding the code which i had asked in the stackoverflow forum. My intention is to know if my approach is correct for factory method. Any modifications to be done to align with the approach?

 public enum ModelType
    {
        BMW=0,
        Audi=1
    }
//program.cs

            IAutoFactory factory = new clsAutoFactory();
            IAuto model = factory.createModel(ModelType.Audi);
            model.start();
            model.stop();
            Console.ReadKey();

Factory method implementation - is it the right approach

I am implementing the factory method approach. Is there any flaw in the implementation? Adding the code which i had asked in the stackoverflow forum. My intention is to know if my approach is correct for factory method. Any modifications to be done to align with the approach?

 public enum ModelType
    {
        BMW=0,
        Audi=1
    }
//program.cs

            IAutoFactory factory = new clsAutoFactory();
            IAuto model = factory.createModel(ModelType.Audi);
            model.start();
            model.stop();
            Console.ReadKey()

Factory method to create two kinds of cars based on an enum

I am implementing the factory method approach. My intention is to know if my approach is correct for factory method. Any modifications to be done to align with the approach?

 public enum ModelType
    {
        BMW=0,
        Audi=1
    }
//program.cs

            IAutoFactory factory = new clsAutoFactory();
            IAuto model = factory.createModel(ModelType.Audi);
            model.start();
            model.stop();
            Console.ReadKey();
Post Reopened by Stephen Rauch, user34073, alecxe, Sᴀᴍ Onᴇᴌᴀ, hjpotter92
added the code
Source Link
Loading
Post Closed as "Not suitable for this site" by Heslacher, Vogel612
Source Link
Loading