Asp.Net Filtering Inyection

filterContainerRegistration.cs

container.RegisterGlobalActionFilter<MvcTestFilterAttribute>();

filterRegistration.cs

GlobalFilters.Filters.Add(new ActionFilterWrapperAttribute(typeof(MvcTestFilterAttribute)));

[ActionFilterWrapper(typeof(MvcTestFilterAttribute))]
//
// GET: /Mvc2/
public ActionResult Index()
{
    return View();
}

mvc_filterContainerExtension.cs

public static class UnityContainerMvcExtensions
{
    public static void RegisterGlobalActionFilter<T>(this IUnityContainer container)
        where T : IActionFilter
    {
        container.RegisterType<T>(new PerRequestLifetimeManager());

        GlobalFilters.Filters.Add(new ActionFilterWrapperAttribute(typeof(T)));
    }
}

mvc_RemoveDefaultFilterProvider.cs

public static class UnityWebActivator
    {
        /// <summary>Integrates Unity when the application starts.</summary>
        public static void Start() 
        {
            var container = UnityConfig.GetConfiguredContainer();

            FilterProviders.Providers.Remove(FilterProviders.Providers.OfType<FilterAttributeFilterProvider>().First());
            FilterProviders.Providers.Add(new UnityFilterAttributeFilterProvider(container));
            
            DependencyResolver.SetResolver(new UnityDependencyResolver(container));

            Microsoft.Web.Infrastructure.DynamicModuleHelper.DynamicModuleUtility.RegisterModule(typeof(UnityPerRequestHttpModule));
        }
    }

simpleGlobalFilter.cs

GlobalFilters.Add(new SimpleMvcFilterAttribute());

standardFilterWithCollaborators.cs

GlobalFilters.Add(new FilterWithCollaborators(new LoggingCollaborator(), new UnitofWork()));

webApi_filterContainerExtension.cs

 public static class UnityContainerWebApiExtensions
    {
        public static void RegisterGlobalActionFilter<T>(this IUnityContainer container)
            where T : IActionFilter
        {
            container.RegisterType<T>(new PerRequestLifetimeManager());

            GlobalConfiguration.Configuration.Filters.Add(new ActionFilterWrapperAttribute(typeof(T)));
        }
    }

webApi_removeDefaultFilterConfig.cs

 public static class UnityWebApiActivator
    {
        /// <summary>Integrates Unity when the application starts.</summary>
        public static void Start() 
        {
            var resolver = new UnityHierarchicalDependencyResolver(UnityConfig.GetConfiguredContainer());

            var defaultProviders = GlobalConfiguration.Configuration.Services.GetFilterProviders();
            GlobalConfiguration.Configuration.Services.Remove(typeof(IFilterProvider), defaultProviders.First(f => f is ActionDescriptorFilterProvider));
            GlobalConfiguration.Configuration.Services.Add(typeof(IFilterProvider), new WebApiUnityFilterProvider(UnityConfig.GetConfiguredContainer()));

            GlobalConfiguration.Configuration.DependencyResolver = resolver;
        }
    }

WebApiFilterProvider.cs

public class WebApiUnityFilterProvider : ActionDescriptorFilterProvider, IFilterProvider
    {
        private readonly IUnityContainer container;

        public WebApiUnityFilterProvider(IUnityContainer container)
        {
            this.container = container;
        }

        public new IEnumerable<FilterInfo> GetFilters(HttpConfiguration configuration, HttpActionDescriptor actionDescriptor)
        {
            var filters = base.GetFilters(configuration, actionDescriptor);
            List<FilterInfo> filterInfoList = new List<FilterInfo>();

            foreach (var filter in filters)
            {
                container.BuildUp(filter.Instance.GetType(), filter.Instance);
            }

            return filters;
        }
    }

WrapperFilter.cs

  internal class ActionFilterWrapperAttribute : FilterAttribute, IActionFilter
    {
        private readonly Type filter;

        public ActionFilterWrapperAttribute(Type filter)
        {
            this.filter = filter;
        }

        public void OnActionExecuted(ActionExecutedContext filterContext)
        {
            IActionFilter filterInstance = (IActionFilter)DependencyResolver.Current.GetService(filter);

            filterInstance.OnActionExecuted(filterContext);
        }

        public void OnActionExecuting(ActionExecutingContext filterContext)
        {
            IActionFilter filterInstance = (IActionFilter)DependencyResolver.Current.GetService(filter);

            filterInstance.OnActionExecuting(filterContext);
        }
    }