3

我有一个现有的应用程序，我正在修改它以使用 Autofac 属性注入。似乎无论我使用哪种方法向属性注册我的类型，属性始终为 null，除非它们具有公共设置器。InternalsVisibleTo使用其他 IoC 容器（例如 Structuremap），可以将 setter 设置为内部范围，并使用程序集上的属性使其可用。这似乎很好地限制了客户修改分配。

Autofac可以做到这一点吗？或者在使用属性注入以确保分配安全时是否有另一种方法？

我已经尝试使用反射PropertiesAutoWired()以及.WithParameter()从我的 WebApi Global.asax 解析 - 指定要设置的特定参数作为内部设置器没有成功。

[assembly: InternalsVisibleTo("MyWebAPI.dll")]
[assembly: InternalsVisibleTo("Autofac.dll")]
[assembly: InternalsVisibleTo("Autofac.Configuration.dll")]
namespace My.Namespace
{
    public class BaseContext
    {
        public MyPublicClass _dbHelper { get; internal set; }

        public BaseContext()
        {

        }

        protected string DbConnectionString
        {
            get
            {
                return _dbHelper.DbConn; //<-Always null unless setter is public
            }
        }
    }
}
4

4 回答 4

5

您不能internal使用 autofac 注入 setter，因为AutowiringPropertyInjector该类仅在寻找公共属性（请参阅源代码）。

然而，其中的逻辑AutowiringPropertyInjector非常简单，因此您可以创建自己的版本，为非公共属性注入：

public static class AutowiringNonPublicPropertyInjector
{
     public static void InjectProperties(IComponentContext context, 
            object instance, bool overrideSetValues)
     {
          if (context == null)
              throw new ArgumentNullException("context");
          if (instance == null)
              throw new ArgumentNullException("instance");
          foreach (
             PropertyInfo propertyInfo in 
                 //BindingFlags.NonPublic flag added for non public properties
                 instance.GetType().GetProperties(BindingFlags.Instance |
                                                  BindingFlags.Public |
                                                  BindingFlags.NonPublic))
         {
             Type propertyType = propertyInfo.PropertyType;
             if ((!propertyType.IsValueType || propertyType.IsEnum) &&
                 (propertyInfo.GetIndexParameters().Length == 0 &&
                     context.IsRegistered(propertyType)))
             {
                 //Changed to GetAccessors(true) to return non public accessors
                 MethodInfo[] accessors = propertyInfo.GetAccessors(true);
                 if ((accessors.Length != 1 || 
                     !(accessors[0].ReturnType != typeof (void))) &&
                      (overrideSetValues || accessors.Length != 2 ||
                      propertyInfo.GetValue(instance, null) == null))
                 {
                     object obj = context.Resolve(propertyType);
                     propertyInfo.SetValue(instance, obj, null);
                 }
            }
        }
    }
}

现在你可以在OnActivated事件中使用这个类

var builder = new ContainerBuilder();
builder.RegisterType<MyPublicClass>();
builder.RegisterType<BaseContext>()
    .OnActivated(args =>   
          AutowiringNonPublicPropertyInjector
              .InjectProperties(args.Context, args.Instance, true));

然而，上面列出的解决方案现在注入了所有类型的属性，甚至是私有和受保护的，因此您可能需要通过一些额外的检查来扩展它，以确保您只会注入您期望的属性。

于 2013-08-12T19:23:38.360 回答
0

我正在使用这样的解决方案：

builder.RegisterType<MyPublicClass>();
builder.RegisterType<BaseContext>()
       .OnActivating(CustomPropertiesHandler);

使用这样的处理程序：

//If OnActivated: Autofac.Core.IActivatedEventArgs
public void CustomPropertiesHandler<T>(Autofac.Core.IActivatingEventArgs<T> e)
{
    var props = e.Instance.GetType()
        .GetTypeInfo().DeclaredProperties //Also "private prop" with "public set"
        .Where(pi => pi.CanWrite) //Has a set accessor.
        //.Where(pi => pi.SetMethod.IsPrivate) //set accessor is private
        .Where(pi => e.Context.IsRegistered(pi.PropertyType)); //Type is resolvable

    foreach (var prop in props)
        prop.SetValue(e.Instance, e.Context.Resolve(prop.PropertyType), null);
}

由于 IActivatingEventArgs 和 IActivatedEventArgs 都有实例和上下文，因此您可能希望使用在 CustomPropertiesHandler 上使用这些参数的包装方法。

于 2015-07-24T10:14:58.320 回答
0

我们也可以将@nemesv 实现编写为扩展方法。

public static class AutofacExtensions
{
    public static void InjectProperties(IComponentContext context, object instance, bool overrideSetValues)
    {
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }
        if (instance == null)
        {
            throw new ArgumentNullException(nameof(instance));
        }

        foreach (var propertyInfo in instance.GetType().GetProperties(BindingFlags.Instance |
                                                                      BindingFlags.Public |
                                                                      BindingFlags.NonPublic))
        {
            var propertyType = propertyInfo.PropertyType;

            if ((!propertyType.IsValueType || propertyType.IsEnum) && (propertyInfo.GetIndexParameters().Length == 0) && context.IsRegistered(propertyType))
            {
                var accessors = propertyInfo.GetAccessors(true);
                if (((accessors.Length != 1) ||
                     !(accessors[0].ReturnType != typeof(void))) &&
                    (overrideSetValues || (accessors.Length != 2) ||
                     (propertyInfo.GetValue(instance, null) == null)))
                {
                    var obj = context.Resolve(propertyType);
                    propertyInfo.SetValue(instance, obj, null);
                }
            }
        }
    }

    public static IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> InjectPropertiesAsAutowired<TLimit, TActivatorData, TRegistrationStyle>(
        this IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> registration)
    {
        return registration.OnActivated(args => InjectProperties(args.Context, args.Instance, true));
    }

使用；

protected override void Load(ContainerBuilder builder)
{
    builder.RegisterType<StartupConfiguration>().As<IStartupConfiguration>().AsSelf().InjectPropertiesAsAutowired().AsImplementedInterfaces().SingleInstance();
}
于 2016-10-11T16:34:14.483 回答
0

当前版本的 Autofac定义了用于过滤可注入属性的可选IPropertySelector参数。PropertiesAutowired

默认实现IPropertySelector是DefaultPropertySelector，它过滤非公共属性。

public virtual bool InjectProperty(PropertyInfo propertyInfo, object instance)
{
   if (!propertyInfo.CanWrite || propertyInfo.SetMethod?.IsPublic != true)
   {
       return false;
   }
   ....
 }

定义IPropertySelector允许注入非公共属性的自定义

public class AccessRightInvariantPropertySelector : DefaultPropertySelector
{
    public AccessRightInvariantPropertySelector(bool preserveSetValues) : base(preserveSetValues)
    { }

    public override bool InjectProperty(PropertyInfo propertyInfo, object instance)
    {
        if (!propertyInfo.CanWrite)
        {
            return false;
        }

        if (!PreserveSetValues || !propertyInfo.CanRead)
        {
            return true;
        }
        try
        {
            return propertyInfo.GetValue(instance, null) == null;
        }
        catch
        {
            // Issue #799: If getting the property value throws an exception
            // then assume it's set and skip it.
            return false;
        }
    }
}

采用

builder.RegisterType<AppService>()
      .AsImplementedInterfaces()
      .PropertiesAutowired(new AccessRightInvariantPropertySelector(true));

或者

安装

PM> Install-Package Autofac.Core.NonPublicProperty

采用

builder.RegisterType<AppService>()
      .AsImplementedInterfaces()
      .AutoWireNonPublicProperties();
于 2017-09-22T15:28:15.683 回答