/// <summary>
/// Retrieve registrations for an unregistered service, to be used
/// by the container.
/// </summary>
/// <param name="service">The service that was requested.</param>
/// <param name="registrationAccessor">A function that will return existing registrations for a service.</param>
/// <returns>Registrations providing the service.</returns>
public IEnumerable<IComponentRegistration> RegistrationsFor(Service service, Func<Service, IEnumerable<IComponentRegistration>> registrationAccessor)
{
if (service == null) throw new ArgumentNullException("service");
if (registrationAccessor == null) throw new ArgumentNullException("registrationAccessor");
var ts = service as IServiceWithType;
if (ts != null && ts.ServiceType.IsDelegate())
{
var resultType = ts.ServiceType.FunctionReturnType();
var resultTypeService = ts.ChangeType(resultType);
return registrationAccessor(resultTypeService)
.Select(r =>
{
var factory = new FactoryGenerator(ts.ServiceType, r, ParameterMapping.Adaptive);
var rb = RegistrationBuilder.ForDelegate(ts.ServiceType, factory.GenerateFactory)
.InstancePerLifetimeScope()
.ExternallyOwned()
.As(service)
.Targeting(r);
return rb.CreateRegistration();
});
}
return Enumerable.Empty<IComponentRegistration>();
}
static void Main(string[] args)
{
/* Begin demonstration of Abstract Factory design pattern */
/* Note that Program.cs (driver class) has no knowledge of the interfaces/factories involved*/
/* It creates concrete factories and shapes/colors from the interfaces, as opposed to their concrete classes*/
// create a shape factory using factory generator
IFactory shapeFactory = FactoryGenerator.GenerateFactory("shape");
// create a color factory using the factory generator
IFactory colorFactory = FactoryGenerator.GenerateFactory("color");
// create shapes from the abstract IFactory
IShape rectangle = shapeFactory.CreateShape("rectangle");
IShape square = shapeFactory.CreateShape("square");
// create colors from the abstract IFactory
IColor green = colorFactory.CreateColor("green");
IColor red = colorFactory.CreateColor("red");
// verify that the abstract colors and shapes display the correct output
green.Colorize();
rectangle.Draw();
red.Colorize();
square.Draw();
// view console output of the program
Console.Read();
}
static void Main(string[] args)
{
var generator = new FactoryGenerator(DeviceType.HighLow);
var factory = generator.GetDeviceFactory();
var display = factory.GetDisplayDevice().ToString();
var printer = factory.GetPrinterDevice().ToString();
Console.WriteLine(display);
Console.WriteLine(printer);
}
/// <summary> Add the specified type <paramref name="factoryType" /> to the DI container as a factory that performs factory methods for creating objects. </summary>
/// <param name="services"> A collection of DI container services. </param>
/// <param name="factoryType"> Factory type. </param>
/// <returns> Reference to the passed object <paramref name="services" /> to be able to call methods in a chain. </returns>
public static IServiceCollection AddFactory(this IServiceCollection services, Type factoryType)
{
if (factoryType == null)
{
throw new ArgumentNullException(nameof(factoryType));
}
services.AddAdvancedOptions();
services.TryAddSingleton(factoryType, FactoryGenerator.Generate(factoryType));
return(services);
}
private static async Task GenerateFactoriesAsync(string solutionPath,
IEnumerable<string> attributeImportList,
bool writeXmlDoc,
string templatePath)
{
var workspace = MSBuildWorkspace.Create();
var solution = await workspace.OpenSolutionAsync(solutionPath);
var factoryGenerator = new FactoryGenerator(workspace, solution, attributeImportList, writeXmlDoc, templatePath);
await factoryGenerator.ExecuteAsync();
}
private async Task <Solution> GenerateFactoryAsync(Document document, TypeDeclarationSyntax typeDecl, CancellationToken cancellationToken)
{
await Logger.WriteLine($"GenerateFactoryAsync, {typeDecl}");
if (typeDecl is InterfaceDeclarationSyntax ids)
{
var handler = new FactoryGenerator();
var definition = await handler.GetDefinition(document, ids, cancellationToken);
return(handler.GetFactoryAppliedSolution(document, definition));
}
return(document.Project.Solution);
}
public string Get()
{
var cityGenerator = new CityGenerator();
if (!cityGenerator.Generate())
{
return("Error");
}
var factoryGenerator = new FactoryGenerator();
if (!factoryGenerator.Generate())
{
return("Error");
}
var utilityGenerator = new UtilityGenerator();
if (!utilityGenerator.Generate())
{
return("Error");
}
var regionGenerator = new RegionGenerator();
if (!regionGenerator.Generate())
{
return("Error");
}
var containerGenerator = new ContainerGenerator();
if (!containerGenerator.Generate())
{
return("Error");
}
var tripGenerator = new TripGenerator();
if (!tripGenerator.Generate())
{
return("Error");
}
return("Success");
}
public static Contracts.IFactoryGenerator GetFactoryGenerator(string solutionName, string contractsFilePath)
{
return(FactoryGenerator.Create(SolutionProperties.Create(solutionName, contractsFilePath)));
}
static void Main(string[] args)
{
SolutionProperties solutionProperties = SolutionProperties.Create();
EntityGenerator entityGenerator = EntityGenerator.Create(solutionProperties);
DataContextGenerator dataContextGenerator = DataContextGenerator.Create(solutionProperties);
ControllerGenerator controllerGenerator = ControllerGenerator.Create(solutionProperties);
FactoryGenerator factoryGenerator = FactoryGenerator.Create(solutionProperties);
TransferGenerator transferGenerator = TransferGenerator.Create(solutionProperties);
List <string> lines = new List <string>();
Console.WriteLine("Create Modules-Entities...");
lines.Clear();
lines.AddRange(entityGenerator.CreateModulesEntities());
WriteAllLines(solutionProperties.EntitiesModulesFilePath, FormatCSharp(lines));
Console.WriteLine("Create Business-Entities...");
lines.Clear();
lines.AddRange(entityGenerator.CreateBusinesssEntities());
WriteAllLines(solutionProperties.EntitiesBusinessFilePath, FormatCSharp(lines));
Console.WriteLine("Create Persistence-Entities...");
lines.Clear();
lines.AddRange(entityGenerator.CreatePersistenceEntities());
WriteAllLines(solutionProperties.EntitiesPersistenceFilePath, FormatCSharp(lines));
Console.WriteLine("Create DataContext-DbContext...");
lines.Clear();
lines.AddRange(dataContextGenerator.CreateDbContext());
WriteAllLines(solutionProperties.DataContextPersistenceFilePath, FormatCSharp(lines));
Console.WriteLine("Create Persistence-Controllers...");
lines.Clear();
lines.AddRange(controllerGenerator.CreatePersistenceControllers());
WriteAllLines(solutionProperties.ControllersPersistenceFilePath, FormatCSharp(lines));
Console.WriteLine("Create Business-Controllers...");
lines.Clear();
lines.AddRange(controllerGenerator.CreateBusinessControllers());
WriteAllLines(solutionProperties.ControllersBusinessFilePath, FormatCSharp(lines));
Console.WriteLine("Create Factory...");
lines.Clear();
lines.AddRange(factoryGenerator.CreateLogicFactory());
WriteAllLines(solutionProperties.LogicFactoryFilePath, FormatCSharp(lines));
Console.WriteLine("Create Modules-Transfer...");
lines.Clear();
lines.AddRange(transferGenerator.CreateModulesTransfers());
WriteAllLines(solutionProperties.TransferModulesFilePath, FormatCSharp(lines));
Console.WriteLine("Create Business-Transfer...");
lines.Clear();
lines.AddRange(transferGenerator.CreateBusinessTransfers());
WriteAllLines(solutionProperties.TransferBusinessFilePath, FormatCSharp(lines));
Console.WriteLine("Create Persistence-Transfer...");
lines.Clear();
lines.AddRange(transferGenerator.CreatePersistenceTransfers());
WriteAllLines(solutionProperties.TransferPersistenceFilePath, FormatCSharp(lines));
Console.WriteLine("Create Controllers-WebApi...");
lines.Clear();
lines.AddRange(controllerGenerator.CreateWebApiControllers());
WriteAllLines(solutionProperties.WebApiControllersFilePath, FormatCSharp(lines));
Console.WriteLine("Create Adapters...");
lines.Clear();
lines.AddRange(factoryGenerator.CreateAdapterFactory());
WriteAllLines(solutionProperties.AdaptersFactoryFilePath, FormatCSharp(lines));
}
