/// <summary> /// Adds customized JSON serializer settings. /// </summary> public static IMvcCoreBuilder AddCustomJsonOptions( this IMvcCoreBuilder builder, IHostingEnvironment hostingEnvironment) => builder.AddJsonOptions( options => { if (hostingEnvironment.IsDevelopment()) { // Pretty print the JSON in development for easier debugging. options.SerializerSettings.Formatting = Formatting.Indented; } // Parse dates as DateTimeOffset values by default. You should prefer using DateTimeOffset over // DateTime everywhere. Not doing so can cause problems with time-zones. options.SerializerSettings.DateParseHandling = DateParseHandling.DateTimeOffset; // Output enumeration values as strings in JSON. options.SerializerSettings.Converters.Add(new StringEnumConverter()); });
public static IMvcCoreBuilder ConfigureControllerFactories(this IMvcCoreBuilder mvcServiceBuilder, Func <IServiceProvider, IControllerActivatorProvider> controllerActivatorProvider = null, Func <IServiceProvider, IControllerActivator> controllerActivator = null, Func <IServiceProvider, IControllerFactoryProvider> controllerFactoryProvider = null, Func <IServiceProvider, IControllerFactory> controllerFactory = null) { if (controllerActivatorProvider == null) { mvcServiceBuilder.Services.Replace(ServiceDescriptor.Singleton <IControllerActivatorProvider, ControllerActivatorProvider>()); } else { mvcServiceBuilder.Services.Replace(ServiceDescriptor.Singleton(controllerActivatorProvider)); } if (controllerActivator == null) { mvcServiceBuilder.Services.Replace(ServiceDescriptor.Transient <IControllerActivator, DefaultControllerActivator>()); } else { mvcServiceBuilder.Services.Replace(ServiceDescriptor.Transient(controllerActivator)); } if (controllerFactoryProvider == null) { mvcServiceBuilder.Services.Replace(ServiceDescriptor.Singleton <IControllerFactoryProvider, ControllerFactoryProvider>()); } else { mvcServiceBuilder.Services.Replace(ServiceDescriptor.Singleton(controllerFactoryProvider)); } if (controllerFactory == null) { mvcServiceBuilder.Services.Replace(ServiceDescriptor.Singleton <IControllerFactory, DefaultControllerFactory>()); } else { mvcServiceBuilder.Services.Replace(ServiceDescriptor.Singleton(controllerFactory)); } //mvcServiceBuilder.AddControllersAsServices(); //the line above does the following: //mvcServiceBuilder.Services.Replace(ServiceDescriptor.Transient<IControllerActivator, ServiceBasedControllerActivator>()); return(mvcServiceBuilder); }
/// <summary> /// Registers <see cref="CookieTempDataProvider"/> as the default <see cref="ITempDataProvider"/> in the /// <see cref="IServiceCollection"/>. Also registers the default view services. /// </summary> /// <param name="builder">The <see cref="IMvcCoreBuilder"/>.</param> /// <param name="setupAction"> /// An <see cref="Action{CookieTempDataProviderOptions}"/> to configure the provided /// <see cref="CookieTempDataProviderOptions"/>. /// </param> /// <returns>The <see cref="IMvcCoreBuilder"/>.</returns> public static IMvcCoreBuilder AddCookieTempDataProvider( this IMvcCoreBuilder builder, Action <CookieTempDataProviderOptions> setupAction) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (setupAction == null) { throw new ArgumentNullException(nameof(setupAction)); } AddCookieTempDataProvider(builder); builder.Services.Configure(setupAction); return(builder); }
public static IMvcCoreBuilder AddViews( this IMvcCoreBuilder builder, Action <MvcViewOptions> setupAction) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (setupAction == null) { throw new ArgumentNullException(nameof(setupAction)); } AddViews(builder); builder.Services.Configure(setupAction); return(builder); }
private IWebHostBuilder SetupWebHost(StringWriter testOutput) { var hostBuilder = new WebHostBuilder(); // Configure services #if ASPNETCORE2_0 hostBuilder.UseLogJam((LogManagerConfig config, WebHostBuilderContext hostBuilderContext) => #else hostBuilder.UseLogJam((LogManagerConfig config, IServiceProvider serviceProvider) => #endif { config.UseTestOutput(_testOutput); config.UseTextWriter(testOutput); }); hostBuilder.ConfigureServices(serviceCollection => { IMvcCoreBuilder mvcCoreBuilder = serviceCollection.AddMvcCore(); mvcCoreBuilder.AddJsonFormatters(); #if ASPNETCORE2_0 serviceCollection.Configure <LoggerFilterOptions>(filterOptions => filterOptions.MinLevel = LogLevel.Trace); #else serviceCollection.Configure <FilterLoggerSettings>(filterSettings => filterSettings.Add("Default", LogLevel.Trace)); #endif }); // Configure webapp hostBuilder.Configure(appBuilder => { appBuilder.UseStatusCodePages(); appBuilder.UseExceptionHandler(new ExceptionHandlerOptions() { ExceptionHandler = async context => { context.Response.StatusCode = 500; await context.Response.WriteAsync("Unhandled exception"); } }); appBuilder.UseMvc(); }); return(hostBuilder); }
public static IMvcCoreBuilder AddModularRazorPages(this IMvcCoreBuilder builder) { builder.AddRazorPages(options => { options.RootDirectory = "/"; options.Conventions.Add(new DefaultModularPageRouteModelConvention()); }); builder.Services.TryAddEnumerable( ServiceDescriptor.Transient <IConfigureOptions <RazorViewEngineOptions>, ModularPageRazorViewEngineOptionsSetup>()); builder.Services.TryAddEnumerable( ServiceDescriptor.Singleton <IPageApplicationModelProvider, ModularPageApplicationModelProvider>()); builder.Services.Replace( ServiceDescriptor.Singleton <IActionDescriptorChangeProvider, ModularPageActionDescriptorChangeProvider>()); return(builder); }
/// <summary> /// Add Salesforce WebHook configuration and services to the specified <paramref name="builder"/>. /// </summary> /// <param name="builder">The <see cref="IMvcCoreBuilder" /> to configure.</param> /// <returns>The <paramref name="builder"/>.</returns> public static IMvcCoreBuilder AddSalesforceWebHooks(this IMvcCoreBuilder builder) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } var services = builder.Services; services.TryAddEnumerable(ServiceDescriptor.Singleton <IWebHookMetadata, SalesforceMetadata>()); services.TryAddSingleton <ISalesforceResultCreator, SalesforceResultCreator>(); // ??? Are the [DataContract] formatters also needed? XmlSerializer is enough for at least XElement. // ??? Does SalesforceAcknowledgmentFilter need a non-default Order too? return(builder .AddXmlSerializerFormatters() .AddWebHooks(OptionsSetupAction) .AddSingletonFilter <SalesforceAcknowledgmentFilter>() .AddSingletonFilter <SalesforceVerifyOrganizationIdFilter>(WebHookSecurityFilter.Order)); }
public static IWebHostBuilder ForFullNode(this IWebHostBuilder hostBuilder, FullNode fullNode) { hostBuilder.ConfigureServices(s => { IMvcCoreBuilder mvcBuilder = s.AddMvcCore(o => { o.ModelBinderProviders.Insert(0, new DestinationModelBinder()); o.ModelBinderProviders.Insert(0, new MoneyModelBinder()); }); // Include all feature assemblies for action discovery otherwise RPC actions will not execute // https://stackoverflow.com/questions/37725934/asp-net-core-mvc-controllers-in-separate-assembly foreach (Assembly assembly in fullNode.Services.Features.OfType <FullNodeFeature>().Select(x => x.GetType().GetTypeInfo().Assembly).Distinct()) { mvcBuilder.AddApplicationPart(assembly); } }); return(hostBuilder); }
public void ConfigureServices(IServiceCollection services) { services.AddDbContext <ConfigurationContext>(options => options.UseSqlServer(Configuration.GetConnectionString("connectionstring"))); this.ApplicationService(services); this.ConfigureAuth(services); services.AddOptions(); IMvcCoreBuilder mvcCoreBuilder = services.AddMvcCore(options => { var policy = new AuthorizationPolicyBuilder() .RequireAuthenticatedUser() .Build(); options.Filters.Add(new AuthorizeFilter(policy)); }); mvcCoreBuilder.AddFormatterMappings() .AddJsonFormatters() .AddCors(); }
public static IMvcCoreBuilder AddJsonFormatters( this IMvcCoreBuilder builder, Action <JsonSerializerSettings> setupAction) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (setupAction == null) { throw new ArgumentNullException(nameof(setupAction)); } AddJsonFormatterServices(builder.Services); builder.Services.Configure <MvcJsonOptions>((options) => setupAction(options.SerializerSettings)); return(builder); }
private static void ConfigureInterfaces(this IMvcCoreBuilder mvcBuilder, IEnumerable <Type> serviceTypes) { foreach (var t in serviceTypes) { mvcBuilder.AddMvcOptions(opt => { opt.Conventions.Add(new ControllerModelConvention(t)); opt.Conventions.Add(new ActionModelConvention(t)); opt.Conventions.Add(new ParameterModelConvention(t)); }); } mvcBuilder.ConfigureApplicationPartManager(manager => { var featureProvider = new ServiceControllerFeatureProvider(serviceTypes); manager.FeatureProviders.Remove(manager.FeatureProviders.FirstOrDefault(x => x.GetType() == typeof(ControllerFeatureProvider))); manager.FeatureProviders.Add(featureProvider); }); }
public static IMvcCoreBuilder ConfigureMvcUsing(this IMvcCoreBuilder mvcCoreBuilder, ModuleRegistry moduleRegistry) { var controllerTypes = new List <Type>(); var controllerToModulePrefixMap = new Dictionary <Type, BaseRoute>(); foreach (var module in moduleRegistry.Modules) { var moduleControllerTypes = module.ControllerTypes; foreach (var moduleControllerType in moduleControllerTypes) { controllerToModulePrefixMap.Add(moduleControllerType, module.BaseRoute); controllerTypes.Add(moduleControllerType); } } return(mvcCoreBuilder .AddMvcOptions(o => o.Conventions.Insert(0, new ModulePrefixConvention(controllerToModulePrefixMap))) .AddSpecificControllers(controllerTypes)); }
public static IMvcCoreBuilder AddCustomMvcOptions( this IMvcCoreBuilder builder, IHostingEnvironment hostingEnvironment) => builder.AddMvcOptions( options => { // Controls how controller actions cache content from the appsettings.json file. var cacheProfileOptions = builder.Services.BuildServiceProvider().GetRequiredService <CacheProfileOptions>(); foreach (var keyValuePair in cacheProfileOptions) { options.CacheProfiles.Add(keyValuePair); } // Remove string and stream output formatters. These are not useful for an API serving JSON or XML. options.OutputFormatters.RemoveType <StreamOutputFormatter>(); options.OutputFormatters.RemoveType <StringOutputFormatter>(); // Returns a 406 Not Acceptable if the MIME type in the Accept HTTP header is not valid. options.ReturnHttpNotAcceptable = true; });
public static IServiceCollection AddJsonApi <TContext>(this IServiceCollection services, Action <JsonApiOptions> options, IMvcCoreBuilder mvcBuilder) where TContext : DbContext { var config = new JsonApiOptions(); options(config); config.BuildContextGraph(builder => builder.AddDbContext <TContext>()); mvcBuilder .AddMvcOptions(opt => { opt.Filters.Add(typeof(JsonApiExceptionFilter)); opt.SerializeAsJsonApi(config); }); AddJsonApiInternals <TContext>(services, config); return(services); }
public static IServiceCollection AddJsonApi( this IServiceCollection services, Action <JsonApiOptions> configureOptions, IMvcCoreBuilder mvcBuilder, Action <ServiceDiscoveryFacade> autoDiscover = null) { var config = new JsonApiOptions(); configureOptions(config); if (autoDiscover != null) { var facade = new ServiceDiscoveryFacade(services, config.ResourceGraphBuilder); autoDiscover(facade); } mvcBuilder.AddMvcOptions(opt => AddMvcOptions(opt, config)); AddJsonApiInternals(services, config); return(services); }
public static IServiceProvider ConfigureApplicationServices(this IServiceCollection services, IConfiguration configuration, IWebHostEnvironment hostingEnvironment) { //add Config configuration parameters CepresConfig config = services.ConfigureStartupConfig <CepresConfig>(configuration.GetSection("Cepres")); //add accessor to HttpContext services.AddHttpContextAccessor(); CommonHelper.DefaultFileProvider = new FileManagerProvider(hostingEnvironment); IMvcCoreBuilder mvcCoreBuilder = services.AddMvcCore(); //create, initialize and configure the engine IEngine engine = EngineContext.Create(); IServiceProvider serviceProvider = engine.ConfigureServices(services, configuration); SqlServerDataProvider.InitializeDatabase(config.DataConnectionString); return(serviceProvider); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { IMvcCoreBuilder builder = services .AddMvcCore() .AddApiExplorer() .AddAuthorization() .AddCors() .AddDataAnnotations() .AddFormatterMappings() .AddViews() .AddRazorViewEngine() .AddCacheTagHelper(); AddTagHelpersFrameworkParts(builder.PartManager); // In production, the React files will be served from this directory services.AddSpaStaticFiles(configuration => { configuration.RootPath = "ClientApp/build"; }); }
public static IMvcCoreBuilder ConfigureActionInvokers(this IMvcCoreBuilder mvcServiceBuilder, Func <IServiceProvider, IActionInvokerFactory> actionInvokerFactory = null, Func <IServiceProvider, IActionInvokerProvider> actionInvokerProvider = null) { if (actionInvokerFactory == null) { mvcServiceBuilder.Services.Replace(ServiceDescriptor.Singleton <IActionInvokerFactory, ActionInvokerFactory>()); } else { mvcServiceBuilder.Services.Replace(ServiceDescriptor.Singleton(actionInvokerFactory)); } mvcServiceBuilder.Services.RemoveAll <IActionInvokerProvider>(); if (actionInvokerProvider == null) { mvcServiceBuilder.Services.TryAddEnumerable(ServiceDescriptor.Transient <IActionInvokerProvider, ControllerActionInvokerProvider>()); } else { mvcServiceBuilder.Services.TryAddEnumerable(ServiceDescriptor.Transient(actionInvokerProvider)); } return(mvcServiceBuilder); }
public static IMvcCoreBuilder AddGitLfs(this IMvcCoreBuilder builder) { builder.AddNewtonsoftJson(); builder.AddApplicationPart(typeof(LfsConstants).GetTypeInfo().Assembly); builder.AddMvcOptions(options => { options.Filters.Add(new ProducesAttribute(LfsConstants.LfsMediaType.MediaType.Buffer)); options.Filters.Add(new TypeFilterAttribute(typeof(BasicAuthFilter))); foreach (InputFormatter input in options.InputFormatters.OfType <NewtonsoftJsonInputFormatter>()) { input.SupportedMediaTypes.Add(LfsConstants.LfsMediaType); } foreach (OutputFormatter output in options.OutputFormatters.OfType <NewtonsoftJsonOutputFormatter>()) { output.SupportedMediaTypes.Add(LfsConstants.LfsMediaType); } }); return(builder); }
public static IMvcCoreBuilder AddConfigurationApi(this IMvcCoreBuilder mvcBuilder, Action <ConfigurationApiOptions> configureAction = null) { if (configureAction != null) { mvcBuilder.Services.Configure <ConfigurationApiOptions>(o => { configureAction.Invoke(o); }); } mvcBuilder.Services.AddValidOptions(); mvcBuilder.Services.AddSaveOptions(); mvcBuilder.Services.TryAddSingleton <ITypeResolver, ReflectionTypeResolver>(); mvcBuilder.Services.AddSingleton <ConfigurationService>(); mvcBuilder.AddActiveRoute <ConfigurationController, ConfigurationFeature, ConfigurationApiOptions>(); return(mvcBuilder); }
private static IMvcCoreBuilder ConfigureInterfaces(this IMvcCoreBuilder mvcBuilder, WebApiProxyOptions options) { foreach (var t in options.RegisteredServices.Select(x => x.Value)) { mvcBuilder.AddMvcOptions(opt => { opt.Conventions.Add(new ControllerModelConvention(t)); opt.Conventions.Add(new ActionModelConvention(t)); opt.Conventions.Add(new ParameterModelConvention(t)); }); } mvcBuilder.ConfigureApplicationPartManager(manager => { var featureProvider = new ServiceControllerFeatureProvider(options.RegisteredServices.Select(x => x.Value)); manager.FeatureProviders.Remove(manager.FeatureProviders.FirstOrDefault(x => x.GetType() == typeof(ControllerFeatureProvider))); manager.FeatureProviders.Add(featureProvider); }); return(mvcBuilder); }
/// <summary> /// Adds an initialization callback for a given <typeparamref name="TTagHelper"/>. /// </summary> /// <remarks> /// The callback will be invoked on any <typeparamref name="TTagHelper"/> instance before the /// <see cref="ITagHelperComponent.ProcessAsync(TagHelperContext, TagHelperOutput)"/> method is called. /// </remarks> /// <typeparam name="TTagHelper">The type of <see cref="ITagHelper"/> being initialized.</typeparam> /// <param name="builder">The <see cref="IMvcCoreBuilder"/> instance this method extends.</param> /// <param name="initialize">An action to initialize the <typeparamref name="TTagHelper"/>.</param> /// <returns>The <see cref="IMvcCoreBuilder"/> instance this method extends.</returns> public static IMvcCoreBuilder InitializeTagHelper <TTagHelper>( this IMvcCoreBuilder builder, Action <TTagHelper, ViewContext> initialize) where TTagHelper : ITagHelper { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (initialize == null) { throw new ArgumentNullException(nameof(initialize)); } var initializer = new TagHelperInitializer <TTagHelper>(initialize); builder.Services.AddSingleton(typeof(ITagHelperInitializer <TTagHelper>), initializer); return(builder); }
/// <summary> /// Register services needed for Razor Pages. /// </summary> /// <param name="builder">The <see cref="IMvcCoreBuilder"/>.</param> /// <param name="setupAction">The action to setup the <see cref="RazorPagesOptions"/>.</param> /// <returns>The <see cref="IMvcCoreBuilder"/>.</returns> public static IMvcCoreBuilder AddRazorPages( this IMvcCoreBuilder builder, Action <RazorPagesOptions> setupAction) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (setupAction == null) { throw new ArgumentNullException(nameof(setupAction)); } builder.AddRazorViewEngine(); AddRazorPagesServices(builder.Services); builder.Services.Configure(setupAction); return(builder); }
internal static IMvcCoreBuilder AddAuthorization(this IMvcCoreBuilder @this, IConfiguration configuration) { var authConfig = configuration .GetSection("authentication") .Get <AuthConfiguration>(); if (!authConfig.IsEnabled()) { return(@this.AddAuthorization()); } return(@this .AddAuthorization(options => { options.AddPolicy(AdminPolicy, builder => builder .RequireScope("hawk")); options.AddPolicy(ReadOnlyPolicy, builder => builder .RequireScope("hawk") .RequireScope("hawk.readonly")); })); }
/// <summary> /// Enabling JsonApiDotNetCore using the EF Core DbContext to build the ResourceGraph. /// </summary> public static IServiceCollection AddJsonApi <TDbContext>(this IServiceCollection services, Action <JsonApiOptions> options = null, Action <IServiceDiscoveryFacade> discovery = null, Action <IResourceGraphBuilder> resources = null, IMvcCoreBuilder mvcBuilder = null) where TDbContext : DbContext { var application = new JsonApiApplicationBuilder(services, mvcBuilder ?? services.AddMvcCore()); if (options != null) { application.ConfigureJsonApiOptions(options); } application.ConfigureMvc(); if (discovery != null) { application.AutoDiscover(discovery); } application.ConfigureResources <TDbContext>(resources); application.ConfigureServices(); return(services); }
public static IMvcCoreBuilder AddCustomMvcOptions(this IMvcCoreBuilder builder) { return(builder.AddMvcOptions( options => { // Controls how controller actions cache content from the appsettings.json file. CacheProfileOptionsDictionary cacheProfileOptions = builder .Services .BuildServiceProvider() .GetRequiredService <CacheProfileOptionsDictionary>(); foreach (System.Collections.Generic.KeyValuePair <string, Microsoft.AspNetCore.Mvc.CacheProfile> keyValuePair in cacheProfileOptions) { options.CacheProfiles.Add(keyValuePair); } MediaTypeCollection jsonInputFormatterMediaTypes = options .InputFormatters .OfType <JsonInputFormatter>() .First() .SupportedMediaTypes; MediaTypeCollection jsonOutputFormatterMediaTypes = options .OutputFormatters .OfType <JsonOutputFormatter>() .First() .SupportedMediaTypes; // Add RESTful JSON media type (application/vnd.restful+json) to the JSON input and output formatters. // See http://restfuljson.org/ jsonInputFormatterMediaTypes.Insert(0, ContentType.RestfulJson); jsonOutputFormatterMediaTypes.Insert(0, ContentType.RestfulJson); // Remove string and stream output formatters. These are not useful for an API serving JSON or XML. options.OutputFormatters.RemoveType <StreamOutputFormatter>(); options.OutputFormatters.RemoveType <StringOutputFormatter>(); // Returns a 406 Not Acceptable if the MIME type in the Accept HTTP header is not valid. options.ReturnHttpNotAcceptable = true; })); }
/// <summary> /// Adds Fluent Validation services to the specified /// <see cref="T:Microsoft.Extensions.DependencyInjection.IMvcBuilder" />. /// </summary> /// <returns> /// An <see cref="T:Microsoft.Extensions.DependencyInjection.IMvcCoreBuilder" /> that can be used to further configure the /// MVC services. /// </returns> public static IMvcCoreBuilder AddFluentValidation(this IMvcCoreBuilder mvcBuilder, Action <FluentValidationMvcConfiguration> configurationExpression = null) { var expr = configurationExpression ?? delegate { }; var config = new FluentValidationMvcConfiguration(); expr(config); if (config.AssembliesToRegister.Count > 0) { RegisterTypes(config.AssembliesToRegister, mvcBuilder.Services); } RegisterServices(mvcBuilder.Services, config); // clear all model validation providers since fluent validation will be handling everything mvcBuilder.AddMvcOptions( options => { options.ModelValidatorProviders.Clear(); }); return(mvcBuilder); }
/// <summary> /// Perform file deply /// </summary> /// <param name="plug">Plugin file info</param> /// <param name="applicationPartManager">Application part manager</param> /// <returns>Assembly</returns> private static Assembly AddApplicationPart(FileInfo plug, IMvcCoreBuilder mvcCoreBuilder, GrandConfig config) { if (plug.Directory == null || plug.Directory.Parent == null) { throw new InvalidOperationException("The plugin directory for the " + plug.Name + " file exists in a folder outside of the allowed grandnode folder hierarchy"); } var _plug = config.PluginShadowCopy ? ShadowCopyFile(plug, Directory.CreateDirectory(_shadowCopyFolder.FullName)) : plug; try { Assembly assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(_plug.FullName); //we can now register the plugin definition Debug.WriteLine("Adding to ApplicationParts: '{0}'", assembly.FullName); mvcCoreBuilder.AddApplicationPart(assembly); return(assembly); } catch (Exception ex) { throw new InvalidOperationException($"The plugin directory for the {plug.Name} file exists in a folder outside of the allowed grandnode folder hierarchy - exception because of {plug.FullName} - exception: {ex.Message}"); } }
public static IMvcCoreBuilder AddCustomMvcOptions( this IMvcCoreBuilder builder, IHostingEnvironment hostingEnvironment) => builder.AddMvcOptions( options => { // Controls how controller actions cache content from the appsettings.json file. var cacheProfileOptions = builder .Services .BuildServiceProvider() .GetRequiredService <CacheProfileOptions>(); foreach (var keyValuePair in cacheProfileOptions) { options.CacheProfiles.Add(keyValuePair); } var jsonInputFormatterMediaTypes = options .InputFormatters .OfType <JsonInputFormatter>() .First() .SupportedMediaTypes; var jsonOutputFormatterMediaTypes = options .OutputFormatters .OfType <JsonOutputFormatter>() .First() .SupportedMediaTypes; // Add Problem Details media type (application/problem+json) to the JSON output formatters. // See https://tools.ietf.org/html/rfc7807 jsonOutputFormatterMediaTypes.Insert(0, ContentType.ProblemJson); // Add RESTful JSON media type (application/vnd.restful+json) to the JSON input and output formatters. // See http://restfuljson.org/ jsonInputFormatterMediaTypes.Insert(0, ContentType.RestfulJson); jsonOutputFormatterMediaTypes.Insert(0, ContentType.RestfulJson); // Returns a 406 Not Acceptable if the MIME type in the Accept HTTP header is not valid. options.ReturnHttpNotAcceptable = true; });
public static IMvcCoreBuilder AddMessagePackFormatters(this IMvcCoreBuilder builder, Action <MessagePackFormatterOptions> messagePackFormatterOptionsConfiguration) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } var messagePackFormatterOptions = new MessagePackFormatterOptions(); messagePackFormatterOptionsConfiguration?.Invoke(messagePackFormatterOptions); messagePackFormatterOptions.Options.WithResolver(messagePackFormatterOptions.FormatterResolver); foreach (var extension in messagePackFormatterOptions.SupportedExtensions) { foreach (var contentType in messagePackFormatterOptions.SupportedContentTypes) { builder.AddFormatterMappings(m => m.SetMediaTypeMappingForFormat(extension, new MediaTypeHeaderValue(contentType))); } } //builder.AddMvcOptions(options => options.InputFormatters.Add(new MessagePackInputFormatter(messagePackFormatterOptions))); //builder.AddMvcOptions(options => options.OutputFormatters.Add(new MessagePackOutputFormatter(messagePackFormatterOptions))); builder.AddMvcOptions(options => { options.InputFormatters.Clear(); options.InputFormatters.Add(new MessagePackInputFormatter(messagePackFormatterOptions)); }); builder.AddMvcOptions(options => { options.OutputFormatters.Clear(); options.OutputFormatters.Add(new MessagePackOutputFormatter(messagePackFormatterOptions)); }); return(builder); }