public void CreateGreenObject() { abstractFactory = factoryProducer.getFactory("color"); IColor color = abstractFactory.GetColor("green"); Assert.IsInstanceOf <Green>(color); }
public void InvalidSurgicalSpecialtyAverage() { // Arrange IAbstractFactory abstractFactory = AbstractFactory.Create(); IDependenciesAbstractFactory dependenciesAbstractFactory = abstractFactory.CreateDependenciesAbstractFactory(); IPatientLengthOfStayInputContext patientLengthOfStayInputContext = abstractFactory.CreateContextsAbstractFactory().CreatePatientLengthOfStayInputContextFactory().Create( specialty: dependenciesAbstractFactory.CreateCodeableConceptFactory().Create(BoneAndMarrowTransplantationSurgery, SNOMEDCT, null), statistic: dependenciesAbstractFactory.CreateValueFactory().CreateAverage()); IPatientLengthOfStayExport patientLengthOfStayExport = abstractFactory.CreateExportsAbstractFactory().CreatePatientLengthOfStayExportFactory().Create(); // Act Action action = () => { IPatientLengthOfStayOutputContext surgicalDurationOutputContext = patientLengthOfStayExport.GetPatientLengthOfStay( abstractFactory, patientLengthOfStayInputContext); }; // Assert Assert.ThrowsException <NullReferenceException>( action); }
public void CreateRedObject() { abstractFactory = factoryProducer.getFactory("color"); IColor color = abstractFactory.GetColor("red"); Assert.IsInstanceOf <Red>(color); }
public void CreateSquareObject() { abstractFactory = factoryProducer.getFactory("shape"); IShape shape = abstractFactory.GetShape("square"); Assert.IsInstanceOf <Square>(shape); }
public void CreateCircleObject() { abstractFactory = factoryProducer.getFactory("shape"); IShape shape = abstractFactory.GetShape("circle"); Assert.IsInstanceOf <Circle>(shape); }
public void Table1( string specialty, decimal value, string unit, string statistic) { // Arrange IAbstractFactory abstractFactory = AbstractFactory.Create(); IDependenciesAbstractFactory dependenciesAbstractFactory = abstractFactory.CreateDependenciesAbstractFactory(); IPatientLengthOfStayInputContext patientLengthOfStayInputContext = abstractFactory.CreateContextsAbstractFactory().CreatePatientLengthOfStayInputContextFactory().Create( specialty: dependenciesAbstractFactory.CreateCodeableConceptFactory().Create(specialty, SNOMEDCT, null), statistic: dependenciesAbstractFactory.CreateValueFactory().Create(statistic)); IPatientLengthOfStayExport patientLengthOfStayExport = abstractFactory.CreateExportsAbstractFactory().CreatePatientLengthOfStayExportFactory().Create(); // Act IPatientLengthOfStayOutputContext patientLengthOfStayOutputContext = patientLengthOfStayExport.GetPatientLengthOfStay( abstractFactory, patientLengthOfStayInputContext); // Assert Assert.AreEqual( expected: value, actual: patientLengthOfStayOutputContext.Duration.Value.Value); Assert.AreEqual( expected: unit, actual: patientLengthOfStayOutputContext.Duration.UnitElement.Value); }
public static void ClientCode(IAbstractFactory factory) { IAbstractMainboard mainboard = factory.CreateMainboard(); IAbstractProcessor processor = factory.CreateProcessor(); Console.WriteLine(mainboard.GetProcessor(processor)); }
public void run(IAbstractFactory factory) { IAbstractProductA p1 = factory.CreateProductA(); IAbstractProductB p2 = factory.CreateProductB(); p2.Interact(p1); }
public void AddFactory(IAbstractFactory <TKey, TValue> factory) { if (factory != null) { container.Add(factory); } }
public Computer(IAbstractFactory abstractFactory, string brand, string model) { Cpu = abstractFactory.CreateCpu(); Memory = abstractFactory.CreateMemory(); Brand = brand; Model = model; }
/// <summary> /// Constructor /// </summary> /// <param name="archivePath">Fully qualified file name for archive file</param> /// <param name="abstractFactory">Factory to create tokenizers, readers etc.</param> public ArchiveReader(string archivePath, IAbstractFactory abstractFactory) { this.abstractFactory = abstractFactory ?? throw new ArgumentNullException(nameof(abstractFactory)); FileAttributes fileAttributes = File.GetAttributes(archivePath); if ((fileAttributes & FileAttributes.Directory) == FileAttributes.Directory) { //File is a directory. Set the outputPath and continue OutputPath = string.IsNullOrWhiteSpace(archivePath) ? throw new ArgumentNullException(nameof(archivePath)) : archivePath; } else { //File is an archive file. Extract to temp directory archiveFolder = abstractFactory.CreateArchiveFolder(archivePath); OutputPath = archiveFolder.Extract(); } FileName = archivePath; metaDataReader = abstractFactory.CreateMetaDataReader(); MetaData = metaDataReader.ReadMetaData(OutputPath); //Create a core file reader var coreFileMetaData = abstractFactory.CreateCoreMetaData(MetaData.Core); coreFile = CreateFileReader(coreFileMetaData); //Create file readers for extensions foreach (var extension in MetaData.Extension) { var extensionFileName = extension.Files.FirstOrDefault(); var extensionFileMetaData = abstractFactory.CreateExtensionMetaData(extension); extensionFiles.Add(CreateFileReader(extensionFileMetaData)); } Extensions = new FileReaderCollection(extensionFiles); }
public void ClientMethod(IAbstractFactory factory) { IAbstractProductA productA = factory.CreateProductA(); IAbstractProductB productB = factory.CreateProductB(); Console.WriteLine(productB.GetInfo()); }
public static void Run() { IAbstractFactory af = null; Console.WriteLine("What kind of factory do you want to create"); Console.WriteLine("1 > Wooden"); Console.WriteLine("2 > Steel"); var choise = Console.ReadLine(); switch (choise) { case "1": af = new WoodenFactory(); break; case "2": af = new SteelFactory(); break; default: Console.WriteLine("wrong choise"); break; } if (af == null) { return; } var toy = af.GetCar(); Console.WriteLine($"in result we have {toy.Name}"); }
internal static void BindModelStatic <TModel>(TModel model, IAbstractFactory factory, IModelOptions options, IConfigUiServices uiServices) where TModel : ModelBase { model.Factory = factory; model.ModelOptions = options; model.UiServices = uiServices; }
public ActionResult check(string fromStreet, string fromCity, string fromState, string fromZip, string toStreet, string toCity, string toState, string toZip, string time, FormCollection fc) { string typeText = fc["typeText"]; string origin = fromStreet + ", " + fromCity + ", " + fromState + ", " + fromZip; string destination = toStreet + ", " + toCity + ", " + toState + ", " + toZip; //Console.WriteLine("origin: " + origin); //Console.WriteLine("destination: " + destination); int type = Int32.Parse(typeText); ViewBag.from = origin; TempData["from"] = origin; ViewBag.to = destination; TempData["to"] = destination; ViewBag.time = time; TempData["time"] = time; // DriverTrip newTrip = new DriverTrip(from, to, time); // ViewBag.list = getResult(newTrip); Location from = new Location(fromStreet, fromCity, fromState, fromZip); Location to = new Location(toStreet, toCity, toState, toZip); DateTime myTime = DateTime.ParseExact(time, "yyyy-MM-dd HH:mm", System.Globalization.CultureInfo.InvariantCulture); //.AddHours(6) Trip newTrip = new Trip(from, to, myTime); IAbstractFactory factory = MatchFactory.getInstance(); IMatchAdapter adapter = factory.getMatchAdapter(myTime, type); ViewBag.list = adapter.getMatchedTrips(newTrip); if (ViewBag.list.Count == 0) { return(View("emptyResult")); } return(View()); }
public LoginVM(IAccount account, IChatHub chat, IAbstractFactory <Window> abstractFactory) : base(account, chat, abstractFactory) { UserName = Properties.UserSettings.Default.Login; Password = Properties.UserSettings.Default.Password; RememberMe = Properties.UserSettings.Default.RememberMe; _errors.Clear(); }
public static void CreateAbstFactory(IAbstractFactory aFactory) { var productA = aFactory.CreateProductA(); var productB = aFactory.CreateProductB(); Console.WriteLine(productA.AnyProductAOperation() + productB.AnyProductBOperation()); }
public AddUserVM(IChatHub chat, IFile file, IAbstractFactory <ChatVM> abstractFactory) { _chat = chat; _file = file; baseContent = abstractFactory.GetInstance(); baseContent.NewChatCreated += RemoveFindedUser; }
public MainWindow() { InitializeComponent(); factoryRed = new FactoryRed(); factoryGreen = new FactoryGreen(); }
public static void ClientMethod(IAbstractFactory factory) { var chair = factory.CreateIChair(); var table = factory.CreateITable(); table.ShowInfomationWithChair(chair); }
public Task <IHM3AOutputContext> Solve( IAbstractFactory abstractFactory, IHM3AConfiguration HM3AConfiguration, IHM3AInputContext HM3AInputContext, ISolverConfiguration solverConfiguration, HM3AEncodingEnum HM3AEncodingEnum) { return(abstractFactory.CreateSolutionsAbstractFactory().CreateHM3ASolutionFactory().Create().Solve( abstractFactory.CreateCalculationsAbstractFactory(), abstractFactory.CreateConstraintElementsAbstractFactory(), abstractFactory.CreateConstraintsAbstractFactory(), abstractFactory.CreateContextsAbstractFactory(), abstractFactory.CreateCrossJoinElementsAbstractFactory(), abstractFactory.CreateCrossJoinsAbstractFactory(), abstractFactory.CreateDependenciesAbstractFactory(), abstractFactory.CreateIndexElementsAbstractFactory(), abstractFactory.CreateIndicesAbstractFactory(), abstractFactory.CreateModelsAbstractFactory(), abstractFactory.CreateObjectiveFunctionsAbstractFactory(), abstractFactory.CreateParameterElementsAbstractFactory(), abstractFactory.CreateParametersAbstractFactory(), abstractFactory.CreateResultElementsAbstractFactory(), abstractFactory.CreateResultsAbstractFactory(), abstractFactory.CreateVariablesAbstractFactory(), HM3AConfiguration, HM3AInputContext, solverConfiguration, HM3AEncodingEnum)); }
public Task <ITPOutputContext> Solve( IAbstractFactory abstractFactory, ITPConfiguration TPConfiguration, ITPInputContext TPInputContext, ISolverConfiguration solverConfiguration) { return(abstractFactory.CreateSolutionsAbstractFactory().CreateTPSolutionFactory().Create().Solve( abstractFactory.CreateCalculationsAbstractFactory(), abstractFactory.CreateConstraintElementsAbstractFactory(), abstractFactory.CreateConstraintsAbstractFactory(), abstractFactory.CreateContextsAbstractFactory(), abstractFactory.CreateCrossJoinElementsAbstractFactory(), abstractFactory.CreateCrossJoinsAbstractFactory(), abstractFactory.CreateDependenciesAbstractFactory(), abstractFactory.CreateIndexElementsAbstractFactory(), abstractFactory.CreateIndicesAbstractFactory(), abstractFactory.CreateModelsAbstractFactory(), abstractFactory.CreateObjectiveFunctionsAbstractFactory(), abstractFactory.CreateParameterElementsAbstractFactory(), abstractFactory.CreateParametersAbstractFactory(), abstractFactory.CreateResultElementsAbstractFactory(), abstractFactory.CreateResultsAbstractFactory(), abstractFactory.CreateVariablesAbstractFactory(), TPConfiguration, TPInputContext, solverConfiguration)); }
public void Table1( string specialty, decimal value, string unit, string statistic) { // Arrange IAbstractFactory abstractFactory = AbstractFactory.Create(); IDependenciesAbstractFactory dependenciesAbstractFactory = abstractFactory.CreateDependenciesAbstractFactory(); ISurgicalDurationInputContext surgicalDurationInputContext = abstractFactory.CreateContextsAbstractFactory().CreateSurgicalDurationInputContextFactory().Create( specialty: dependenciesAbstractFactory.CreateCodeableConceptFactory().Create(specialty, SNOMEDCT, null), statistic: dependenciesAbstractFactory.CreateValueFactory().Create(statistic)); ISurgicalDurationExport surgicalDurationExport = abstractFactory.CreateExportsAbstractFactory().CreateSurgicalDurationExportFactory().Create(); // Act ISurgicalDurationOutputContext surgicalDurationOutputContext = surgicalDurationExport.GetSurgicalDuration( abstractFactory, surgicalDurationInputContext); // Assert Assert.AreEqual( expected: value, actual: surgicalDurationOutputContext.Duration.Value.Value); Assert.AreEqual( expected: unit, actual: surgicalDurationOutputContext.Duration.UnitElement.Value); }
public void InvalidSurgicalSpecialtyStdDev() { // Arrange IAbstractFactory abstractFactory = AbstractFactory.Create(); IDependenciesAbstractFactory dependenciesAbstractFactory = abstractFactory.CreateDependenciesAbstractFactory(); ISurgicalDurationInputContext surgicalDurationInputContext = abstractFactory.CreateContextsAbstractFactory().CreateSurgicalDurationInputContextFactory().Create( specialty: dependenciesAbstractFactory.CreateCodeableConceptFactory().Create(BoneAndMarrowTransplantationSurgery, SNOMEDCT, null), statistic: dependenciesAbstractFactory.CreateValueFactory().CreateStdDev()); ISurgicalDurationExport surgicalDurationExport = abstractFactory.CreateExportsAbstractFactory().CreateSurgicalDurationExportFactory().Create(); // Act Action action = () => { ISurgicalDurationOutputContext surgicalDurationOutputContext = surgicalDurationExport.GetSurgicalDuration( abstractFactory, surgicalDurationInputContext); }; // Assert Assert.ThrowsException <NullReferenceException>( action); }
public AnalyticsController( ICashier cashier, IAbstractFactory abstractFactory) { _cashier = cashier; _abstractFactory = abstractFactory; }
static void Inp(IAbstractFactory factory) { var AutoLoad = factory.TuneAutoLoad(); var Screen = factory.TuneScreen(); var Aud = factory.TuneAud(); var Icon = factory.TuneIcon(); var DataBase = factory.TuneDataBas(); var Link = factory.TuneLink(); var BackMod = factory.TuneBackMod(); var LoadScreen = factory.TuneLoadScreen(); var Safe = factory.TuneSafety(); var Inter = factory.TuneInterf(); Console.WriteLine("Настройки:"); AutoLoad.CustAutoLoad(); Screen.Resol(); Aud.CustAud(); Icon.ViewIcon(); DataBase.CustDataBas(); Link.CustLink(); BackMod.CustBackMod(); LoadScreen.CustLoadScreen(); Safe.CustSafety(); Inter.CustInterf(); }
public static void ClientMethod(IAbstractFactory factory) { var productA = factory.CreateProductA(); var productB = factory.CreateProductB(); Console.WriteLine(productB.UsefulFunctionB()); Console.WriteLine(productB.AnotherUsefulFunctionB(productA)); }
/// <summary> /// Метод выполняет производство различных продуктов в зависимости от используемой фабрики. /// </summary> /// <param name="factory"> Фабрика. </param> private void CreateProducts(IAbstractFactory factory) { var productOne = factory.CreateProductOne(); var productTwo = factory.CreateProductFour(); Console.WriteLine(productOne.DoWorkOne()); Console.WriteLine(productTwo.WorkWithProductOne(productOne)); }
public void ClientMethod(IAbstractFactory factory) { var phone = factory.CreatePhone(); var pc = factory.CreatePC(); phone.Call(); pc.Play(); }
public void ClientMethod(IAbstractFactory factory) { var productA = factory.CreateParrot(); var productB = factory.CreateDog(); Console.WriteLine(productA.ParrotFunction()); Console.WriteLine(productB.DogFunction()); }
/// <summary> /// Initializes a new instance of the <see cref="MainWindow"/> class. /// </summary> /// <param name="context">The context.</param> public MainWindow(IAbstractFactory context) { InitializeComponent(); try { IConfig config = context.Create<IConfig>(); config.ReadGlobalConfigFile(); #region Creating objects m_ThreadManager = context.Create<IThreadsManager>(); m_EventsMessages = context.Create<IEventsMessages>(); IMapView theMapView = context.Create<IMapView>(); // Set Panel with the Map View IDockingCenter inductionCenter = context.Create<IDockingCenter>(); inductionCenter.SetManager(m_DockManager); inductionCenter.AssignToArea(theMapView, "Dock Panel 1"); #endregion #region Releasing objects context.Release(inductionCenter); context.Release(theMapView); #endregion } catch (Exception ex) { MessageBox.Show("Failed to create components: " + ex.Message); } }
public Client(IAbstractFactory factory) { abstractProductA = factory.CreateProductA(); abstractProductB = factory.CreateProductB(); }