scriptcs/src/ScriptCs.Hosting/InitializationServices.cs at dev · rezn/scriptcs · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
using System;
using System.Collections.Generic;
using Autofac;
using ScriptCs.Contracts;
using ScriptCs.Hosting.Package;

namespace ScriptCs.Hosting
{
    public class InitializationServices : ScriptServicesRegistration, IInitializationServices
    {
        private readonly ILog _log;

        public InitializationServices(ILogProvider logProvider, IDictionary<Type, object> overrides = null)
            : base(logProvider, overrides)
        {
            Guard.AgainstNullArgument("logProvider", logProvider);

            _log = logProvider.ForCurrentType();

        }

        protected override IContainer CreateContainer()
        {
            var builder = new ContainerBuilder();
            _log.Debug("Registering initialization services");
            builder.RegisterInstance(this.LogProvider);
            builder.RegisterType<ScriptServicesBuilder>().As<IScriptServicesBuilder>();

            RegisterLineProcessors(builder);

            RegisterOverrideOrDefault<IFileSystem>(builder, b => b.RegisterType<FileSystem>().As<IFileSystem>().SingleInstance());

            RegisterOverrideOrDefault<IAssemblyUtility>(builder, b => b.RegisterType<AssemblyUtility>().As<IAssemblyUtility>().SingleInstance());

            RegisterOverrideOrDefault<IPackageContainer>(builder, b => b.RegisterType<PackageContainer>().As<IPackageContainer>().SingleInstance());

            RegisterOverrideOrDefault<IPackageAssemblyResolver>(builder, b => b.RegisterType<PackageAssemblyResolver>().As<IPackageAssemblyResolver>().SingleInstance());

            RegisterOverrideOrDefault<IAssemblyResolver>(builder, b => b.RegisterType<AssemblyResolver>().As<IAssemblyResolver>().SingleInstance());

            RegisterOverrideOrDefault<IInstallationProvider>(builder, b => b.RegisterType<NugetInstallationProvider>().As<IInstallationProvider>().SingleInstance());

            RegisterOverrideOrDefault<IPackageInstaller>(builder, b => b.RegisterType<PackageInstaller>().As<IPackageInstaller>().SingleInstance());

            RegisterOverrideOrDefault<IModuleLoader>(builder, b => b.RegisterType<ModuleLoader>().As<IModuleLoader>().SingleInstance());

            RegisterOverrideOrDefault<IAppDomainAssemblyResolver>(builder, b => b.RegisterType<AppDomainAssemblyResolver>().As<IAppDomainAssemblyResolver>().SingleInstance());

            RegisterOverrideOrDefault<IFilePreProcessor>(builder, b => b.RegisterType<FilePreProcessor>().As<IFilePreProcessor>().SingleInstance());

            return builder.Build();
        }

        private IAssemblyResolver _assemblyResolver;

        public IAssemblyResolver GetAssemblyResolver()
        {
            return GetService(ref _assemblyResolver);
        }

        private IModuleLoader _moduleLoader;

        public IModuleLoader GetModuleLoader()
        {
            return GetService(ref _moduleLoader);
        }

        private IFileSystem _fileSystem;

        public IFileSystem GetFileSystem()
        {
            return GetService(ref _fileSystem);
        }

        private IInstallationProvider _installationProvider;

        public IInstallationProvider GetInstallationProvider()
        {
            return GetService(ref _installationProvider);
        }

        private IPackageAssemblyResolver _packageAssemblyResolver;

        public IPackageAssemblyResolver GetPackageAssemblyResolver()
        {
            return GetService(ref _packageAssemblyResolver);
        }

        private IPackageInstaller _packageInstaller;

        public IPackageInstaller GetPackageInstaller()
        {
            return GetService(ref _packageInstaller);
        }

        private IAppDomainAssemblyResolver _appDomainAssemblyResolver;

        public IAppDomainAssemblyResolver GetAppDomainAssemblyResolver()
        {
            return GetService(ref _appDomainAssemblyResolver);
        }

        private IAssemblyUtility _assemblyUtility;

        public IAssemblyUtility GetAssemblyUtility()
        {
            return GetService(ref _assemblyUtility);
        }

        private T GetService<T>(ref T service )
        {
            if (Equals(service,null))
            {
                _log.Debug(string.Format("Resolving {0}", typeof(T).Name));
                service = Container.Resolve<T>();
            }

            return service;
        }
    }
}