C# 4.0 统一的财产注入

我遇到了unity的问题，我想使用属性注入，下面是我在代码中的内容： 容器的配置：

public static void RegisterTypes(IUnityContainer container)
    {
        container.RegisterType<GTModelContainer, GTModelContainer>(new HttpContextLifetimeManager<GTModelContainer>())
                 .RegisterType<IUnitOfWork, UnitOfWorkGT>()
                 .RegisterType<ILogger, Logger>(new ContainerControlledLifetimeManager())                     
                 .RegisterType<ISocieteServices, SocieteServices>() ;
 }

我尝试使用属性注入（我不能将构造函数注入与自定义数据注释一起使用），下面是我所做的：

   public class CodeSocieteUniqueAttribute : ValidationAttribute
{
     [Dependency]
    public ISocieteServices SocieteService {get; set;} 

     [InjectionMethod]
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {

        string codeSociete = value as string;

        var societe = SocieteService.getSocieteByCode(codeSociete);
        if (societe == null) return ValidationResult.Success;
        else return new ValidationResult(FormatErrorMessage(validationContext.DisplayName));

    }
}

---

问题是没有注入CodeSocieteUniqueAttribute类中的societeService

假设注册类型的类是可公开访问的，并且有一个IUnityContainer对象，即：

public static class Resolver
{

    public static IUnityContainer Container { get; set; }
    public static void RegisterTypes(IUnityContainer container)
    {
        // type registrations here
        container.RegisterType<GTModelContainer, GTModelContainer>(new HttpContextLifetimeManager<GTModelContainer>())
             .RegisterType<IUnitOfWork, UnitOfWorkGT>()
             .RegisterType<ILogger, Logger>(new ContainerControlledLifetimeManager())                     
             .RegisterType<ISocieteServices, SocieteServices>() ;

        // Now, set the container
        Container = container;
    }
}

公共静态类解析器
{
公共静态IUnityContainer容器{get；set；}
公共静态无效注册表类型（IUnityContainer容器）
{
//在这里输入注册
container.RegisterType（新的HttpContextLifetimeManager（））
.RegisterType（）
.RegisterType（新的ContainerControlled LifetimeManager（））
.RegisterType（）；
//现在，设置容器
容器=容器；
}
}

您可以访问已构建的容器，并在方法执行期间解析这些类型

比如说,

public class CodeSocieteUniqueAttribute : ValidationAttribute
{
     [Dependency]
    public ISocieteServices SocieteService { get; set; } 

     [InjectionMethod]
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        var societeServices = Resolver.Container.Resolve<ISocieteServices>();
        SocieteService = societeServices; // Or, you know, just use this since it's resolved.
        string codeSociete = value as string;

        var societe = SocieteService.getSocieteByCode(codeSociete);
        if (societe == null) return ValidationResult.Success;
        else return new ValidationResult(FormatErrorMessage(validationContext.DisplayName));

    }
}

公共类CodeSocieteUniqueAttribute:ValidationAttribute
{
[依赖性]
公共ISocieteServices社交服务{get；set；}
[注射法]
受保护的重写ValidationResult有效（对象值，ValidationContext ValidationContext）
{
var societeServices=Resolver.Container.Resolve（）；
SocieteService=societeServices；//或者，你知道，既然已经解决了，就使用这个。
string codeSociete=作为字符串的值；
var societe=SocieteService.getSocieteByCode（codeSociete）；
if（societe==null）返回ValidationResult.Success；
否则返回新的ValidationResult（FormatErrorMessage（validationContext.DisplayName））；
}
}

这实际上是相当标准的实践，描述了在运行时解析项

另一个选项是将分辨率弹出到默认构造函数中，如下所示：

public class CodeSocieteUniqueAttribute : ValidationAttribute
{
    [Dependency]
    public ISocieteServices SocieteService {get; set;} 
    public CodeSocieteUniqueAttribute()
    {
        var societeServices = Resolver.Container.Resolve<ISocieteServices>();
        SocieteService = societeServices; 
    }
     // the rest of the class omitted for brevity
}

公共类CodeSocieteUniqueAttribute:ValidationAttribute
{
[依赖性]
公共ISocieteServices社交服务{get；set；}
公共代码SocieteUniqueAttribute（）
{
var societeServices=Resolver.Container.Resolve（）；
社会服务=社会服务；
}
//为了简洁起见，班上的其余部分省略了
}

假设注册类型的类是可公开访问的，并且有一个IUnityContainer对象，即：

public static class Resolver
{

    public static IUnityContainer Container { get; set; }
    public static void RegisterTypes(IUnityContainer container)
    {
        // type registrations here
        container.RegisterType<GTModelContainer, GTModelContainer>(new HttpContextLifetimeManager<GTModelContainer>())
             .RegisterType<IUnitOfWork, UnitOfWorkGT>()
             .RegisterType<ILogger, Logger>(new ContainerControlledLifetimeManager())                     
             .RegisterType<ISocieteServices, SocieteServices>() ;

        // Now, set the container
        Container = container;
    }
}

公共静态类解析器
{
公共静态IUnityContainer容器{get；set；}
公共静态无效注册表类型（IUnityContainer容器）
{
//在这里输入注册
container.RegisterType（新的HttpContextLifetimeManager（））
.RegisterType（）
.RegisterType（新的ContainerControlled LifetimeManager（））
.RegisterType（）；
//现在，设置容器
容器=容器；
}
}

您可以访问已构建的容器，并在方法执行期间解析这些类型

比如说,

public class CodeSocieteUniqueAttribute : ValidationAttribute
{
     [Dependency]
    public ISocieteServices SocieteService { get; set; } 

     [InjectionMethod]
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        var societeServices = Resolver.Container.Resolve<ISocieteServices>();
        SocieteService = societeServices; // Or, you know, just use this since it's resolved.
        string codeSociete = value as string;

        var societe = SocieteService.getSocieteByCode(codeSociete);
        if (societe == null) return ValidationResult.Success;
        else return new ValidationResult(FormatErrorMessage(validationContext.DisplayName));

    }
}

公共类CodeSocieteUniqueAttribute:ValidationAttribute
{
[依赖性]
公共ISocieteServices社交服务{get；set；}
[注射法]
受保护的重写ValidationResult有效（对象值，ValidationContext ValidationContext）
{
var societeServices=Resolver.Container.Resolve（）；
SocieteService=societeServices；//或者，你知道，既然已经解决了，就使用这个。
string codeSociete=作为字符串的值；
var societe=SocieteService.getSocieteByCode（codeSociete）；
if（societe==null）返回ValidationResult.Success；
否则返回新的ValidationResult（FormatErrorMessage（validationContext.DisplayName））；
}
}

这实际上是相当标准的实践，描述了在运行时解析项

另一个选项是将分辨率弹出到默认构造函数中，如下所示：

public class CodeSocieteUniqueAttribute : ValidationAttribute
{
    [Dependency]
    public ISocieteServices SocieteService {get; set;} 
    public CodeSocieteUniqueAttribute()
    {
        var societeServices = Resolver.Container.Resolve<ISocieteServices>();
        SocieteService = societeServices; 
    }
     // the rest of the class omitted for brevity
}

公共类CodeSocieteUniqueAttribute:ValidationAttribute
{
[依赖性]
公共ISocieteServices社交服务{get；set；}
公共代码SocieteUniqueAttribute（）
{
var societeServices=Resolver.Container.Resolve（）；
社会服务=社会服务；
}
//为了简洁起见，班上的其余部分省略了
}

假设注册类型的类是可公开访问的，并且有一个IUnityContainer对象，即：

public static class Resolver
{

    public static IUnityContainer Container { get; set; }
    public static void RegisterTypes(IUnityContainer container)
    {
        // type registrations here
        container.RegisterType<GTModelContainer, GTModelContainer>(new HttpContextLifetimeManager<GTModelContainer>())
             .RegisterType<IUnitOfWork, UnitOfWorkGT>()
             .RegisterType<ILogger, Logger>(new ContainerControlledLifetimeManager())                     
             .RegisterType<ISocieteServices, SocieteServices>() ;

        // Now, set the container
        Container = container;
    }
}

公共静态类解析器
{
公共静态IUnityContainer容器{get；set；}
公共静态无效注册表类型（IUnityContainer容器）
{
//在这里输入注册
container.RegisterType（新的HttpContextLifetimeManager（））
.RegisterType（）
.RegisterType（新的ContainerControlled LifetimeManager（））
.RegisterType（）；
//现在，设置容器
容器=容器；
}
}

您可以访问已构建的容器，并在方法执行期间解析这些类型

比如说,

public class CodeSocieteUniqueAttribute : ValidationAttribute
{
     [Dependency]
    public ISocieteServices SocieteService { get; set; } 

     [InjectionMethod]
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        var societeServices = Resolver.Container.Resolve<ISocieteServices>();
        SocieteService = societeServices; // Or, you know, just use this since it's resolved.
        string codeSociete = value as string;

        var societe = SocieteService.getSocieteByCode(codeSociete);
        if (societe == null) return ValidationResult.Success;
        else return new ValidationResult(FormatErrorMessage(validationContext.DisplayName));

    }
}

公共类CodeSocieteUniqueAttribute:ValidationAttribute
{
[依赖性]
公共ISocieteServices社交服务{get；set；}
[注射法]
受保护的重写ValidationResult有效（对象值，ValidationContext ValidationContext）
{
var societeServices=Resolver.Container.Resolve（）；
SocieteService=societeServices；//或者，你知道，既然已经解决了，就使用这个。
string codeSociete=作为字符串的值；
var societe=SocieteService.getSocieteByCode（codeSociete）；
if（societe==null）返回ValidationResult.Success；
否则返回新的ValidationResult（FormatErrorMessage（validationContext.DisplayName））；
}
}

这实际上是相当标准的实践，描述了在运行时解析项

另一个选项是将分辨率弹出到默认构造函数中，如下所示：

public class CodeSocieteUniqueAttribute : ValidationAttribute
{
    [Dependency]
    public ISocieteServices SocieteService {get; set;} 
    public CodeSocieteUniqueAttribute()
    {
        var societeServices = Resolver.Container.Resolve<ISocieteServices>();
        SocieteService = societeServices; 
    }
     // the rest of the class omitted for brevity
}

<