patterns & practices – Enterprise Library

How can I migrate following code to 4.1? Is it possible?

public class PolicyInjectionInstanceProvider : IInstanceProvider
    {
        private Type serviceContractType { get; set; }
        private static readonly PolicyInjectorFactory fac = new PolicyInjectorFactory();
        private static PolicyInjector injector;
        private readonly object _sync = new object();

        public PolicyInjectionInstanceProvider(Type type)
        {
            if (type != null && !type.IsInterface)
            {
                throw new ArgumentException("Specified Type must be an interface");
            }

            serviceContractType = type;
        }

        #region IInstanceProvider Members

        public object GetInstance(System.ServiceModel.InstanceContext instanceContext, System.ServiceModel.Channels.Message message)
        {
            Type type = instanceContext.Host.Description.ServiceType;

            if (serviceContractType != null)
            {
                return injector.Create(type, serviceContractType);
            }
            else
            {
                if (!type.IsMarshalByRef)
                {
                    throw new ArgumentException("Type Must inherit MarshalByRefObject if no ServiceInterface is Specified");
                }
                return injector.Create(type);
            }
        }

        public object GetInstance(System.ServiceModel.InstanceContext instanceContext)
        {
            return GetInstance(instanceContext, null);
        }

        public void ReleaseInstance(System.ServiceModel.InstanceContext instanceContext, object instance)
        {
            IDisposable disposable = instance as IDisposable;
            if (disposable != null)
            {
                disposable.Dispose();
            }
        }

        #endregion
    }

injector = fac.Create();

No, Create method is generic

Thanks. You really helped me!

I cannot find class Injection... I used reflector and wrote following code
container.Configure<Interception>()
                        .SetDefaultInterceptorFor(serviceContractType, injector);

I am wondering, if I am building up my own unity container and want to layer PIAB into it during resolution, that is supported in 4.1

What is the best approach for doing this instead of using an interceptor?  Can the PIAB resolve a type from unity and apply its' policies for you?

I have been digging all around for a day and cannot find anything on this outside of leveraging interception on the Unity container and wiring it up manually like you do here...

> Crap, you're right. I can't believe I left the non-generic overloads off the PolicyInjection class.

Does that mean that we can expect this overload to find its way to the next release? That would be very helpful - we've had this exact issue as well

at ruifavas request,  

 public class PolicyInjectionInstanceProvider : IInstanceProvider
 {
     private Type serviceContractType { get; set; }        
     private readonly object _sync = new object();
     private static readonly IUnityContainer container;
     private static readonly TransparentProxyInterceptor injector = new TransparentProxyInterceptor();

     static PolicyInjectionInstanceProvider()
     {
         container = new UnityContainer()
             .AddNewExtension<Interception>();

         IConfigurationSource configSource = ConfigurationSourceFactory.Create();
         PolicyInjectionSettings settings = (PolicyInjectionSettings)configSource.GetSection(PolicyInjectionSettings.SectionName);
         if (settings != null)
         {
             settings.ConfigureContainer(container, configSource);
         }
     }

     public PolicyInjectionInstanceProvider(Type type)
     {
         if (type != null && !type.IsInterface)
         {
             throw new ArgumentException("Specified Type must be an interface");
         }

         serviceContractType = type;
     }

     public object GetInstance(System.ServiceModel.InstanceContext instanceContext, System.ServiceModel.Channels.Message message)
     {
         Type type = instanceContext.Host.Description.ServiceType;
         if (serviceContractType != null)
         {
             lock (_sync)
             {
                 container.Configure<Interception>()
                     .SetDefaultInterceptorFor(serviceContractType, injector);
                 container.RegisterType(serviceContractType, type);
                 return container.Resolve(serviceContractType);
             }
         }
         else
         {
             if (!type.IsMarshalByRef)
             {
                 throw new ArgumentException("Type Must inherit MarshalByRefObject if no ServiceInterface is Specified");
             }
             lock (_sync)
             {
                 container.Configure<Interception>()
                     .SetDefaultInterceptorFor(type, injector);
                 return container.Resolve(type);
             }
         }
     }

     public object GetInstance(System.ServiceModel.InstanceContext instanceContext)
     {
         return GetInstance(instanceContext, null);
     }

     public void ReleaseInstance(System.ServiceModel.InstanceContext instanceContext, object instance)
     {
         IDisposable disposable = instance as IDisposable;
         if (disposable != null)
         {
             disposable.Dispose();
         }
     }
 }