public async Task <Res> Next(Cb callback,
object rawCallback, MemberBinding member,
IHandler composer, Next <Res> next,
IFilterProvider provider)
{
var transaction = member.Dispatcher.Attributes
.OfType <TransactionAttribute>().SingleOrDefault();
var unitOfWork = new UnitOfWork(
composer.Resolve <UnitOfWork>(),
provider as UnitOfWorkAttribute,
transaction,
composer);
try
{
var result = await next(unitOfWork + composer);
await unitOfWork.CommitAsync();
return(result);
}
finally
{
unitOfWork.Dispose();
}
}
public ContentStreamProcessor(PdfRectangle cropBox, IResourceStore resourceStore, UserSpaceUnit userSpaceUnit, PageRotationDegrees rotation,
IPdfTokenScanner pdfScanner,
IPageContentParser pageContentParser,
IFilterProvider filterProvider,
ILog log,
bool clipPaths)
{
this.resourceStore = resourceStore;
this.userSpaceUnit = userSpaceUnit;
this.rotation = rotation;
this.pdfScanner = pdfScanner ?? throw new ArgumentNullException(nameof(pdfScanner));
this.pageContentParser = pageContentParser ?? throw new ArgumentNullException(nameof(pageContentParser));
this.filterProvider = filterProvider ?? throw new ArgumentNullException(nameof(filterProvider));
this.log = log;
this.clipPaths = clipPaths;
// initiate CurrentClippingPath to cropBox
var clippingSubpath = new PdfSubpath();
clippingSubpath.Rectangle(cropBox.BottomLeft.X, cropBox.BottomLeft.Y, cropBox.Width, cropBox.Height);
var clippingPath = new PdfPath()
{
clippingSubpath
};
clippingPath.SetClipping(FillingRule.NonZeroWinding);
graphicsStack.Push(new CurrentGraphicsState()
{
CurrentClippingPath = clippingPath
});
ColorSpaceContext = new ColorSpaceContext(GetCurrentState, resourceStore);
}
public Type0FontHandler(CidFontFactory cidFontFactory, CMapCache cMapCache, IFilterProvider filterProvider, IPdfObjectParser pdfObjectParser)
{
this.cidFontFactory = cidFontFactory;
this.cMapCache = cMapCache;
this.filterProvider = filterProvider;
this.pdfObjectParser = pdfObjectParser;
}
protected void RegisterFilterAttributeProvider( IFilterProvider filterProvider )
{
var oldProvider = FilterProviders.Providers.SingleOrDefault( f => f is FilterAttributeFilterProvider );
if( oldProvider != null ) FilterProviders.Providers.Remove( oldProvider );
FilterProviders.Providers.Add( filterProvider );
}
public PdfTokenScanner(IInputBytes inputBytes, IObjectLocationProvider objectLocationProvider, IFilterProvider filterProvider)
{
this.inputBytes = inputBytes;
this.objectLocationProvider = objectLocationProvider;
this.filterProvider = filterProvider;
coreTokenScanner = new CoreTokenScanner(inputBytes);
}
public CidFontFactory(IPdfTokenScanner pdfScanner, FontDescriptorFactory descriptorFactory,
IFilterProvider filterProvider)
{
this.pdfScanner = pdfScanner;
this.descriptorFactory = descriptorFactory;
this.filterProvider = filterProvider;
}
public Type0FontHandler(CidFontFactory cidFontFactory, IFilterProvider filterProvider,
IPdfTokenScanner scanner)
{
this.cidFontFactory = cidFontFactory;
this.filterProvider = filterProvider;
this.scanner = scanner;
}
public void Add(IFilterProvider provider)
{
Precondition.Require(provider, () =>
Error.ArgumentNull("provider"));
_providers.Add(provider);
}
protected override void OnComplete(
IConventionContext context,
FilterConventionDefinition definition)
{
if (definition.Provider is null)
{
throw FilterConvention_NoProviderFound(GetType(), definition.Scope);
}
if (definition.ProviderInstance is null)
{
_provider =
context.Services.GetOrCreateService <IFilterProvider>(definition.Provider) ??
throw FilterConvention_NoProviderFound(GetType(), definition.Scope);
}
else
{
_provider = definition.ProviderInstance;
}
_namingConventions = context.DescriptorContext.Naming;
_operations = definition.Operations.ToDictionary(
x => x.Id,
FilterOperation.FromDefinition);
_bindings = definition.Bindings;
_configs = definition.Configurations;
_argumentName = definition.ArgumentName;
if (_provider is IFilterProviderConvention init)
{
init.Initialize(context);
}
_typeInspector = context.DescriptorContext.TypeInspector;
}
protected void RegisterFilterProvider( IFilterProvider filterProvider )
{
var oldProviders = FilterProviders.Providers.Where( f => f is IFilterProvider ).ToList();
if( oldProviders != null ) foreach( var fp in oldProviders ) FilterProviders.Providers.Remove( fp );
FilterProviders.Providers.Add( filterProvider );
}
public void Configure(ControllerConfigurationSettings module)
{
if (Factory != null)
{
Type type = String.IsNullOrEmpty(Factory.FactoryType) ?
typeof(DefaultControllerFactory) :
Type.GetType(Factory.FactoryType, true, true);
IControllerFactory factory = CreateControllerFactory(type);
factory.Init(Factory.Parameters);
module.Factory = factory;
}
if (Mappings != null)
{
foreach (ControllerMappingConfigurationElement map in Mappings)
{
module.Mappings.Add(map.Name, Type.GetType(map.ControllerType, true, true));
}
}
if (FilterProviders != null)
{
foreach (FilterProviderConfigurationElement elem in FilterProviders)
{
IFilterProvider provider = CreateFilterProvider(
Type.GetType(elem.ProviderType, true, true));
provider.Init(elem.Parameters);
module.FilterProviders.Add(provider);
}
}
}
public TestController(
DatabaseContext db,
IFilterProvider <Post> filterProvider)
{
Db = db;
FilterProvider = filterProvider;
}
/// <summary>Integrates Unity when the application starts.</summary>
public static void Start()
{
IUnityContainer container = Utils.Configuration.CurrentContainer;
container.RegisterType <IActionFilter, ValidateLocationAttribute>();
List <IFilterProvider> filterProviders = GlobalConfiguration.Configuration.Services.GetFilterProviders().ToList();
GlobalConfiguration.Configuration.Services.Add(typeof(IFilterProvider), new UnityWebApiFilterAttributeFilterProvider(container));
IFilterProvider defaultProvider = filterProviders.FirstOrDefault(provider => provider is ActionDescriptorFilterProvider);
if (defaultProvider != null)
{
GlobalConfiguration.Configuration.Services.Remove(typeof(IFilterProvider), defaultProvider);
}
// Use UnityHierarchicalDependencyResolver if you want to use a new child container for each IHttpController resolution.
// var resolver = new UnityHierarchicalDependencyResolver(UnityConfig.GetConfiguredContainer());
var resolver = new UnityDependencyResolver(container);
var currentJsonFormatter = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
currentJsonFormatter.SerializerSettings.NullValueHandling = JsonSerialization.PawsJsonSerializerSetting.NullValueHandling;
currentJsonFormatter.SerializerSettings.DefaultValueHandling = JsonSerialization.PawsJsonSerializerSetting.DefaultValueHandling;
currentJsonFormatter.SerializerSettings.ContractResolver = JsonSerialization.PawsJsonSerializerSetting.ContractResolver;
GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
public void FilterProviderCollectionCombinedItemsDelegatesToResolver()
{
// Arrange
var firstProvider = new Mock <IFilterProvider>();
var secondProvider = new Mock <IFilterProvider>();
var thirdProvider = new Mock <IFilterProvider>();
var dependencyProviders = new IFilterProvider[]
{
firstProvider.Object,
secondProvider.Object
};
var collectionProviders = new IFilterProvider[] { thirdProvider.Object };
var expectedProviders = new IFilterProvider[]
{
firstProvider.Object,
secondProvider.Object,
thirdProvider.Object
};
Mock <IDependencyResolver> resolver = new Mock <IDependencyResolver>();
resolver
.Setup(r => r.GetServices(typeof(IFilterProvider)))
.Returns(dependencyProviders);
var providers = new FilterProviderCollection(collectionProviders, resolver.Object);
// Act
IFilterProvider[] combined = providers.CombinedItems;
// Assert
Assert.Equal(expectedProviders, combined);
}
public Type3FontHandler(IPdfTokenScanner scanner, IFilterProvider filterProvider,
IEncodingReader encodingReader)
{
this.filterProvider = filterProvider;
this.encodingReader = encodingReader;
this.scanner = scanner;
}
internal PdfDocument(ILog log,
IInputBytes inputBytes,
HeaderVersion version,
CrossReferenceTable crossReferenceTable,
bool isLenientParsing,
ParsingCachingProviders cachingProviders,
IPageFactory pageFactory,
Catalog catalog,
DocumentInformation information,
EncryptionDictionary encryptionDictionary,
IPdfTokenScanner pdfScanner,
IFilterProvider filterProvider,
AcroFormFactory acroFormFactory)
{
this.log = log;
this.inputBytes = inputBytes;
this.version = version ?? throw new ArgumentNullException(nameof(version));
this.isLenientParsing = isLenientParsing;
this.cachingProviders = cachingProviders ?? throw new ArgumentNullException(nameof(cachingProviders));
this.encryptionDictionary = encryptionDictionary;
this.pdfScanner = pdfScanner ?? throw new ArgumentNullException(nameof(pdfScanner));
this.filterProvider = filterProvider ?? throw new ArgumentNullException(nameof(filterProvider));
Information = information ?? throw new ArgumentNullException(nameof(information));
pages = new Pages(log, catalog, pageFactory, isLenientParsing, pdfScanner);
Structure = new Structure(catalog, crossReferenceTable, pdfScanner);
documentForm = new Lazy <AcroForm>(() => acroFormFactory.GetAcroForm(catalog));
}
internal AdvancedPdfDocumentAccess(IPdfTokenScanner pdfScanner,
IFilterProvider filterProvider,
Catalog catalog)
{
this.pdfScanner = pdfScanner ?? throw new ArgumentNullException(nameof(pdfScanner));
this.filterProvider = filterProvider ?? throw new ArgumentNullException(nameof(filterProvider));
this.catalog = catalog ?? throw new ArgumentNullException(nameof(catalog));
}
public PageFactory(IResourceStore resourceStore, IPdfObjectParser pdfObjectParser, IFilterProvider filterProvider,
IPageContentParser pageContentParser)
{
this.resourceStore = resourceStore;
this.pdfObjectParser = pdfObjectParser;
this.filterProvider = filterProvider;
this.pageContentParser = pageContentParser;
}
public FilterRegister(FilterGraph filterGraph,
IFilterPropertyProvider filterPropertyProvider,
IFilterProvider filterProvider)
{
this.filterGraph = filterGraph;
this.filterPropertyProvider = filterPropertyProvider;
this.filterProvider = filterProvider;
}
public static SchemaException FilterProvider_NoHandlersConfigured(
IFilterProvider filterProvider) =>
new SchemaException(
SchemaErrorBuilder.New()
.SetMessage(
DataResources.FilterProvider_NoHandlersConfigured,
filterProvider.GetType().FullName ?? filterProvider.GetType().Name)
.SetExtension(nameof(filterProvider), filterProvider)
.Build());
public CidFontFactory(FontDescriptorFactory descriptorFactory, TrueTypeFontParser trueTypeFontParser,
IPdfObjectParser pdfObjectParser,
IFilterProvider filterProvider)
{
this.descriptorFactory = descriptorFactory;
this.trueTypeFontParser = trueTypeFontParser;
this.pdfObjectParser = pdfObjectParser;
this.filterProvider = filterProvider;
}
public Type1FontHandler(IPdfTokenScanner pdfScanner, IFilterProvider filterProvider,
FontDescriptorFactory fontDescriptorFactory,
IEncodingReader encodingReader)
{
this.pdfScanner = pdfScanner;
this.filterProvider = filterProvider;
this.fontDescriptorFactory = fontDescriptorFactory;
this.encodingReader = encodingReader;
}
public static SchemaException FilterProvider_NoHandlersConfigured(
IFilterProvider filterProvider) =>
new SchemaException(
SchemaErrorBuilder.New()
.SetMessage(
"The filter provider `{0}` does not specify and field handler.",
filterProvider.GetType().FullName ?? filterProvider.GetType().Name)
.SetExtension(nameof(filterProvider), filterProvider)
.Build());
public static void RegisterUnityFilterExtension(IUnityContainer container)
{
IFilterProvider filterProvider = FilterProviders.Providers.Single(p => p is FilterAttributeFilterProvider);
FilterProviders.Providers.Remove(filterProvider);
var unityFilterAttributeFilterProvider = new UnityFilterAttributeFilterProvider(container);
FilterProviders.Providers.Add(unityFilterAttributeFilterProvider);
}
public ListWorkOrderQueryHandler(ILogAs logAs,
IMapper mapper,
IWorkOrderReadRepository workOrderReadRepository,
IFilterProvider filterProvider)
{
_logAs = logAs ?? throw Error.ArgumentNull(nameof(logAs));
_mapper = mapper ?? throw Error.ArgumentNull(nameof(mapper));
_workOrderReadRepository = workOrderReadRepository ?? throw Error.ArgumentNull(nameof(workOrderReadRepository));
_filterProvider = filterProvider ?? throw Error.ArgumentNull(nameof(filterProvider));
}
public MyBusinessClass(
IFilterProvider filterProvider
)
{
if (filterProvider == null)
{
throw new ArgumentNullException("filterProvider");
}
this.filterProvider = filterProvider;
}
public PageFactory(IPdfTokenScanner pdfScanner, IResourceStore resourceStore, IFilterProvider filterProvider,
IPageContentParser pageContentParser,
XObjectFactory xObjectFactory)
{
this.resourceStore = resourceStore;
this.filterProvider = filterProvider;
this.pageContentParser = pageContentParser;
this.xObjectFactory = xObjectFactory;
this.pdfScanner = pdfScanner;
}
public PageFactory(IPdfTokenScanner pdfScanner, IResourceStore resourceStore, IFilterProvider filterProvider,
IPageContentParser pageContentParser,
ILog log)
{
this.resourceStore = resourceStore;
this.filterProvider = filterProvider;
this.pageContentParser = pageContentParser;
this.log = log;
this.pdfScanner = pdfScanner;
}
public void GetAllFilters_FiltersAddedByFilterProviders_AreNeverCached(bool reusable)
{
// Arrange
var customFilterProvider = new TestFilterProvider(
providerExecuting: (providerContext) =>
{
var filter = new TestFilter(providerContext.ActionContext.HttpContext.Items["name"] as string);
providerContext.Results.Add(
new FilterItem(new FilterDescriptor(filter, FilterScope.Global), filter)
{
IsReusable = reusable
});
},
providerExecuted: null);
var staticFilter = new TestFilter();
var actionContext = CreateActionContext(new[]
{
new FilterDescriptor(new TestFilterFactory()
{
IsReusable = false
}, FilterScope.Action),
new FilterDescriptor(staticFilter, FilterScope.Action),
});
var filterProviders = new IFilterProvider[] { new DefaultFilterProvider(), customFilterProvider };
var filterDescriptors = actionContext.ActionDescriptor.FilterDescriptors;
// Act - 1
actionContext.HttpContext.Items["name"] = "foo";
var filterResult = FilterFactory.GetAllFilters(filterProviders, actionContext);
var filters = filterResult.Filters;
// Assert - 1
Assert.Equal(3, filters.Length);
var request1Filter1 = Assert.IsType <TestFilter>(filters[0]); // Created by factory
Assert.Same(staticFilter, filters[1]); // Cached and the same statically created filter instance
var request1Filter3 = Assert.IsType <TestFilter>(filters[2]); // Created by custom filter provider
Assert.Equal("foo", request1Filter3.Data);
// Act - 2
actionContext.HttpContext.Items["name"] = "bar";
filters = FilterFactory.CreateUncachedFilters(filterProviders, actionContext, filterResult.CacheableFilters);
// Assert -2
Assert.Equal(3, filters.Length);
var request2Filter1 = Assert.IsType <TestFilter>(filters[0]);
Assert.NotSame(request1Filter1, request2Filter1); // Created by factory
Assert.Same(staticFilter, filters[1]); // Cached and the same statically created filter instance
var request2Filter3 = Assert.IsType <TestFilter>(filters[2]);
Assert.NotSame(request1Filter3, request2Filter3); // Created by custom filter provider again
Assert.Equal("bar", request2Filter3.Data);
}
public CidFontFactory(IPdfTokenScanner pdfScanner, FontDescriptorFactory descriptorFactory,
TrueTypeFontParser trueTypeFontParser,
CompactFontFormatParser compactFontFormatParser,
IFilterProvider filterProvider)
{
this.pdfScanner = pdfScanner;
this.descriptorFactory = descriptorFactory;
this.trueTypeFontParser = trueTypeFontParser;
this.compactFontFormatParser = compactFontFormatParser;
this.filterProvider = filterProvider;
}
public static ISchemaError FilterProvider_UnableToCreateFieldHandler(
IFilterProvider filterProvider,
Type fieldHandler) =>
SchemaErrorBuilder.New()
.SetMessage(
DataResources.FilterProvider_UnableToCreateFieldHandler,
fieldHandler.FullName ?? fieldHandler.Name,
filterProvider.GetType().FullName ?? filterProvider.GetType().Name)
.SetExtension(nameof(filterProvider), filterProvider)
.SetExtension(nameof(fieldHandler), fieldHandler)
.Build();
public void AddXObject(XObjectContentRecord xObject,
IPdfTokenScanner scanner,
IFilterProvider filterProvider,
IResourceStore resourceStore)
{
if (top != null && xObject.Type == XObjectType.Image)
{
var image = XObjectFactory.ReadImage(xObject, scanner, filterProvider, resourceStore);
top?.AddImage(image);
}
}
public void FilterProviderCollectionCombinedItemsCaches()
{
// Arrange
var providers = new IFilterProvider[]
{
new Mock<IFilterProvider>(MockBehavior.Strict).Object,
new Mock<IFilterProvider>(MockBehavior.Strict).Object
};
var collection = new FilterProviderCollection(providers);
// Act
IFilterProvider[] combined1 = collection.CombinedItems;
IFilterProvider[] combined2 = collection.CombinedItems;
// Assert
Assert.Equal(providers, combined1);
Assert.Same(combined1, combined2);
}
public void FilterProviderCollectionCombinedItemsDelegatesToResolver()
{
// Arrange
var firstProvider = new Mock<IFilterProvider>();
var secondProvider = new Mock<IFilterProvider>();
var thirdProvider = new Mock<IFilterProvider>();
var dependencyProviders = new IFilterProvider[] { firstProvider.Object, secondProvider.Object };
var collectionProviders = new IFilterProvider[] { thirdProvider.Object };
var expectedProviders = new IFilterProvider[] { firstProvider.Object, secondProvider.Object, thirdProvider.Object };
Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
resolver.Setup(r => r.GetServices(typeof(IFilterProvider))).Returns(dependencyProviders);
var providers = new FilterProviderCollection(collectionProviders, resolver.Object);
// Act
IFilterProvider[] combined = providers.CombinedItems;
// Assert
Assert.Equal(expectedProviders, combined);
}
private static ControllerActionInvokerCache CreateFilterCache(IFilterProvider[] filterProviders = null)
{
var services = new ServiceCollection().BuildServiceProvider();
var descriptorProvider = new ActionDescriptorCollectionProvider(services);
return new ControllerActionInvokerCache(descriptorProvider, filterProviders.AsEnumerable() ?? new List<IFilterProvider>());
}
public TestControllerActionInvoker(
ActionContext actionContext,
IFilterProvider[] filterProvider,
MockControllerFactory controllerFactory,
ControllerActionDescriptor descriptor,
IReadOnlyList<IInputFormatter> inputFormatters,
IControllerActionArgumentBinder controllerActionArgumentBinder,
IReadOnlyList<IModelBinder> modelBinders,
IReadOnlyList<IModelValidatorProvider> modelValidatorProviders,
IReadOnlyList<IValueProviderFactory> valueProviderFactories,
ILogger logger,
DiagnosticSource diagnosticSource,
int maxAllowedErrorsInModelState)
: base(
actionContext,
filterProvider,
controllerFactory,
descriptor,
inputFormatters,
controllerActionArgumentBinder,
modelBinders,
modelValidatorProviders,
valueProviderFactories,
logger,
diagnosticSource,
maxAllowedErrorsInModelState)
{
ControllerFactory = controllerFactory;
}
public TestControllerActionInvoker(
ActionContext actionContext,
IFilterProvider[] filterProvider,
MockControllerFactory controllerFactory,
ControllerActionDescriptor descriptor,
IInputFormattersProvider inputFormattersProvider,
IControllerActionArgumentBinder controllerActionArgumentBinder,
IModelBinderProvider modelBinderProvider,
IModelValidatorProviderProvider modelValidatorProviderProvider,
IValueProviderFactoryProvider valueProviderFactoryProvider,
IScopedInstance<ActionBindingContext> actionBindingContext,
ITempDataDictionary tempData)
: base(
actionContext,
filterProvider,
controllerFactory,
descriptor,
inputFormattersProvider,
controllerActionArgumentBinder,
modelBinderProvider,
modelValidatorProviderProvider,
valueProviderFactoryProvider,
actionBindingContext,
tempData)
{
ControllerFactory = controllerFactory;
}
public ExcludeFilterProvider(IFilterProvider[] filters)
{
this.filterProviders = new FilterProviderCollection(filters);
}
public TestControllerActionInvoker(
ActionContext actionContext,
IFilterProvider[] filterProvider,
MockControllerFactory controllerFactory,
ControllerActionDescriptor descriptor,
IReadOnlyList<IInputFormatter> inputFormatters,
IReadOnlyList<IOutputFormatter> outputFormatters,
IControllerActionArgumentBinder controllerActionArgumentBinder,
IReadOnlyList<IModelBinder> modelBinders,
IReadOnlyList<IModelValidatorProvider> modelValidatorProviders,
IReadOnlyList<IValueProviderFactory> valueProviderFactories,
IActionBindingContextAccessor actionBindingContext,
ILogger logger,
TelemetrySource telemetry,
int maxAllowedErrorsInModelState)
: base(
actionContext,
filterProvider,
controllerFactory,
descriptor,
inputFormatters,
outputFormatters,
controllerActionArgumentBinder,
modelBinders,
modelValidatorProviders,
valueProviderFactories,
actionBindingContext,
logger,
telemetry,
maxAllowedErrorsInModelState)
{
ControllerFactory = controllerFactory;
}
public void WithCustomConstructor_OnlyCustomActionDescriptorFilterProvidersAreUsed()
{
Mock<IFilterProvider> mockFilterProvider = new Mock<IFilterProvider>();
mockFilterProvider.Setup(p => p.GetFilters(It.IsAny<HttpConfiguration>(), It.IsAny<HttpActionDescriptor>())).Returns(() => Enumerable.Empty<FilterInfo>());
IFilter testGlobalFilter = new UnorderedFilter();
_configuration.Filters.Add(testGlobalFilter);
_filterProvider = new OrderedFilterProvider(new[] { mockFilterProvider.Object });
var filters = _filterProvider.GetFilters(_configuration, _mockActionDescriptor.Object);
filters.ShouldNotContain(f => f.Instance == testGlobalFilter);
_mockControllerDescriptor.Verify(d => d.GetFilters(), Times.Never(), "Controller Filters should not have been requested");
_mockActionDescriptor.Verify(d => d.GetFilters(), Times.Never(), "Action Filters should not have been requested");
}
public void Setup()
{
_configuration = new HttpConfiguration();
_lstActionFilters = new List<IFilter>();
_lstControllerFilters = new List<IFilter>();
_mockControllerDescriptor = new Mock<HttpControllerDescriptor>();
_mockControllerDescriptor.Setup(d => d.GetFilters()).Returns(() => new Collection<IFilter>(_lstControllerFilters));
_mockActionDescriptor = new Mock<HttpActionDescriptor>();
_mockActionDescriptor.Setup(d => d.GetFilters()).Returns(() => new Collection<IFilter>(_lstActionFilters));
_mockActionDescriptor.Object.ControllerDescriptor = _mockControllerDescriptor.Object;
_filterProvider = new OrderedFilterProvider();
}
public TestControllerActionInvoker(
ActionContext actionContext,
IFilterProvider[] filterProvider,
MockControllerFactory controllerFactory,
ControllerActionDescriptor descriptor,
IReadOnlyList<IInputFormatter> inputFormatters,
IReadOnlyList<IOutputFormatter> outputFormatters,
IControllerActionArgumentBinder controllerActionArgumentBinder,
IReadOnlyList<IModelBinder> modelBinders,
IReadOnlyList<IModelValidatorProvider> modelValidatorProviders,
IReadOnlyList<IValueProviderFactory> valueProviderFactories,
IScopedInstance<ActionBindingContext> actionBindingContext,
ITempDataDictionary tempData,
ILoggerFactory loggerFactory,
int maxAllowedErrorsInModelState)
: base(
actionContext,
filterProvider,
controllerFactory,
descriptor,
inputFormatters,
outputFormatters,
controllerActionArgumentBinder,
modelBinders,
modelValidatorProviders,
valueProviderFactories,
actionBindingContext,
tempData,
loggerFactory,
maxAllowedErrorsInModelState)
{
ControllerFactory = controllerFactory;
}
