/// <summary>
        /// Initializes a new instance of the <see cref="ContainerFixture"/> class.
        /// </summary>
        public ContainerFixture()
        {
            var builder = DependencyBuilderFactory.Create(DependencyLibrary.Microsoft);

            builder.Register <IAttributeDefinitionProvider <Attribute, Type>, AttributeDefinitionProvider>();
            builder.Register <IAttributeParameterDefinitionProvider <Tuple <PropertyInfo, object>, Type>, AttributeParameterDefinitionProvider>();
            builder.Register <IClassDefinitionProvider <Type, Type>, ClassDefinitionProvider>();
            builder.Register <IEnumDefinitionProvider <Type, Type>, EnumDefinitionProvider>();
            builder.Register <IEnumValueDefinitionProvider <object, Type>, EnumValueDefinitionProvider>();
            builder.Register <IMethodDefinitionProvider <MethodInfo, Type>, MethodDefinitionProvider>();
            builder.Register <IParameterDefinitionProvider <ParameterInfo, Type>, ParameterDefinitionProvider>();
            builder.Register <IPropertyDefinitionProvider <PropertyInfo, Type>, PropertyDefinitionProvider>();
            builder.Register <IStructDefinitionProvider <Type, Type>, StructDefinitionProvider>();
            builder.Register <IObjectDefinitions <Type>, ObjectDefinitions>();
            builder.RegisterInstance <ILoggingService>(new LoggingService());
            builder.RegisterScoped <IInputService, InputService>();

            this.Container = builder.Build();

            this.AttributeProvider          = this.Container.Resolve <IAttributeDefinitionProvider <Attribute, Type> >();
            this.AttributeParameterProvider = this.Container.Resolve <IAttributeParameterDefinitionProvider <Tuple <PropertyInfo, object>, Type> >();
            this.ClassProvider     = this.Container.Resolve <IClassDefinitionProvider <Type, Type> >();
            this.EnumProvider      = this.Container.Resolve <IEnumDefinitionProvider <Type, Type> >();
            this.EnumValueProvider = this.Container.Resolve <IEnumValueDefinitionProvider <object, Type> >();
            this.MethodProvider    = this.Container.Resolve <IMethodDefinitionProvider <MethodInfo, Type> >();
            this.ParameterProvider = this.Container.Resolve <IParameterDefinitionProvider <ParameterInfo, Type> >();
            this.PropertyProvider  = this.Container.Resolve <IPropertyDefinitionProvider <PropertyInfo, Type> >();
            this.StructProvider    = this.Container.Resolve <IStructDefinitionProvider <Type, Type> >();

            this.ContainerBuilt();
        }
        public static IDependencyContainer Register(PublishConfiguration configuration)
        {
            var builder = DependencyBuilderFactory.Create(DependencyLibrary.Microsoft);

            builder.RegisterInstance(ConnectorBuilder.Build(configuration));
            builder.RegisterInstance <ILoggingService>(new ConsoleLoggingService());
            builder.Register <IScriptBuilder, ScriptBuilder>();
            builder.Register <IScriptRunner, ScriptRunner>();

            return(builder.Build());
        }
Example #3
0
        private static void ProcessConfigurationFile(string configurationFileName, List <OutputFileOverride> outputFileOverrides)
        {
            LoggingService.Notice($"Starting to read configuration file [{Path.GetFileName(configurationFileName)}]");

            // read the configuration file.
            var configuration = GetConfigurationFile(configurationFileName);

            if (configuration == null)
            {
                return;
            }

            // overrides the outfile type matching adding "NameIn" type matcher,
            // and adds all the typed names to the output file configuration for this run.
            OverrideConfigurationFiles(outputFileOverrides, configuration);

            LoggingService.WriteLine($"Input  Type:     {configuration.Input.InputType}");
            LoggingService.WriteLine($"Output Type:     {configuration.Output.OutputType}");

            // inject dependencies and start input and ouput plugins.
            var builder = DependencyBuilderFactory.Create(DependencyLibrary.Microsoft);

            builder.RegisterInstance <ILoggingService, ConsoleLoggingService>((ConsoleLoggingService)LoggingService);
            builder.RegisterInstance(AssemblyLoader);

            InputPluginLoader.Load(builder, configuration.Input, AssemblyLoadContext.Default);
            OutputPluginLoader.Load(builder, configuration.Output, AssemblyLoadContext.Default);

            var container = builder.Build();

            // instantiate input and output plugin.
            var inputService  = container.Resolve <IInputService>();
            var outputService = container.Resolve <IOutputService>();

            // run input and output logic.
            inputService.Process(configurationFileName, configuration.Input);
            outputService.GenerateAsync(configurationFileName, configuration.Output);
        }