public static IMvcBuilder AppendJsonSettings(this IMvcBuilder mvcBuilder
#if !NETCOREAPP3_1 && !NET5_0
, Action <MvcJsonOptions>?mvcJsonOption = null
#else
, Action <JsonOptions>?jsonOptions = null, Action <MvcNewtonsoftJsonOptions>?mvcJsonOptions = null
#endif
)
{
#if NETCOREAPP3_1 || NET5_0
return(mvcBuilder.AddJsonOptions(options =>
{
options.JsonSerializerOptions.Encoder = JavaScriptEncoder.Create(UnicodeRanges.All);
options.JsonSerializerOptions.PropertyNamingPolicy = null;
jsonOptions?.Invoke(options);
}).AddNewtonsoftJson(options =>
{
options.SerializerSettings.ContractResolver = new DefaultContractResolver();
mvcJsonOptions?.Invoke(options);
}));
#else
return(mvcBuilder.AddJsonOptions(options =>
{
options.SerializerSettings.ContractResolver = new DefaultContractResolver();
mvcJsonOption?.Invoke(options);
}));
#endif
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
IMvcBuilder mvcBuilder = services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
#if DEBUG
mvcBuilder.AddJsonOptions(options => { options.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented; });
#endif
services.AddSwaggerGen(c =>
{
c.DescribeAllEnumsAsStrings();
c.SwaggerDoc("v1", new Info //OpenApiInfo
{
Version = "v1",
Title = "ExerceoBitcamp2019",
Description = "This is our hackathon project.",
Contact = new Contact //OpenApiContact
{
Name = "ExerceoBitGroup",
Email = string.Empty,
Url = "" //new Uri("https://google.com")
},
License = new License //OpenApiLicense
{
Name = "Use under Apache",
Url = "" //new Uri("https://google.com")
}
});
//var xmlFile = $"{Assembly.GetExecut ingAssembly().GetName().Name}.xml";
//var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
//c.IncludeXmlComments(xmlPath);
});
}
public static IMvcBuilder AddNaos(
this IMvcBuilder mvcBuilder,
Action <NaosMvcOptions> optionsAction = null)
{
var options = new NaosMvcOptions();
optionsAction?.Invoke(options);
if (!options.ControllerRegistrations.IsNullOrEmpty())
{
mvcBuilder
.AddMvcOptions(o =>
{
o.Filters.Add <OperationCancelledExceptionFilter>();
o.Conventions.Add(new GeneratedControllerRouteConvention());
})
.ConfigureApplicationPartManager(o => o
.FeatureProviders.Add(
new GeneratedRepositoryControllerFeatureProvider(options.ControllerRegistrations)));
}
mvcBuilder.AddControllersAsServices(); // needed to resolve controllers through di https://andrewlock.net/controller-activation-and-dependency-injection-in-asp-net-core-mvc/
mvcBuilder.AddJsonOptions(o => o.AddDefaultJsonSerializerSettings(options.JsonSerializerSettings));
return(mvcBuilder);
}
public static IMvcBuilder AddFuzzySerializer(this IMvcBuilder mvcBuilder)
{
return(mvcBuilder.AddJsonOptions(opt =>
{
opt.SerializerSettings.ContractResolver = new FuzzyObjectContractResolver();
}));
}
private void IndentJsonForDevelopment(IMvcBuilder mvc)
{
if (Env.IsDevelopment())
{
mvc.AddJsonOptions(jsonFormat => jsonFormat.SerializerSettings.Formatting = Formatting.Indented);
}
}
public static void AddDataContractResolver(this IMvcBuilder builder)
{
builder.AddJsonOptions(opts =>
{
opts.SerializerSettings.ContractResolver = new SensitiveDataContractResolver();
});
}
/// <summary>
/// Adds customized JSON serializer settings.
/// </summary>
public static IMvcBuilder AddCustomJsonOptions(
this IMvcBuilder builder,
IWebHostEnvironment webHostEnvironment)
{
return(builder.AddJsonOptions(
options =>
{
var jsonSerializerOptions = options.JsonSerializerOptions;
if (webHostEnvironment.IsDevelopment())
{
// Pretty print the JSON in development for easier debugging.
jsonSerializerOptions.WriteIndented = true;
}
jsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
// changes response to be Pascal case rather than Camel Case
jsonSerializerOptions.DictionaryKeyPolicy = null;
jsonSerializerOptions.PropertyNamingPolicy = null;
// Parse dates as DateTimeOffset values by default. You should prefer using DateTimeOffset over
// DateTime everywhere. Not doing so can cause problems with time-zones.
// jsonSerializerOptions.SerializerSettings.DateParseHandling = DateParseHandling.DateTimeOffset;
// removes null collections and objects
jsonSerializerOptions.IgnoreNullValues = true;
//omits empty collections
}));
}
/// <summary>
/// Format json response data.
/// See https://docs.microsoft.com/es-es/aspnet/core/web-api/advanced/formatting
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IMvcBuilder AddCustomJsonOptions(this IMvcBuilder builder) =>
builder.AddJsonOptions(options =>
{
// Use the default property (Pascal) casing.
options.JsonSerializerOptions.PropertyNamingPolicy = null;
options.JsonSerializerOptions.IgnoreNullValues = true;
});
public static IMvcBuilder ConfigureTextJson(this IMvcBuilder builder, JsonOptions options, ICustomMediaTypeService customMediaTypeService)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
return(builder.AddJsonOptions(o =>
{
o.JsonSerializerOptions.AllowTrailingCommas = options.BeTolerant;
o.JsonSerializerOptions.PropertyNameCaseInsensitive = options.BeTolerant;
if (options.BeTolerant)
{
o.JsonSerializerOptions.ReadCommentHandling = JsonCommentHandling.Skip;
}
o.JsonSerializerOptions.IgnoreNullValues = options.IgnoreNullValue;
o.JsonSerializerOptions.PropertyNamingPolicy = options.UseCamelCase ? JsonNamingPolicy.CamelCase : null;
if (options.EnumAsString)
{
o.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
}
}).AddMvcOptions(o =>
{
o.AddCustomInputFormatters();
o.AddCustomOutputFormatters <SystemTextJsonOutputFormatter>(customMediaTypeService);
}));
}
/// <summary>
/// Configures the input and output formatters.
/// </summary>
private static void ConfigureFormatters(IMvcBuilder mvcBuilder)
{
// The JSON input and output formatters are added to MVC by default.
// $Start-JsonSerializerSettings$
// Configures the JSON output formatter to use camel case property names like 'propertyName' instead of
// pascal case 'PropertyName' as this is the more common JavaScript/JSON style.
mvcBuilder.AddJsonOptions(
x => x.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver());
// $End-JsonSerializerSettings$
// $Start-BsonFormatter$
// Adds the BSON input and output formatters using the JSON.NET serializer.
mvcBuilder.AddBsonSerializerFormatters();
// $End-BsonFormatter$
// $Start-XmlFormatter-DataContractSerializer$
// Adds the XML input and output formatter using the DataContractSerializer.
mvcBuilder.AddXmlDataContractSerializerFormatters();
// $End-XmlFormatter-DataContractSerializer$
// $Start-XmlFormatter-XmlSerializer$
// Adds the XML input and output formatter using the XmlSerializer.
mvcBuilder.AddXmlSerializerFormatters();
// $End-XmlFormatter-XmlSerializer$
}
public static IMvcBuilder AddCrazyPriceValidation(this IMvcBuilder mvcBuilder)
{
mvcBuilder.AddFluentValidation(fv => fv.RegisterValidatorsFromAssemblyContaining <SearchCriteriaValidator>());
mvcBuilder.AddJsonOptions(opts =>
{
opts.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
opts.JsonSerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
});
mvcBuilder.Services.Configure <ApiBehaviorOptions>(options =>
{
options.InvalidModelStateResponseFactory = context =>
{
var(key, value) =
context.ModelState.First(e => e.Value.ValidationState == ModelValidationState.Invalid);
var error = value.Errors[0].ErrorMessage;
#region ForPrimitiveType
// Needed if the controller gets a primitive type like string or int etc.
if (error.Contains("''"))
{
error = error.Replace("''", $"'{key}'");
}
#endregion
return(new BadRequestObjectResult(error));
};
});
return(mvcBuilder);
}
/// <summary>
/// Configures the input and output formatters.
/// </summary>
private static void ConfigureFormatters(IMvcBuilder mvcBuilder)
{
// Configures the JSON output formatter to use camel case property names like 'propertyName' instead of
// pascal case 'PropertyName' as this is the more common JavaScript/JSON style.
mvcBuilder.AddJsonOptions(
x => x.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver());
}
private static IMvcBuilder AddJsonSerializerOptions(this IMvcBuilder mvcBuilder)
=> mvcBuilder.AddJsonOptions(opt =>
{
opt.JsonSerializerOptions.DictionaryKeyPolicy = JsonNamingPolicy.CamelCase;
opt.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
opt.JsonSerializerOptions.IgnoreNullValues = false;
});
/// <summary>
/// Sets up some common, default JsonSerializerOptions settings:<br/>
/// - CamelCase property names.
/// - Indented formatting.
/// - Ignore null properties which have values.
/// - Enums are rendered as string's ... not their backing number-value.
/// </summary>
/// <param name="builder"Mvc builder to help create the Mvc settings.></param>
/// <returns>IMvcBuilder: the builder, so we can more builder methods.</returns>
public static IMvcBuilder AddDefaultJsonOptions(this IMvcBuilder builder,
bool isIndented = false,
string?dateTimeFormat = null,
IEnumerable <JsonConverter>?converters = null)
{
return(builder.AddJsonOptions(options =>
{
options.JsonSerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
options.JsonSerializerOptions.WriteIndented = isIndented;
options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter(JsonNamingPolicy.CamelCase));
// If we have specified a custom date-time format, then use the specific custom converter.
if (!string.IsNullOrWhiteSpace(dateTimeFormat))
{
options.JsonSerializerOptions.Converters.Add(new DateTimeConverter(dateTimeFormat));
}
if (converters?.Any() == true)
{
foreach (var converter in converters)
{
options.JsonSerializerOptions.Converters.Add(converter);
}
}
}));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
IMvcBuilder mvcBuilder = services.AddMvc();
services.AddCors();
mvcBuilder.AddJsonOptions
(opts => opts.SerializerSettings.ContractResolver =
new CamelCasePropertyNamesContractResolver());
services.AddOptions();
//Configuration Pocos
services.Configure <ApplicationSettings>(Configuration.GetSection("ApplicationSettings"));
services.Configure <EmailSettings>(Configuration.GetSection("EmailSettings"));
services.Configure <LogSettings>(Configuration.GetSection("LogSettings"));
//Add custom services
services.AddTransient <IEmailService, EmailService>();
services.AddSingleton <IFileService, FileService>();
services.AddLogging();
// In production, the Angular files will be served from this directory
services.AddSpaStaticFiles(configuration => { configuration.RootPath = "ClientApp/dist"; });
}
/// <summary>
/// Configures the input and output formatters.
/// </summary>
private static void ConfigureFormatters(IMvcBuilder mvcBuilder)
{
// The JSON input and output formatters are added to MVC by default.
// $Start-JsonSerializerSettings$
// Configures the JSON output formatter to use camel case property names like 'propertyName' instead of
// pascal case 'PropertyName' as this is the more common JavaScript/JSON style.
mvcBuilder.AddJsonOptions(
x => x.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver());
// $End-JsonSerializerSettings$
// $Start-BsonFormatter$
// $End-BsonFormatter$
// $Start-XmlFormatter-DataContractSerializer$
// Adds the XML input and output formatter using the DataContractSerializer.
mvcBuilder.AddXmlDataContractSerializerFormatters();
// $End-XmlFormatter-DataContractSerializer$
// $Start-XmlFormatter-XmlSerializer$
// Adds the XML input and output formatter using the XmlSerializer.
mvcBuilder.AddXmlSerializerFormatters();
// $End-XmlFormatter-XmlSerializer$
}
public static IMvcBuilder AddDelve(this IMvcBuilder mvcBuilder, Action <DelveOptions> options = null)
{
var option = new DelveOptions();
options?.Invoke(option);
ResourceParameterOptions.ApplyConfig(option);
//Adds UrlHelper services to mvc app
mvcBuilder.Services.AddSingleton <IActionContextAccessor, ActionContextAccessor>();
mvcBuilder.Services.AddScoped <IUrlHelper, UrlHelper>(factory =>
new UrlHelper(factory.GetService <IActionContextAccessor>().ActionContext));
//Adds IResourceParameter<T> ModelBinding and ModelState validator
mvcBuilder.AddMvcOptions(opt =>
{
opt.ModelBinderProviders.Insert(0, new ResourceParamBinderProvider());
opt.Filters.Add(new ModelStateValidator());
});
//Ignores CiruclarReference checking in json.net
mvcBuilder.AddJsonOptions(opt => {
opt.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
});
return(mvcBuilder);
}
public static IMvcBuilder AddMetaflow(this IMvcBuilder builder,
ICollection <Type> resourceTypes)
{
builder
.AddJsonOptions(options => options.JsonSerializerOptions.Configure())
.ConfigureApplicationPartManager(apm =>
{
apm.FeatureProviders.Add(new GrainControllerFeatureProvider(resourceTypes));
});
builder.AddJsonOptions(o =>
{
o.JsonSerializerOptions.AddMaybeConverter();
});
return(builder);
}
/// <summary>
/// add Json default serializations settings
/// </summary>
/// <param name="mvcBuilder"></param>
public static void AddJsonDefaultOptions(this IMvcBuilder mvcBuilder)
{
mvcBuilder.AddJsonOptions(options =>
{
options.SerializerSettings.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter());
options.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
});
}
public static void Configure(IMvcBuilder mvcBuilder)
{
mvcBuilder.AddJsonOptions(options =>
{
options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
options.SerializerSettings.Formatting = Formatting.Indented;
});
}
public static IMvcBuilder AddJsonOptions(this IMvcBuilder builder)
{
return(builder.AddJsonOptions(opt =>
{
opt.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
opt.JsonSerializerOptions.IgnoreNullValues = true;
}));
}
/// <summary>
/// Use a preffered json format setting(eg: format date at yyyy-MM-dd HH:mm:ss & ignore loop reference & so on)
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IMvcBuilder UsePrefferedJsonSettings(this IMvcBuilder builder)
{
builder.AddJsonOptions(jsonOptions =>
{
jsonOptions.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
});
return(builder);
}
/// <summary>
/// Configures the input and output formatters.
/// </summary>
private static void ConfigureFormatters(IMvcBuilder mvcBuilder)
{
// The JSON input and output formatters are added to MVC by default.
// Configures the JSON output formatter to use camel case property names like 'propertyName' instead of
// pascal case 'PropertyName' as this is the more common JavaScript/JSON style.
mvcBuilder.AddJsonOptions(x => x.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver());
}
/// <summary>
/// Setups the json options.
/// </summary>
/// <param name="mvcBuilder">The MVC builder.</param>
public static void SetupJsonOptions(this IMvcBuilder mvcBuilder)
{
mvcBuilder.AddJsonOptions(options =>
{
options.SerializerSettings.Converters.Add(new StringEnumConverter());
options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
});
}
/// <summary>
/// 注册MVC服务
/// </summary>
/// <param name="services"></param>
private void AddGobalMvc(IServiceCollection services)
{
IMvcBuilder mvcBuilder = services.AddMvc();
//Csv
var csvFormatterOptions = new CsvFormatterOptions();
mvcBuilder.AddMvcOptions(options =>
{
options.Filters.AddService(typeof(HandlerExceptionFilter));
options.InputFormatters.Add(new CsvInputFormatter(csvFormatterOptions));
options.OutputFormatters.Add(new CsvOutputFormatter(csvFormatterOptions));
options.FormatterMappings.SetMediaTypeMappingForFormat("csv", MediaTypeHeaderValue.Parse("text/csv"));
options.RespectBrowserAcceptHeader = true;
options.InputFormatters.Add(new XmlSerializerInputFormatter());
options.OutputFormatters.Add(new XmlSerializerOutputFormatter());
});
// Force Camel Case to JSON
mvcBuilder.AddJsonOptions(opts =>
{
opts.SerializerSettings.ContractResolver = new BaseContractResolver();
opts.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
opts.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
opts.SerializerSettings.Converters.Add(new TimeSpanConverter());
opts.SerializerSettings.Converters.Add(new GuidConverter());
opts.SerializerSettings.Formatting = Formatting.None;
});
//foreach (var module in ExtensionManager.Modules)
// // Register controller from modules
// mvcBuilder.AddApplicationPart(module.Assembly);
mvcBuilder.AddRazorOptions(
o =>
{
foreach (Assembly assembly in ExtensionManager.Assemblies)
{
o.FileProviders.Add(new EmbeddedFileProvider(assembly, assembly.GetName().Name));
}
foreach (var module in ExtensionManager.Modules)
{
o.AdditionalCompilationReferences.Add(MetadataReference.CreateFromFile(module.Assembly.Location));
}
}
).AddViewLocalization()
.AddDataAnnotationsLocalization();
foreach (Action <IMvcBuilder> prioritizedAddMvcAction in GetPrioritizedAddMvcActions())
{
this.logger.LogInformation("Executing prioritized AddMvc action '{0}' of {1}", GetActionMethodInfo(prioritizedAddMvcAction));
prioritizedAddMvcAction(mvcBuilder);
}
//注册模块FluentValidation验证
foreach (ModuleInfo moduleInfo in ExtensionManager.Modules)
{
mvcBuilder.AddFluentValidation(fv => fv.RegisterValidatorsFromAssembly(moduleInfo.Assembly));
}
}
/// <summary>
/// Configurações de serialização json
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IMvcBuilder AddCustomJsonOptions(this IMvcBuilder builder)
{
builder.AddJsonOptions(options =>
{
options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
});
return(builder);
}
public static IMvcBuilder AddJsonConfiguration(this IMvcBuilder builder)
{
builder.AddJsonOptions(options =>
{
options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
});
return(builder);
}
public static void ConfigureJsonSerializerSettings(this IMvcBuilder mvcBuilder)
{
mvcBuilder
.AddJsonOptions(opt =>
{
opt.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
opt.SerializerSettings.DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc;
});
}
/// <summary>
/// configuration of JSON response
/// </summary>
/// <param name="mvcBuilder"></param>
public static IMvcBuilder ConfigureJsonResponse(this IMvcBuilder mvcBuilder)
{
mvcBuilder.AddJsonOptions(options =>
{
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
});
return(mvcBuilder);
}
public virtual void MvcJsonOptions(IMvcBuilder mvcBuilder)
{
_mvcBuilder
.AddJsonOptions(options =>
{
options.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
});
}
public static IMvcBuilder AddMySerializers(this IMvcBuilder mvc)
{
mvc.AddJsonOptions(options =>
{
ConfigureJson(options.SerializerSettings, TypeNameHandling.None);
});
return(mvc);
}
public static IMvcBuilder AddDxSampleModelJsonOptions(this IMvcBuilder builder, Action <JsonResolver> setupAction = null)
{
return(builder.AddJsonOptions(opt => {
var resolver = new JsonResolver();
opt.SerializerSettings.ContractResolver = resolver;
opt.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
setupAction?.Invoke(resolver);
}));
}
