Asp.Net Core实战(干货)

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

序言

使用.NET Core，团队可以更容易专注的在.net core上工作。比如核心类库（如System.Collections）的更改仍然需要与.NET Framework相同的活力，但是ASP.NET Core或Entity Framework Core可以更轻松地进行实质性更改，而不受向后兼容性的限制。.NET Core借鉴了.NET Framework的最佳实践，并将软件工程的最新进展结合在一起。

寒暄、扯淡已经完毕，，，下面是我最近时间对.Net Core整理的相关知识，觉得这些在项目中是最基础且最会应用到的，，，，不喜欢扯理论，直接撸码：

1、浅谈Startup类

2、自定义路由

3、跨域设置

4、自定义读取配置文件信息

5、程序集批量依赖注入

6、使用NLog写入文件日志

7、使用NLog写入数据库日志

8、Nlog标签解读

9、启用Session

10、json数据，自定义日期格式

11、json数据，string类型字段返回为null时默认返回空字符串

12、Json数据，返回字段同实体字段大小写一致

一、浅谈Startup类

在ASP.NET Core应用程序中，使用一个按约定 Startup 命名的类 Startup ，在Program.cs中使用WebHostBuilderExtensionsUseStartup <TStartup>方法指定类，但通常使用系统默认的startup，可以通过startup的构造函数进行依赖注入，startup类中必须包含Configure方法同时可以根据实际情况添加ConfigureServices方法，这两个方法均在应用程序运行时被调用。Startup 类的执行顺序：构造 -> configureServices ->configure

ConfigureServices方法：主要用于服务配置，比如依赖注入(DI)的配置，使用时该方法必须在Configure方法之前

Configure方法：用于应用程序响应HTTP请求，通过向IApplicationBuilder实例添加中间件组件来配置请求管道

二、自定义路由

在Startup类的Configure方法配置

public void Configure(IApplicationBuilder app, IHostingEnvironment env)

        {

            if (env.IsDevelopment())

            {

                app.UseDeveloperExceptionPage();

            }

            #region 自定义路由配置

            app.UseMvc(routes =>

            {

                // 自定义路由

                routes.MapRoute(

                  name: "default1",

                  template: "api/{controller}/{action}/{id?}",

                  defaults: new { controller = "Values", action = "Index" });

                // 默认路由

                routes.MapRoute(

                   name: "default",

                   template: "{controller}/{action}/{id?}",

                   defaults: new { controller = "Values", action = "Index" });

            });

            #endregion

        }

三、跨域设置

在Startup类的ConfigureServices方法配置

public void ConfigureServices(IServiceCollection services)

        {

            #region 跨域设置

            services.AddCors(options =>

            {

                options.AddPolicy("AppDomain", builder =>

                {

                    builder.AllowAnyOrigin() // Allow access to any source from the host

                    .AllowAnyMethod()        // Ensures that the policy allows any method

                    .AllowAnyHeader()        // Ensures that the policy allows any header

                    .AllowCredentials();     // Specify the processing of cookie

                });

            });

            #endregion

            services.AddMvc();

        }

其中“AppDomain”这个名字是自定义的，大家可以根据自己的喜好定义不同的名字，配置完成之后，在控制器上面添加[EnableCors("AppDomain")]特性即可，如果要实现全局的跨域设置，可以在Configure方法里面配置app.UseCors("AppDomain")，即能实现全局的跨域设置

四、自定义读取配置文件信息

这里是写的一个公共方法去读取配置文件appsettings.json

using Microsoft.Extensions.Configuration;

using Microsoft.Extensions.Configuration.Json;

using Microsoft.Extensions.DependencyInjection;

using Microsoft.Extensions.Options;

using System.IO;

public class JsonConfigurationHelper

    {

        public static T GetAppSettings<T>(string key,string path= "appsettings.json") where T : class, new()

        {

            var currentClassDir = Directory.GetCurrentDirectory();

            IConfiguration config = new ConfigurationBuilder()

                .SetBasePath(currentClassDir)

                .Add(new JsonConfigurationSource { Path = path, Optional = false, ReloadOnChange = true })

                .Build();

            var appconfig = new ServiceCollection()

                .AddOptions()

                .Configure<T>(config.GetSection(key))

                .BuildServiceProvider()

                .GetService<IOptions<T>>()

                .Value;

            return appconfig;

        }

    }

/// <summary>

        /// 读取配置文件

        /// </summary>

        /// <returns></returns>

        [HttpGet]

        public dynamic JsonConfig()

        {

            var jsonStr = JsonConfigurationHelper.GetAppSettings<ConfigDTO>("config");

            return Ok(jsonStr);

        }

        /// <summary>

        /// 实体类

        /// </summary>

        public class ConfigDTO

        {

            public dynamic name { get; set; }

        }

{

  "config": {

    "name": "Core.Api"

  }

}

截图看效果

五、程序集批量依赖注入

我们都知道依赖注入主要是为了方便解耦，解除应用程序之间的依赖关系，在我看来DI、IOC这两者差不多是一样的，DI是从应用程序的角度而IOC是从容器的角度，它们主要是对同一件事情的不同角度的描述。然而，，，，，，当我们项目业务比较多的时候，如果要实现多个业务的注入，通常方法是手动一个个的添加注入，这样可能有点太繁琐，所以就想到了利用反射实现批量注入，，，，，，

方法一

帮助类

public class RuntimeHelper

    {

        /// <summary>

        /// 获取项目程序集，排除所有的系统程序集(Microsoft.***、System.***等)、Nuget下载包

        /// </summary>

        /// <returns></returns>

        public static IList<Assembly> GetAllAssemblies()

        {

            var list = new List<Assembly>();

            var deps = DependencyContext.Default;

            var libs = deps.CompileLibraries.Where(lib => !lib.Serviceable && lib.Type != "package");//排除所有的系统程序集、Nuget下载包

            foreach (var lib in libs)

            {

                try

                {

                    var assembly = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(lib.Name));

                    list.Add(assembly);

                }

                catch (Exception)

                {

                    // ignored

                }

            }

            return list;

        }

        public static Assembly GetAssembly(string assemblyName)

        {

            return GetAllAssemblies().FirstOrDefault(assembly => assembly.FullName.Contains(assemblyName));

        }

        public static IList<Type> GetAllTypes()

        {

            var list = new List<Type>();

            foreach (var assembly in GetAllAssemblies())

            {

                var typeInfos = assembly.DefinedTypes;

                foreach (var typeInfo in typeInfos)

                {

                    list.Add(typeInfo.AsType());

                }

            }

            return list;

        }

        public static IList<Type> GetTypesByAssembly(string assemblyName)

        {

            var list = new List<Type>();

            var assembly = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(assemblyName));

            var typeInfos = assembly.DefinedTypes;

            foreach (var typeInfo in typeInfos)

            {

                list.Add(typeInfo.AsType());

            }

            return list;

        }

        public static Type GetImplementType(string typeName, Type baseInterfaceType)

        {

            return GetAllTypes().FirstOrDefault(t =>

            {

                if (t.Name == typeName &&

                    t.GetTypeInfo().GetInterfaces().Any(b => b.Name == baseInterfaceType.Name))

                {

                    var typeInfo = t.GetTypeInfo();

                    return typeInfo.IsClass && !typeInfo.IsAbstract && !typeInfo.IsGenericType;

                }

                return false;

            });

        }

    }

public static class ServiceExtension

    {

        /// <summary>

        /// 用DI批量注入接口程序集中对应的实现类。

        /// </summary>

        /// <param name="service"></param>

        /// <param name="interfaceAssemblyName"></param>

        /// <returns></returns>

        public static IServiceCollection RegisterAssembly(this IServiceCollection service, string interfaceAssemblyName)

        {

            if (service == null)

                throw new ArgumentNullException(nameof(service));

            if (string.IsNullOrEmpty(interfaceAssemblyName))

                throw new ArgumentNullException(nameof(interfaceAssemblyName));

            var assembly = RuntimeHelper.GetAssembly(interfaceAssemblyName);

            if (assembly == null)

            {

                throw new DllNotFoundException($"the dll \"{interfaceAssemblyName}\" not be found");

            }

            //过滤掉非接口及泛型接口

            var types = assembly.GetTypes().Where(t => t.GetTypeInfo().IsInterface && !t.GetTypeInfo().IsGenericType);

            foreach (var type in types)

            {

                var implementTypeName = type.Name.Substring();

                var implementType = RuntimeHelper.GetImplementType(implementTypeName, type);

                if (implementType != null)

                    service.AddSingleton(type, implementType);

            }

            return service;

        }

        /// <summary>

        /// 用DI批量注入接口程序集中对应的实现类。

        /// </summary>

        /// <param name="service"></param>

        /// <param name="interfaceAssemblyName">接口程序集的名称（不包含文件扩展名）</param>

        /// <param name="implementAssemblyName">实现程序集的名称（不包含文件扩展名）</param>

        /// <returns></returns>

        public static IServiceCollection RegisterAssembly(this IServiceCollection service, string interfaceAssemblyName, string implementAssemblyName)

        {

            if (service == null)

                throw new ArgumentNullException(nameof(service));

            if (string.IsNullOrEmpty(interfaceAssemblyName))

                throw new ArgumentNullException(nameof(interfaceAssemblyName));

            if (string.IsNullOrEmpty(implementAssemblyName))

                throw new ArgumentNullException(nameof(implementAssemblyName));

            var interfaceAssembly = RuntimeHelper.GetAssembly(interfaceAssemblyName);

            if (interfaceAssembly == null)

            {

                throw new DllNotFoundException($"the dll \"{interfaceAssemblyName}\" not be found");

            }

            var implementAssembly = RuntimeHelper.GetAssembly(implementAssemblyName);

            if (implementAssembly == null)

            {

                throw new DllNotFoundException($"the dll \"{implementAssemblyName}\" not be found");

            }

            //过滤掉非接口及泛型接口

            var types = interfaceAssembly.GetTypes().Where(t => t.GetTypeInfo().IsInterface && !t.GetTypeInfo().IsGenericType);

            foreach (var type in types)

            {

                //过滤掉抽象类、泛型类以及非class

                var implementType = implementAssembly.DefinedTypes

                    .FirstOrDefault(t => t.IsClass && !t.IsAbstract && !t.IsGenericType &&

                                         t.GetInterfaces().Any(b => b.Name == type.Name));

                if (implementType != null)

                {

                    service.AddSingleton(type, implementType.AsType());

                }

            }

            return service;

        }

    }

在Startupl类的ConfigureServices方法中添加

// This method gets called by the runtime. Use this method to add services to the container.

        public void ConfigureServices(IServiceCollection services)

        {

            #region 程序集批量依赖注入

            services.RegisterAssembly("Core.BLL");

            #endregion

            services.AddMvc();

        }

调用(Ps:Core.BLL这个类库里面分别有一个接口IAccountService和一个类AccountService，AccountService类去继承接口IAccountService并实现接口里面的方法)

public interface IAccountService

    {

        int GetLst();

    }

public class AccountService: IAccountService

    {

        public int GetLst()

        {

            return ;

        }

    }

public class ValuesController : Controller

    {

        private readonly IAccountService _accountService;

        public ValuesController(IAccountService accountService)

        {

            _accountService = accountService;

        }

        [HttpGet]

        public dynamic GetAccount()

        {

            var result = this._accountService.GetLst();

            return Ok();

        }

}

方法二

public static class InjectionExtension

    {

        /// <summary>

        /// 批量注入接口程序集中对应的实现类(接口和实现类在同一个程序集时)

        /// </summary>

        /// <param name="services">services</param>

        /// <param name="assemblyName">程序集名称</param>

        public static void BatchAddScoped(this IServiceCollection services, string assemblyName)

        {

            if (services == null)

                throw new ArgumentNullException(nameof(services));

            if (assemblyName == null)

                throw new ArgumentNullException(nameof(assemblyName));

            // 排除所有的系统程序集，Nuget下载包

            var libs = DependencyContext.Default.CompileLibraries.Where(lib => !lib.Serviceable && lib.Type != "package");

            var serviceLib = libs.Where(c => c.Name.Contains(assemblyName)).FirstOrDefault();

            var assembly = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(serviceLib.Name));

            var serviceClassList = assembly.GetTypes().Where(x=>x.IsInterface).ToList();

            foreach (var item in serviceClassList)

            {

                var implementName = item.Name.Substring(,item.Name.Length-);

                var implementType= assembly.GetTypes().Where(c => c.IsClass && c.Name == implementName).FirstOrDefault();

                if (implementType == null) continue;

                services.AddScoped(item, implementType);

            }

        }

        /// <summary>

        /// 批量注入接口程序集中对应的实现类(接口和实现类在不同程序集时)

        /// </summary>

        /// <param name="services"></param>

        /// <param name="interfaceAssemblyName"></param>

        /// <param name="implementAssemblyName"></param>

        public static void BatchAddScoped(this IServiceCollection services, string interfaceAssemblyName, string implementAssemblyName)

        {

            if (services == null)

                throw new ArgumentNullException(nameof(services));

            if (string.IsNullOrEmpty(interfaceAssemblyName))

                throw new ArgumentNullException(nameof(interfaceAssemblyName));

            if (string.IsNullOrEmpty(implementAssemblyName))

                throw new ArgumentNullException(nameof(implementAssemblyName));

            // 排除所有的系统程序集，Nuget下载包

            var libs = DependencyContext.Default.CompileLibraries.Where(lib => !lib.Serviceable && lib.Type != "package");

            var serviceInterfaceLib = libs.Where(c => c.Name.Contains(interfaceAssemblyName)).FirstOrDefault();

            var interfaceAssembly = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(serviceInterfaceLib.Name));

            // 过滤非接口

            var serviceInterfaceList = interfaceAssembly.GetTypes().Where(x => x.IsInterface).ToList();

            var serviceImplementLib = libs.Where(c => c.Name.Contains(implementAssemblyName)).FirstOrDefault();

            var implementAssembly = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(serviceImplementLib.Name));

            // 过滤抽象类、泛型类以及非class

            foreach (var item in serviceInterfaceList)

            {

                var implementName = item.Name.Substring(, item.Name.Length - );

                var implementType = implementAssembly.GetTypes().Where(c => c.IsClass && c.Name == implementName).FirstOrDefault();

                if (implementType == null) continue;

                services.AddScoped(item, implementType);

            }

        }

    }

public void ConfigureServices(IServiceCollection services)

        {

            #region 程序集批量依赖注入

            services.BatchAddScoped("Core.BLL");  // 接口和实现类在同一个程序集

            services.BatchAddScoped("Core.Model", "Core.BLL");// 接口和实现类在不同程序集

            #endregion

        }

六、使用NLog写入文件日志

新建配置文件命名为Nlog.config

<?xml version="1.0" encoding="utf-8" ?>

<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <targets>

<!--写入文件-->

    <target

     xsi:type="File"

     name="DebugFile"

     fileName="Logs\Debug\${shortdate}.log"

     layout="日志时间：${longdate}${newline}日志来源：${callsite}${newline}日志级别：${uppercase:${level}}${newline}消息内容：${message}${newline}异常信息：${exception}${newline}==============================================================${newline}" >

    </target>

    <target

      xsi:type="File"

      name="InfoFile"

      fileName="Logs\Info\${shortdate}.log"

      layout="日志时间：${longdate}${newline}日志来源：${callsite}${newline}日志级别：${uppercase:${level}}${newline}消息内容：${message}${newline}异常信息：${exception}${newline}==============================================================${newline}" >

    </target>

    <target

      xsi:type="File"

      name="ErrorFile"

      fileName="Logs\Error\${shortdate}.log"

      layout="日志时间：${longdate}${newline}日志来源：${callsite}${newline}日志级别：${uppercase:${level}}${newline}消息内容：${message}${newline}异常信息：${exception}${newline}==============================================================${newline}" >

    </target>    

  <rules>

    <logger name="FileLogger" minlevel="Debug" maxLevel="Debug" writeTo="DebugFile" />

    <logger name="FileLogger" minlevel="Info" maxLevel="Info" writeTo="InfoFile" />

    <logger name="FileLogger" minlevel="Error" maxLevel="Error" writeTo="ErrorFile" />

  </rules>

</nlog>

在Startup类Configure方法中添加配置

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)

        {

            if (env.IsDevelopment())

            {

                app.UseDeveloperExceptionPage();

            }

            #region NLog配置

            loggerFactory.AddNLog(); // 添加NLog

            loggerFactory.ConfigureNLog($"{Directory.GetCurrentDirectory()}\\Nlog.config"); // 添加Nlog.config配置文件

            loggerFactory.AddDebug();

            #endregion

        }

写入日志到文件

public class ValuesController : Controller

    {

        private readonly Logger _logger;

        public ValuesController()

        {

            _logger = LogManager.GetLogger("FileLogger");

        }

        /// <summary>

        /// 写入文件日志

        /// </summary>

        /// <returns></returns>

        [HttpGet]

        public dynamic WriteLogToFile()

        {

            _logger.Info("写入Info文件");

            _logger.Debug("写入Debug文件");

            _logger.Error("写入Error文件");

            return Ok();

        }

}

七、使用NLog写入数据库日志

添加依赖项：Microsoft.Extensions.Logging和NLog.Extensions.Logging

新建配置文件命名为Nlog.config

<?xml version="1.0" encoding="utf-8" ?>

<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <targets>

    <!--写入数据库-->

    <target xsi:type="Database" name="Database"

            connectionString="Data Source=.;Initial Catalog=MyDb;Persist Security Info=True;User ID=sa;Password=123456"

            commandText="insert into NLog_Log([CreateOn],[Origin],[LogLevel], [Message], [Exception],[StackTrace],[Desc]) values (getdate(), @origin, @logLevel, @message,@exception, @stackTrace,@desc)">

      <!--日志来源-->

      <parameter name="@origin" layout="${callsite}"/>

      <!--日志等级-->

      <parameter name="@logLevel" layout="${level}"/>

      <!--日志消息-->

      <parameter name="@message" layout="${message}"/>

      <!--异常信息-->

      <parameter name="@exception" layout="${exception}" />

      <!--堆栈信息-->

      <parameter name="@stackTrace" layout="${stacktrace}"/>

      <!--自定义消息内容-->

      <parameter name="@desc" layout="${event-context:item=Desc}"/>

    </target>

  </targets>

  <rules>

    <logger name="DbLogger" levels="Trace,Debug,Info,Error"  writeTo="Database"/>

  </rules>

</nlog>

同第六项代码一样，也是在Configure方法设置，写入日志到数据库

/// <summary>

        /// 将日志写入数据库

        /// </summary>

        /// <returns></returns>

        [HttpGet]

        public dynamic WriteLogToDb()

        {

            Logger _dblogger = LogManager.GetLogger("DbLogger");

            LogEventInfo ei = new LogEventInfo();

            ei.Properties["Desc"] = "我是自定义消息";

            _dblogger.Info(ei);

            _dblogger.Debug(ei);

            _dblogger.Trace(ei);

            return Ok();

        }

USE [MyDb]

GO

/****** Object:  Table [dbo].[NLog_Log]    Script Date: 08/09/2018 17:13:20 ******/

SET ANSI_NULLS ON

GO

SET QUOTED_IDENTIFIER ON

GO

CREATE TABLE [dbo].[NLog_Log](

    [ID] [int] IDENTITY(1,1) NOT NULL,

    [Origin] [nvarchar](500) NULL,

    [LogLevel] [nvarchar](500) NULL,

    [Message] [nvarchar](500) NULL,

    [Desc] [nvarchar](500) NULL,

    [Exception] [nvarchar](500) NULL,

    [StackTrace] [nvarchar](500) NULL,

    [CreateOn] [datetime] NULL

) ON [PRIMARY]

GO

八、Nlog标签解读

NLog的使用方式基本上和其它的Log库差不多，用于输出日志的级别包括：Trace,Debug,Info,Warn,Error,Fatal

<nlog>标签

autoReload 修改配置文件后是否允许自动加载无须重启程序

throwExceptions 内部日志系统抛出异常

internalLogFile 把内部的调试和异常信息都写入指定文件里

建议throwExceptions的值设为“false”，这样由于日志引发的问题不至于导致应用程序的崩溃。

<targets>标签

<target />区域定义了日志的目标或者说输出，,在这里可以按需设置文件名称和格式，输出方式。

name：自定义该target的名字,可供rule规则里使用

type：定义类型,官方提供的可选类型有:

不过常用的还是 File \Database \Colored Console\ Mail

layouts 用来规定布局样式,语法“${属性}”,可以把上下文信息插入到日志中，更多布局渲染器可参考https://github.com/nlog/NLog/wiki/Layout%20Renderers

<rules>标签

各种规则配置在logger里

name - 记录者的名字

minlevel - 最低级别

maxlevel - 最高级别

level - 单一日志级别

levels - 一系列日志级别，由逗号分隔。

writeTo - 规则匹配时日志应该被写入的一系列目标，由逗号分隔。

九、启用Session

Net Core默认情况下是没有启用Session的，需要在Startup文件ConfigureServices方法配置启动，否则无法使用（需要在UseMvc之前，否则会报错）

public void ConfigureServices(IServiceCollection services)

        {

            // 启用Session

            services.AddSession();

            services.AddMvc();

        }

十、json数据，自定义日期格式

在webapi数据返回中，经常碰到json数据日期带“T”的问题，可以在Startup类ConfigureServices方法中做如下全局配置

public void ConfigureServices(IServiceCollection services)

        {

            services.AddMvc().AddJsonOptions(options =>

               {

                   options.SerializerSettings.DateFormatString = "yyyy-MM-dd HH:mm:ss"; // 日期格式化

               });

        }

十一、json数据，string类型字段返回为null时默认返回空字符串

帮助类

    public sealed class NullWithEmptyStringResolver : DefaultContractResolver

    {

        protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)

        {

            return type.GetProperties()

                       .Select(p =>

                       {

                           var jp = base.CreateProperty(p, memberSerialization);

                           jp.ValueProvider = new NullToEmptyStringValueProvider(p);

                           return jp;

                       }).ToList();

        }

        /// <summary>

        /// 将所有返回字段转换为小写

        /// </summary>

        /// <param name="propertyName"></param>

        /// <returns></returns>

        //protected override string ResolvePropertyName(string propertyName)

        //{

        //    return propertyName.ToLower();

        //}

    }

    public class NullToEmptyStringValueProvider : IValueProvider

    {

        PropertyInfo _MemberInfo;

        public NullToEmptyStringValueProvider(PropertyInfo memberInfo)

        {

            _MemberInfo = memberInfo;

        }

        public object GetValue(object target)

        {

            object result = _MemberInfo.GetValue(target);

            if (result == null)

            {

                var type = _MemberInfo.PropertyType;

                if (type == typeof(string)) result = "";

                //else if (type == typeof(DateTime?))

                //    result = new DateTime(1, 1, 1);

            }

            return result;

        }

        public void SetValue(object target, object value)

        {

            _MemberInfo.SetValue(target, value);

        }

    }

在Startup类ConfigureServices方法中做如下全局配置

public void ConfigureServices(IServiceCollection services)

        {

            services.AddMvc().AddJsonOptions(options =>

               {

                   options.SerializerSettings.Formatting = Formatting.Indented;  // 返回数据格式缩进(按需配置)

                   options.SerializerSettings.ContractResolver = new NullWithEmptyStringResolver();  // 字段为字符串返回为null时，默认返回空

               });

        }

api后台代码

public class ValuesController : Controller

    {

        [HttpGet]

        public dynamic Index()

        {

            List<userinfo> list = new List<userinfo>()

            {

                new userinfo(){ UserName=null }

            };

            return list;

        }

        public class userinfo

        {

            public string UserName { get; set; }

        }

}

配置前和配置之后数据在浏览器中返回效果截图

大家看效果图有没有发现一个问题，我在没有配置时，实体里面的“UserName”字段默认被转换成了小写，这显然不符合我们的要求，当我配置之后就可以返回同实体里面的字段大小写格式一致了，同时为null的字段默认返回了空字符串，是不是美滋滋，，，，

可能有朋友会说，我只想让返回的数据字段同实体的数据字段一致，而字段为null的值依然还是让他返回null，其实这样也可以，看第十二项配置操作即可。

十二、Json数据，返回字段同实体字段大小写一致

在.net core中，webapi返回的数据字段，首字母默认被转换成了小写，在Startup类ConfigureServices方法中配置：

public void ConfigureServices(IServiceCollection services)

        {

            services.AddMvc().AddJsonOptions(options =>

               {

                   options.SerializerSettings.ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver();

               });

        }

public class ValuesController : Controller

    {

        [HttpGet]

        public dynamic Index()

        {

            List<userinfo> list = new List<userinfo>()

            {

                new userinfo(){ UserName=null }

            };

            return list;

        }

        public class userinfo

        {

            public string UserName { get; set; }

        }

}

配置前和配置之后数据在浏览器中返回效果截图

目前只整理了这些，后续会持续更新到这里面，如有不合理的地方，请大家加以斧正，，，希望能和大家共同学习、共同进步，，

权责申明

作者：SportSky 出处： http://www.cnblogs.com/sportsky/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。如果觉得还有帮助的话，可以点一下右下角的【推荐】，希望能够持续的为大家带来好的技术文章！想跟我一起进步么？那就【关注】我吧。