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();
}
