microsoft-dependency-injection/src/Configuration.cs at 3b1b5652c0d39120d4a3759b06b21fcdef739068 · unitycontainer/microsoft-dependency-injection · 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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Collections.Generic;
using System.Reflection;
using Unity.Lifetime;
using Unity.Microsoft.DependencyInjection.Lifetime;

namespace Unity.Microsoft.DependencyInjection
{
    internal static class Configuration
    {
        internal static IUnityContainer AddServices(this IUnityContainer container, IServiceCollection services)
        {
            var lifetime = ((UnityContainer)container).Configure<MdiExtension>().Lifetime;
            var registerFunc = ((UnityContainer)container).Register;

            ((UnityContainer)container).Register = ((UnityContainer)container).AppendNew;

            foreach (var descriptor in services) container.Register(descriptor, lifetime);

            ((UnityContainer)container).Register = registerFunc;

            return container;
        }


        internal static void Register(this IUnityContainer container,
            ServiceDescriptor serviceDescriptor, ILifetimeContainer lifetime)
        {
            if (serviceDescriptor.IsKeyedService)
            {
                if (serviceDescriptor.KeyedImplementationType != null)
                {
                    var name = serviceDescriptor.ServiceType.IsGenericTypeDefinition ? UnityContainer.All : null;
                    container.RegisterType(serviceDescriptor.ServiceType,
                                           serviceDescriptor.KeyedImplementationType,
                                           name,
                                           (ITypeLifetimeManager)serviceDescriptor.GetLifetime(lifetime));
                }
                else if (serviceDescriptor.KeyedImplementationFactory != null)
                {
                    container.RegisterFactory(serviceDescriptor.ServiceType,
                                            (string)serviceDescriptor.ServiceKey,
                                            scope =>
                                            {
                                                var serviceProvider = scope.Resolve<IServiceProvider>();
                                                var instance = serviceDescriptor.KeyedImplementationFactory(serviceProvider, serviceDescriptor.ServiceKey);
                                                return instance;
                                            },
                                           (IFactoryLifetimeManager)serviceDescriptor.GetLifetime(lifetime));
                }
                else if (serviceDescriptor.KeyedImplementationInstance != null)
                {
                    container.RegisterInstance(serviceDescriptor.ServiceType,
                                               (string)serviceDescriptor.ServiceKey,
                                               serviceDescriptor.KeyedImplementationInstance,
                                               (IInstanceLifetimeManager)serviceDescriptor.GetLifetime(lifetime));
                }
                else
                {
                    throw new InvalidOperationException("Unsupported registration type");
                }
            }
            else
            {
                if (serviceDescriptor.ImplementationType != null)
                {
                    var name = serviceDescriptor.ServiceType.IsGenericTypeDefinition ? UnityContainer.All : null;
                    container.RegisterType(serviceDescriptor.ServiceType,
                                           serviceDescriptor.ImplementationType,
                                           name,
                                           (ITypeLifetimeManager)serviceDescriptor.GetLifetime(lifetime));
                }
                else if (serviceDescriptor.ImplementationFactory != null)
                {
                    container.RegisterFactory(serviceDescriptor.ServiceType,
                                            null,
                                            scope =>
                                            {
                                                var serviceProvider = scope.Resolve<IServiceProvider>();
                                                var instance = serviceDescriptor.ImplementationFactory(serviceProvider);
                                                return instance;
                                            },
                                           (IFactoryLifetimeManager)serviceDescriptor.GetLifetime(lifetime));
                }
                else if (serviceDescriptor.ImplementationInstance != null)
                {
                    container.RegisterInstance(serviceDescriptor.ServiceType,
                                               null,
                                               serviceDescriptor.ImplementationInstance,
                                               (IInstanceLifetimeManager)serviceDescriptor.GetLifetime(lifetime));
                }
                else
                {
                    throw new InvalidOperationException("Unsupported registration type");
                }
            }
        }

        internal static LifetimeManager GetLifetime(this ServiceDescriptor serviceDescriptor, ILifetimeContainer lifetime)
        {
            switch (serviceDescriptor.Lifetime)
            {
                case ServiceLifetime.Scoped:
                    return new HierarchicalLifetimeManager();
                case ServiceLifetime.Singleton:
                    return new InjectionSingletonLifetimeManager(lifetime);
                case ServiceLifetime.Transient:
                    return new InjectionTransientLifetimeManager();
                default:
                    throw new NotImplementedException(
                        $"Unsupported lifetime manager type '{serviceDescriptor.Lifetime}'");
            }
        }


        internal static bool CanResolve(this IUnityContainer container, Type type)
        {
            var info = type.GetTypeInfo();

            if (info.IsClass && !info.IsAbstract)
            {
                if (typeof(Delegate).GetTypeInfo().IsAssignableFrom(info) || typeof(string) == type || info.IsEnum
                    || type.IsArray || info.IsPrimitive)
                {
                    return container.IsRegistered(type);
                }
                return true;
            }

            if (info.IsGenericType)
            {
                var gerericType = type.GetGenericTypeDefinition();
                if ((gerericType == typeof(IEnumerable<>)) ||
                    container.IsRegistered(gerericType))
                {
                    return true;
                }
            }

            return container.IsRegistered(type);
        }
    }
}