private static string BuildInstantiation(DependencyDefinition from)
{
var builder = new StringBuilder();
switch (from.Provider.Strategy)
{
case ProviderType.Implementation:
{
builder.AppendIndent(3);
builder.Append(from.Type.FullName);
builder.Append(" result = new ");
builder.Append(from.Provider.Type.FullName);
builder.AppendMethodDependencies(from.Provider.Dependencies, 3);
}
break;
case ProviderType.Factory:
{
builder.AppendGetDependency(from.Provider.Type, assignTo: "factory", indent: 3, end: true);
builder.AppendIndent(3);
builder.Append(from.Type.FullName);
builder.Append(" result = factory.");
builder.Append(from.Provider.Method.Name);
builder.AppendMethodDependencies(from.Provider.Dependencies, 3);
}
break;
}
builder.AppendLine();
return(builder.ToString());
}
private static string GetTemplateClassDependency(string classNamespace, DependencyDefinition dependency)
{
var rawText = dependency.Lifestyle == Lifestyles.Single ? _classDependencySingleTemplate : _classDependencyTemplate;
return(rawText
.Replace("{{Namespace}}", classNamespace)
.Replace("{{DependencyType}}", dependency.Type.FullName)
.Replace("{{SafeDependencyType}}", SafeName(dependency.Type))
.Replace("{{InstantiateProvider}}", BuildInstantiation(dependency))
.Replace("{{Initializer}}", BuildInitializer(dependency))
.Replace("{{Decorators}}", BuildDecorators(dependency)));
}
private static string BuildDecorators(DependencyDefinition from)
{
if (from?.Decorators?.Any() != true)
{
return(" // no decorators");
}
var builder = new StringBuilder();
foreach (var decorator in from.Decorators)
{
builder.AppendIndent(3);
builder.Append("result = new ");
builder.Append(decorator.Type.FullName);
builder.AppendMethodDependencies(decorator.Dependencies, 3);
builder.AppendLine();
}
return(builder.ToString());
}
private static string BuildInitializer(DependencyDefinition from)
{
// TODO: implement
return(string.Empty);
}
private static Dictionary <Type, DependencyDefinition> ResolveDependencies(Assembly inAssembly)
{
var dependencyAttributes = inAssembly.GetCustomAttributes <DependencyAttribute>();
var decoratorAttributes = inAssembly.GetCustomAttributes <DecoratorAttribute>();
var decoratorAttributeLookup = decoratorAttributes.ToLookup(item => item.Dependency);
var dependencies = new Dictionary <Type, DependencyDefinition>();
// validate
// ? implementation
// ? type interface the provider must be concrete and implement interface
// provider cannot be interface
// factory must be appropriately returning
// ? type is concrete the provider must be null or factory or subclass
// provider must be constructable
foreach (var dependencyAttribute in dependencyAttributes)
{
var dependency = new DependencyDefinition()
{
Declaration = dependencyAttribute,
Type = dependencyAttribute.Type,
Initializer = dependencyAttribute.Initializer,
Lifestyle = dependencyAttribute.Lifestyle
};
dependencies.Add(dependencyAttribute.Type, dependency);
}
foreach (var value in dependencies.Values.ToList())
{
value.Provider = GetProvider(value.Declaration, dependencies);
}
foreach (var value in dependencies.Values)
{
{
if (value.Provider.Strategy == ProviderType.Implementation)
{
var constructor = value.Provider.Type.GetConstructors().Single();
var providerDependencies = new List <DependencyDefinition>();
foreach (var parameter in constructor.GetParameters())
{
providerDependencies.Add(dependencies[parameter.ParameterType]);
}
value.Provider.Dependencies = providerDependencies;
}
else if (value.Provider.Strategy == ProviderType.Factory)
{
foreach (var parameter in value.Provider.Method.GetParameters())
{
if (dependencies.TryGetValue(parameter.ParameterType, out var dependency))
{
value.Provider.Dependencies.Add(dependency);
}
else
{
throw new Exception();
}
}
}
}
if (decoratorAttributeLookup.Contains(value.Type))
{
value.Decorators = decoratorAttributeLookup[value.Type]
.Select(item => new Decorator()
{
Type = item.Type
}).ToList();
foreach (var decorator in value.Decorators)
{
var constructor = decorator.Type.GetConstructors().Single();
var decoratorDependencies = new List <DependencyDefinition>();
bool targetFound = false;
foreach (var parameter in constructor.GetParameters())
{
if (parameter.ParameterType == value.Type)
{
if (!targetFound)
{
targetFound = true;
decoratorDependencies.Add(TargetDependency.Instance);
}
else
{
throw new Exception();
}
}
else
{
decoratorDependencies.Add(dependencies[parameter.ParameterType]);
}
}
decorator.Dependencies = decoratorDependencies;
}
}
}
return(dependencies);
}
