public CodeGenerator(INameMangler nameMangler, ILogger <CodeGenerator> logger, ICodeGeneratorFactory codeGeneratorFactory, IConfiguration configuration)
{
_nameMangler = nameMangler;
_logger = logger;
_codeGeneratorFactory = codeGeneratorFactory;
_configuration = configuration;
}
private void InvokeGenerator(GeneratorContext context, ICodeGeneratorFactory factory, ClassDeclarationSyntax node)
{
var generatedCount = 0;
CompilationUnit unit = default;
foreach (var generator in factory.GetGenerators())
{
context.CancellationToken.ThrowIfCancellationRequested();
if (_generatorCache.AddNew(node, generator.GetGeneratedMemberName()))
{
if (generatedCount == 0)
{
unit = new CompilationUnit(node);
}
else
{
unit.Output.AppendLine();
}
generator.GenerateMemberDeclaration(unit.Output);
generatedCount++;
}
}
context.CancellationToken.ThrowIfCancellationRequested();
if (generatedCount > 0)
{
var source = unit.GetSourceText();
context.AddOutput(node, factory.GetHintName(), source);
}
}
public InterceptableProxyFactoryCache(
ICodeGeneratorFactory codeGeneratorFactory,
IInterceptorResolver interceptorResolver)
{
_codeGeneratorFactory = codeGeneratorFactory;
_interceptorResolver = interceptorResolver;
_instanceFactories = new Dictionary <Tuple <Type, Type>, Func <object, object> >();
_typeFactories = new Dictionary <Type, Func <IServiceProvider, object> >();
}
public ServiceDescriptorConverter(
Type serviceType,
Type implementationType,
ServiceLifetime lifetime,
IInterceptorResolver interceptorResolver,
IInterceptableProxyFactoryCache factoryCache,
ICodeGeneratorFactory codeGeneratorFactory)
: this(new ServiceDescriptor(serviceType, implementationType, lifetime), interceptorResolver, factoryCache, codeGeneratorFactory)
{
}
/// <summary>
/// Create a new <see cref="GenericInterceptableServiceDescriptor"/>.
/// </summary>
/// <param name="codeGeneratorFactory">The <see cref="ICodeGeneratorFactory"/> used to get <see cref="ICodeGenerator"/>.</param>
/// <param name="interceptorResolver">The <see cref="IInterceptorResolver"/> used to resolve registered interceptors.</param>
/// <param name="serviceType">The service type.</param>
/// <param name="implementationType">The <see cref="Type"/> service implements.</param>
/// <param name="lifetime">The <see cref="ServiceLifetime"/> of the service registration.</param>
public GenericInterceptableServiceDescriptor(
ICodeGeneratorFactory codeGeneratorFactory,
IInterceptorResolver interceptorResolver,
Type serviceType, Type implementationType, ServiceLifetime lifetime)
: base(serviceType, GetInterceptableProxyType(codeGeneratorFactory, interceptorResolver, serviceType, implementationType), lifetime)
{
if (!serviceType.IsGenericTypeDefinition)
{
throw new ArgumentException("Non-open-generic type (generic type definition) is not support", nameof(serviceType));
}
_targetType = implementationType;
}
public void GenerateCode(CodeObject codeObject, ICodeGeneratorFactory factory)
{
var ns = (NamespaceDeclaration)codeObject;
var writer = factory.Writer;
writer.Indention().Write(CSharpKeyword.Namespace).Space().Write(ns.Name)
.BlockStart().IncreaseIndention();
ns.Types.ForEach(t => factory.GetCodeGenerator(t).GenerateCode(t, factory));
writer.DecreaseIndention().BlockEnd();
}
private void InvokeGenerator(
GeneratorContext context,
ICodeGeneratorFactory factory,
ClassDeclarationSyntax node,
Logger logger)
{
if (!factory.Validate(logger))
{
return;
}
var contract = new ContractDescription(factory.ServiceType);
ShowWarnings(logger, contract, factory.ServiceType);
var unit = new CompilationUnit(node);
var generatedCount = 0;
var imports = new HashSet <string>(StringComparer.Ordinal);
foreach (var generator in factory.GetGenerators(contract, node).Concat(GetSharedGenerators(contract)))
{
context.CancellationToken.ThrowIfCancellationRequested();
if (_generatorCache.AddNew(node, generator.GetGeneratedMemberName()))
{
if (generatedCount > 0)
{
unit.Output.AppendLine();
}
generator.GenerateMemberDeclaration(unit.Output);
foreach (var i in generator.GetUsing())
{
imports.Add(i);
}
generatedCount++;
}
}
context.CancellationToken.ThrowIfCancellationRequested();
if (generatedCount > 0)
{
var source = unit.GetSourceText(GetSharedUsing().Concat(imports));
context.AddOutput(node, factory.GetHintName(contract), source);
}
}
private static Type GetInterceptableProxyType(
ICodeGeneratorFactory codeGeneratorFactory,
IInterceptorResolver interceptorResolver,
Type serviceType,
Type implementationType)
{
var interceptors = serviceType.IsInterface
? interceptorResolver.GetInterceptors(serviceType, implementationType)
: interceptorResolver.GetInterceptors(implementationType);
var codeGenerator = codeGeneratorFactory.Create();
var context = new CodeGenerationContext(serviceType, implementationType, interceptors);
var proxyType = codeGenerator.GenerateInterceptableProxyClass(context);
return(proxyType);
}
private static bool TryResolveFactory(AttributeData attribute, out ICodeGeneratorFactory factory)
{
if (CSharpClientCodeGeneratorFactory.Math(attribute))
{
factory = new CSharpClientCodeGeneratorFactory(attribute);
return(true);
}
if (CSharpServiceCodeGeneratorFactory.Math(attribute))
{
factory = new CSharpServiceCodeGeneratorFactory(attribute);
return(true);
}
factory = null !;
return(false);
}
public void GenerateCode(CodeObject codeObject, ICodeGeneratorFactory factory)
{
var writer = factory.Writer;
var classDeclaration = codeObject as ClassDeclaration;
writer.Indention()
.Scope(classDeclaration.Scope)
.Space()
.Write(CSharpKeyword.Class)
.Space()
.Write(classDeclaration.Name);
writer.LineEnd().BlockStart().IncreaseIndention();
bool isFirst = true;
foreach (var property in classDeclaration.Properties)
{
if (!isFirst)
{
writer.LineEnd();
}
writer.Indention()
.Scope(property.Scope)
.Space();
_typeReferenceWriter.Write(writer, property.Type, property.Nullable);
writer.Space().Write(property.Name);
writer.Space().BlockStart(true);
writer.Space().Write(CSharpKeyword.Get).StatementIdentifier();
if (!property.ReadOnly)
{
writer.Space().Write(CSharpKeyword.Set).StatementIdentifier();
}
writer.Space().BlockEnd(true);
isFirst = false;
}
writer.DecreaseIndention();
writer.BlockEnd();
}
public void GenerateCode(CodeObject codeObject, ICodeGeneratorFactory factory)
{
var writer = factory.Writer;
var enumerationDeclaration = codeObject as EnumerationDeclaration;
writer.Indention()
.Scope(enumerationDeclaration.Scope)
.Space()
.Write(CSharpKeyword.Enum)
.Space()
.Write(enumerationDeclaration.Name)
.LineEnd()
.BlockStart()
.IncreaseIndention();
var isFirst = true;
foreach (var member in enumerationDeclaration.Values)
{
if (!isFirst)
{
writer.Write(",");
writer.LineEnd();
}
writer.Indention().Write(member.Name);
if (member.Value.HasValue)
{
writer.Write(CSharpOperator.Assignment)
.Space()
.Write(member.Value.Value.ToString());
}
isFirst = false;
}
writer.DecreaseIndention()
.BlockEnd();
}
private static IServiceCollection AddInterceptableCore(this IServiceCollection services, Type serviceType, Type implementationType, ServiceLifetime lifetime, AddKind kind)
{
Guard.ArgumentNotNull(services, nameof(services));
Guard.ArgumentNotNull(serviceType, nameof(serviceType));
Guard.ArgumentNotNull(implementationType, nameof(implementationType));
if (serviceType.IsGenericTypeDefinition)
{
if (!services.Any(it => it.ServiceType == typeof(ICodeGeneratorFactory)))
{
throw new InvalidOperationException("IServiceCollection's AddInterception method must be called before register open generic service type.");
}
if (_codeGeneratorFactory == null)
{
var provider = services.BuildServiceProvider();
_codeGeneratorFactory = provider.GetRequiredService <ICodeGeneratorFactory>();
_interceptorResolver = provider.GetRequiredService <IInterceptorResolver>();
}
if (serviceType != implementationType)
{
services.AddTransient(implementationType, implementationType);
}
}
switch (kind)
{
case AddKind.AlwaysAdd:
{
if (serviceType.IsGenericTypeDefinition)
{
services.Add(new GenericInterceptableServiceDescriptor(_codeGeneratorFactory, _interceptorResolver, serviceType, implementationType, lifetime));
}
else
{
services.Add(new InterceptableServiceDescriptor(serviceType, implementationType, lifetime));
}
break;
}
case AddKind.TryAdd:
{
if (serviceType.IsGenericTypeDefinition)
{
services.TryAdd(new GenericInterceptableServiceDescriptor(_codeGeneratorFactory, _interceptorResolver, serviceType, implementationType, lifetime));
}
else
{
services.TryAdd(new InterceptableServiceDescriptor(serviceType, implementationType, lifetime));
}
break;
}
case AddKind.TryAddEnumerable:
{
if (!services.OfType <IInterceptableServiceDescriptor>().Any(it => it.TargetType == implementationType))
{
if (serviceType.IsGenericTypeDefinition)
{
services.TryAddEnumerable(new GenericInterceptableServiceDescriptor(_codeGeneratorFactory, _interceptorResolver, serviceType, implementationType, lifetime));
}
else
{
services.TryAddEnumerable(new InterceptableServiceDescriptor(serviceType, implementationType, lifetime));
}
}
break;
}
}
return(services);
}
public void GenerateCode(CodeObject codeObject, ICodeGeneratorFactory factory)
{
var compileUnit = (CompileUnit)codeObject;
compileUnit.Namespaces?.ForEach(ns => factory.GetCodeGenerator(ns).GenerateCode(ns, factory));
}
public bool Equals(ICodeGeneratorFactory <EnumSourceGeneratorState>?obj)
{
return(obj is NewtonsoftJsonSmartEnumCodeGeneratorFactory);
}
public bool Equals(ICodeGeneratorFactory <EnumSourceGeneratorState>?obj)
{
return(obj is MessagePackSmartEnumCodeGeneratorFactory);
}
public bool Equals(ICodeGeneratorFactory <ValueObjectSourceGeneratorState>?obj)
{
return(obj is ValueObjectCodeGeneratorFactory);
}
public ServiceDescriptorConverter(
ServiceDescriptor serviceDescriptor,
IInterceptorResolver interceptorResolver,
IInterceptableProxyFactoryCache factoryCache,
ICodeGeneratorFactory codeGeneratorFactory)
{
Guard.ArgumentNotNull(serviceDescriptor, nameof(serviceDescriptor));
Guard.ArgumentNotNull(interceptorResolver, nameof(interceptorResolver));
Guard.ArgumentNotNull(factoryCache, nameof(factoryCache));
if (serviceDescriptor.ImplementationInstance != null || serviceDescriptor.ImplementationFactory != null || serviceDescriptor.IsInterceptable())
{
_primaryDescriptor = serviceDescriptor;
return;
}
var serviceType = serviceDescriptor.ServiceType;
var implementationType = serviceDescriptor.ImplementationType;
var lifetime = serviceDescriptor.Lifetime;
if (serviceType.IsInterface)
{
var interceptors = interceptorResolver.GetInterceptors(serviceType, implementationType);
if (interceptors.IsEmpty)
{
_primaryDescriptor = new ServiceDescriptor(serviceType, implementationType, lifetime);
}
else if (serviceType.IsGenericTypeDefinition)
{
_secondaryDescriptor = new ServiceDescriptor(implementationType, implementationType, lifetime);
var codeGenerator = codeGeneratorFactory.Create();
var context = new CodeGenerationContext(serviceType, implementationType, interceptors);
var proxyType = codeGenerator.GenerateInterceptableProxyClass(context);
_primaryDescriptor = new ServiceDescriptor(serviceType, proxyType, lifetime);
}
else
{
_primaryDescriptor = new ServiceDescriptor(serviceType, CreateOrGet, lifetime);
object CreateOrGet(IServiceProvider serviceProvider)
{
var target = ActivatorUtilities.CreateInstance(serviceProvider, implementationType);
return(factoryCache.GetInstanceFactory(serviceType, implementationType).Invoke(target));
}
}
}
else
{
var interceptors = interceptorResolver.GetInterceptors(implementationType);
if (interceptors.IsEmpty)
{
_primaryDescriptor = new ServiceDescriptor(serviceType, implementationType, lifetime);
}
else
{
var codeGenerator = codeGeneratorFactory.Create();
var context = new CodeGenerationContext(implementationType, interceptors);
var proxyType = codeGenerator.GenerateInterceptableProxyClass(context);
_primaryDescriptor = new ServiceDescriptor(serviceType, proxyType, lifetime);
}
}
}
