public AddVehicleCommandProcessor(IVehicleFactory vehicleFactory, IUserService userService)
{
Validator.ValidateNull(vehicleFactory, "vehicleFactory");
Validator.ValidateNull(userService, "userService");
this.vehicleFactory = vehicleFactory;
this.userService = userService;
}
public void Should_create_a_Car_of_the_specified_type(IVehicleFactory vehicleFactory, Type expectedCarType)
{
// Act
ICar result = vehicleFactory.CreateCar();
// Assert
Assert.IsType(expectedCarType, result);
}
public void Should_create_a_Bike_of_the_specified_type(IVehicleFactory vehicleFactory, Type expectedBikeType)
{
// Act
IBike result = vehicleFactory.CreateBike();
// Assert
Assert.IsType(expectedBikeType, result);
}
public CarService(ICarRepository carRepository,
VehicleContext context,
IVehicleFactory <Car, CreateCarCommand> carFactory)
{
this._carRepository = carRepository;
this._context = context;
this._factory = carFactory;
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
IVehicleFactory factory = null;
CreateAndDisplayCar(ref factory);
CreateAndDisplayTruck(ref factory);
ReadKey();
}
public TankManager(IBattleOperator battleOperator)
{
this.battleOperator = battleOperator;
this.vehicles = new Dictionary <string, IVehicle>();
this.parts = new Dictionary <string, IPart>();
this.defeatedVehicles = new List <string>();
this.vehicleFactory = new VehicleFactory();
this.partFactory = new PartFactory();
}
public VehicleService(IVehicleFactory vehicleFactory,
IVINQueryService vinQueryService,
IProgramService programService,
IConfiguration configuration)
{
_vehicleFactory = vehicleFactory;
_vinQueryService = vinQueryService;
_configuration = configuration;
_programService = programService;
}
public TankManager(IBattleOperator battleOperator, IVehicleFactory vehicleFactory, IPartFactory partFactory)
{
this.battleOperator = battleOperator;
this.vehicles = new Dictionary <string, IVehicle>();
this.defeatedVehicles = new List <string>();
this.vehicleFactory = vehicleFactory;
this.partFactory = partFactory;
}
public VehicleFactory(VehicleRequirements vehicleReqs)
{
_factory = vehicleReqs.bEngine ? (IVehicleFactory) new MotorVehicleFactory() : new CycleFactory();
_requirements = vehicleReqs;
//Limit checks
_requirements.wheelCount = Mathf.Max(1, vehicleReqs.wheelCount);
_requirements.passengerCount = Mathf.Max(1, vehicleReqs.passengerCount);
}
static void BuildVehicle(IVehicleFactory factory)
{
Engine engine = factory.CreateEngine();
InnerPart innerPart = factory.CreateInnerPart();
OuterPart outerPart = factory.CreateOuterPart();
engine.CheckEngine();
innerPart.CheckInnerPart();
outerPart.CheckOuterPart();
}
public StorageMaster()
{
this.productFactory = new ProductFactory();
this.storageFactory = new StorageFactory();
this.vehicleFactory = new VehicleFactory();
this.productPool = new List <Product>();
this.storageRegistry = new List <Storage>();
this.currentVehicle = null;
}
public void Test()
{
factory = new SimpleVehicleFactory(Terrains.AIR);
Assert.IsInstanceOfType(factory.Create(), typeof(Plane));
factory = new SimpleVehicleFactory(Terrains.LAND);
Assert.IsInstanceOfType(factory.Create(), typeof(Car));
factory = new SimpleVehicleFactory(Terrains.SEA);
Assert.IsInstanceOfType(factory.Create(), typeof(Ship));
}
public static void Main()
{
FactoryEnum selectedFactory = (FactoryEnum)Enum.Parse(typeof(FactoryEnum), Console.ReadLine());
IVehicleFactory factory = GetFactory(selectedFactory);
ICar car = factory.GetCar();
Console.WriteLine(car.Type());
ITruck truck = factory.GetTruck();
Console.WriteLine(truck.Type());
}
/// <summary>
/// Code inside to be written in client mathod
/// </summary>
public static void CallFactory()
{
VehicleFactory factory = new ConcreteVehicleFactory();
IVehicleFactory scooter = factory.GetVehicle("Scooter");
scooter.Drive(10);
IVehicleFactory bike = factory.GetVehicle("Bike");
bike.Drive(20);
Console.ReadKey();
}
static void Main(string[] args)
{
IVehicleFactory factory = GetFactory("Factory_method_real.LincolnAviatorFactory");
var lincolnAviator = factory.CreateVehicle();
lincolnAviator.ShowInfo();
factory = GetFactory("Factory_method_real.FordExplorerFactory");
var fordExplorer = factory.CreateVehicle();
fordExplorer.ShowInfo();
}
static void Main(string[] args)
{
IVehicleFactory factory = GetFactory("FactoryMethodPattern.ConcreteFactories.LincolnAviatorFactory");
var lincolnAviator = factory.CreateVehicle();
lincolnAviator.ShowInfo();
factory = GetFactory("FactoryMethodPattern.ConcreteFactories.FordExplorerFactory");
var fordExplorer = factory.CreateVehicle();
fordExplorer.ShowInfo();
}
public ParkingLotController(IMemoryCache memoryCache, IParkingLotFactory parkingLotFactory, IVehicleFactory vehicleFactory)
{
_memoryCache = memoryCache;
_parkingLotFactory = parkingLotFactory;
_vehicleFactory = vehicleFactory;
// Load up some test data using MemoryCache for demonstration
_parkingLot = _memoryCache.GetOrCreate <IParkingLot>("ParkingLot", entry =>
{
var parkingLot = _parkingLotFactory.Create();
parkingLot.ParkVehicle(_vehicleFactory.Create <CompactVehicle>());
parkingLot.ParkVehicle(_vehicleFactory.Create <TruckVehicle>());
return(parkingLot);
});
}
public AccountController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IEmailSender emailSender,
IVehicleViewModelService vehicleService,
IVehicleFactory vehicleFactory,
ILogger <AccountController> logger
)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_vehicleService = vehicleService;
_vehicleFactory = vehicleFactory;
}
public DealershipEngine(
IInputOutputProvider provider,
ICommentFactory commentFactory,
ICommandFactory commandFactory,
IUserFactory userFactory,
IVehicleFactory vehicleFactory)
{
this.provider = provider;
this.commentFactory = commentFactory;
this.commandFactory = commandFactory;
this.userFactory = userFactory;
this.vehicleFactory = vehicleFactory;
this.users = new Collection <IUser>();
this.loggedUser = null;
}
public VehicleFactory(VehicleRequirements requirements)
{
if (requirements.Engine == true && requirements.HasCargo == false)
{
_factory = (IVehicleFactory) new MotorVehicleFactory();
}
else if (requirements.Engine == false && requirements.HasCargo == true)
{
_factory = (IVehicleFactory) new AirplaneVehicleFactory();
}
else
{
_factory = new Cyclefactory();
}
_requirements = requirements;
}
public DealershipEngine(
IInputOutputProvider provider,
ICommentFactory commentFactory,
ICommandFactory commandFactory,
IUserFactory userFactory,
IVehicleFactory vehicleFactory)
{
this.provider = provider;
this.commentFactory = commentFactory;
this.commandFactory = commandFactory;
this.userFactory = userFactory;
this.vehicleFactory = vehicleFactory;
this.users = new Collection<IUser>();
this.loggedUser = null;
}
private static void CreateAndDisplayTruck(ref IVehicleFactory factory)
{
factory = AutoMBuilder.Build(BodyType.Truck);
IVehicle vehicle = factory.GetVehicle(IgnitionType.Automatic.ToString());
WriteLine($" Vehicle {vehicle.ToString()}");
vehicle = factory.GetVehicle(IgnitionType.Manual.ToString());
WriteLine($" Vehicle {vehicle.ToString()}");
vehicle = factory.GetVehicle(IgnitionType.None.ToString());
WriteLine($" Vehicle {vehicle.ToString()}");
ReadKey();
}
private static VehicleAndFeeFactory CreateSut(IVehicleFactory vehicleFactory = null,
IFeesForVehicleFactory feeFactory = null)
{
if (vehicleFactory == null)
{
vehicleFactory = new TestIVehicleFactory();
}
if (feeFactory == null)
{
feeFactory = new FeesForVehicleFactory(new TestIFeeFactory());
}
var sut = new VehicleAndFeeFactory(vehicleFactory,
feeFactory);
return(sut);
}
public static IVehicleFactory Build(BodyType bodyType)
{
IVehicleFactory factory = null;
if (bodyType == BodyType.Car)
{
factory = new ConcreteCarVehicleFactory();
}
else if (bodyType == BodyType.Truck)
{
factory = new ConcreteTruckVehicleFactory();
}
else
{
factory = new ConcreteDefaultVehicleFactory();
}
return(factory);
}
public static void Main_xx(string[] args)
{
IVehicleFactory hondaFactory = Client.GetFactory("Honda");
var city = hondaFactory.GetCar("City");
Console.WriteLine(city.GetType().Name);
var truck = hondaFactory.GetTruck("Valcano");
Console.WriteLine(truck.GetType().Name);
IVehicleFactory toyotaFactory = Client.GetFactory("Toyota");
var gli = toyotaFactory.GetCar("Gli");
Console.WriteLine(gli.GetType().Name);
truck = toyotaFactory.GetTruck("TruckB");
Console.WriteLine(truck.GetType().Name);
Console.ReadKey();
}
public override IVehicleFactory GetVehicle(EVehicleType type)
{
IVehicleFactory ObjVehicleFactory = null;
switch (type)
{
case EVehicleType.Bike:
ObjVehicleFactory = new Bike();
break;
case EVehicleType.Scooter:
ObjVehicleFactory = new Scooter();
break;
case EVehicleType.Car:
ObjVehicleFactory = new Car();
break;
case EVehicleType.Bus:
ObjVehicleFactory = new Bus();
break;
case EVehicleType.Lorry:
ObjVehicleFactory = new Lorry();
break;
case EVehicleType.Train:
ObjVehicleFactory = new Train();
break;
case EVehicleType.Ship:
ObjVehicleFactory = new Ship();
break;
case EVehicleType.Helicopter:
ObjVehicleFactory = new Helicopter();
break;
default:
break;
}
return(ObjVehicleFactory);
}
public VehicleFactory(VehicleRequirements requirements)
{
//_factory = requirements.Engine ? (IVehicleFactory)new MotorVehicleFactory() : new Cyclefactory();
//_requirements = requirements;
if (requirements.canFly)
{
_factory = (IVehicleFactory) new PlaneFactory();
_requirements = requirements;
}
else if (requirements.Engine)
{
_factory = (IVehicleFactory) new MotorVehicleFactory();
_requirements = requirements;
}
else
{
_factory = (IVehicleFactory) new Cyclefactory();
_requirements = requirements;
}
}
public void Execute()
{
IVehicleFactory vehicleFactory = null;
Console.WriteLine("Enter 1 to drive Bike.");
Console.WriteLine("Enter 2 to drive Scooty.");
var choice = Convert.ToInt32(Console.ReadLine());
if (choice == 1)
{
vehicleFactory = new BikeFactory(110, 55);
}
else
{
vehicleFactory = new ScootyFactory(80, 65);
}
var vehicle = vehicleFactory.CreateVehicle();
vehicle.Drive();
}
public Engine(IReader reader, IWriter writer, IVehicleFactory vehicleFactory)
{
this.reader = reader;
this.writer = writer;
this.vehicleFactory = vehicleFactory;
}
public SourcePath(double length, IVehicleFactory factory)
: base(length)
{
lastAddTime = 0;
this.factory = factory;
}
public VehicleFactory(VehicleRequirements requirements)
{
_factory = requirements.HasEngine ? (IVehicleFactory) new MotorVehicleFactory() : new Cyclefactory();
_requirements = requirements;
}
public CarSeller(IVehicleFactory vehicleFactory)
{
this.Car = vehicleFactory.CreateCar();
this.Truck = vehicleFactory.CreateTruck();
}
