使用结构图，您可以注册一个约定，让您不仅可以调整类型，还可以在对象创建过程中进行干预。我如何使用 Unity 执行此操作。

public class SettingsRegistration : IRegistrationConvention
{
    public void Process(Type type, Registry registry)
    {
        if (!type.IsAbstract && typeof(ISettings).IsAssignableFrom(type))
        {
            registry.For(type).Use(x =>
            {
                var svc = x.GetInstance<ISettingService>();
                return svc.LoadSetting(type);
            });
        }
    }
}

最佳答案

您可以结合使用 Unity 的 Registration by Convention 来做到这一点和一个 InjectionFactory .我看到了三个常见的实现选项，但我确信还有更多...

选项1

使用 lambda 表达式内联的 if 条件一次性注册所有类型。尽管如果您使用许多自定义注册来注册许多类型，这并不能很好地扩展...

container.RegisterTypes(
    AllClasses.FromLoadedAssemblies(),
    WithMappings.FromAllInterfaces,
    WithName.Default,
    WithLifetime.Transient,
    type =>
    {
        // If settings type, load the setting
        if (!type.IsAbstract && typeof (ISettings).IsAssignableFrom(type))
        {
            return new[]
            {
                new InjectionFactory((c, t, n) =>
                {
                    var svc = (ISettings) c.Resolve(t);
                    return svc.LoadSetting(t);
                })
            };
        }

        // Otherwise, no special consideration is needed
        return new InjectionMember[0];
    });

选项 2

仅注册 ISettings 类型并提供一些不错的辅助方法。您将需要多次调用 container.RegisterTypes，但它更具可读性......

container.RegisterTypes(
    AllClasses.FromLoadedAssemblies().IsSetting(),
    WithMappings.FromAllInterfaces,
    WithName.Default,
    WithLifetime.Transient,
    SettingsRegistration.InjectionMembers);

...

public static class SettingsRegistration
{
    public static IEnumerable<Type> IsSetting(this IEnumerable<Type> types)
    {
        return types.Where(type => !type.IsAbstract && 
                                   typeof (ISettings).IsAssignableFrom(type));
    }

    public static IEnumerable<InjectionMember> InjectionMembers(Type type)
    {
        return new[] {new InjectionFactory(LoadSetting)};
    }

    public static ISettings LoadSetting(IUnityContainer container, 
                                        Type type, 
                                        string name)
    {
        var svc = (ISettings) container.Resolve(type, name);
        return svc.LoadSetting(type);
    }
}

选项3

或者您可以创建一个派生自 RegistrationConvention 的类，并让该类做出所有注册决定...

container.RegisterTypes(new SettingsRegistrationConvention(
    AllClasses.FromLoadedAssemblies()));

...

public class SettingsRegistrationConvention : RegistrationConvention
{
    private readonly IEnumerable<Type> _scanTypes;

    public SettingsRegistrationConvention(IEnumerable<Type> scanTypes)
    {
        if (scanTypes == null)
            throw new ArgumentNullException("scanTypes");

        _scanTypes = scanTypes;
    }

    public override IEnumerable<Type> GetTypes()
    {
        return _scanTypes.Where(type => !type.IsAbstract && 
                                        typeof (ISettings).IsAssignableFrom(type));
    }

    public override Func<Type, IEnumerable<Type>> GetFromTypes()
    {
        return WithMappings.FromAllInterfaces;
    }

    public override Func<Type, string> GetName()
    {
        return WithName.Default;
    }

    public override Func<Type, LifetimeManager> GetLifetimeManager()
    {
        return WithLifetime.Transient;
    }

    public override Func<Type, IEnumerable<InjectionMember>> GetInjectionMembers()
    {
        return type => new[]
        {
            new InjectionFactory((c, t, n) =>
            {
                var svc = (ISettings) c.Resolve(t);
                return svc.LoadSetting(t);
            })
        };
    }
}

关于c# - 如何设置 Unity 注册约定？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27371346/