用api开发的人都知道,常用的后台接收参数就是建个dto,然后前台把这个dto传过来。后台再更新,例如如下例子:

public async task<iactionresult> putmodel(dto model)
{
  _context.entry(model).state = entitystate.modified;
  var result = await _context.savechangesasync().configureawait(false);
  return ok("修改实体成功!");
}

这样做后台是很方便,可是ef全部更新效率实在太低,而且没必要,而且前台就需要把所有的dto对象都传过来,如果有不想要修改的怎么办?好吧。用ef的

  _context.entry(model).property(m => m.field1).ismodified = false;
  _context.entry(model).property(m => m.field2).ismodified = false;

如果一个表中有50个字段,有20个需要更新,30个不需要更新,难道写30个_context.entry(model).property(m => m.field1).ismodified = false;这样的语句?或者写20个_context.entry(model).property(m => m.field2).ismodified = true;这样的语句?这样开发效率实在太低。。好吧。还有方法2,针对每个表需要修改的部分都建不同的dto,再用model.field1=dto.field1,  这要去对每个修改的对象都赋值再更改,如果有一百张表呢?那岂不是要建一百个dto,,我的天,那多累,程序猿无疑是最懒的,如果换作你,你愿意花时间建100个dto吗?换作我是的话,我肯定不愿意。有没有更捷径的方法呢?肯定有,那就是用动态传参[dynamic],这样后台就不需要针对每个要修改的表都建dto,前台也不需要把表所有的字段都传过来,只需要传页面表单有的字段,也就是修改过的字段,灵活性大大提高,而且提高了开发效率。好了,不废话了。开始正题。

由于dynamic不支持跨域,首先要解决跨域问题,在startup.cs文件里添加如下代码

    public void configureservices(iservicecollection services)
        {
            //跨域设置
            services.addcors(options =>
            {
                options.addpolicy("allow_all", builder =>
                {
                    builder.allowanymethod().allowanyheader().allowanyorigin();//允许所有域名访问
            //builder.withorigins("http://localhost:8088").allowanyheader();//允许指定域名访问
                });
            });
     }

    public void configure(iapplicationbuilder app, iwebhostenvironment env, ihttpcontextaccessor httpcontextaccessor)
        {
            app.usecors("allow_all");
        }

跨域问题解决之后,添加动态修改数据库的方法。

using microsoft.aspnetcore.mvc;
using microsoft.entityframeworkcore;
using newtonsoft.json;
using system;
using system.collections.generic;
using system.componentmodel.dataannotations;
using system.linq;
using system.reflection;
namespace asp.net.core.ef
{
/// <summary>页面基类</summary>
public class pagebase : controllerbase
{
/// <summary>数据连接</summary>
protected readonly dbcontext _context;//方式1
/// <summary>构造函数 初始化数据库连接</summary>
/// <param name="context">数据连接</param>
public pagebase(dbcontext context)
{
_context = context;
}
/// <summary>
/// 更新指定实体
/// </summary>
/// <typeparam name="t">数据表实体model模型</typeparam>
/// <param name="modelnew">动态json数据</param>
protected virtual void update<t>(dynamic modelnew)
{
//序列化动态json为字符串
string json = modelnew.tostring();
//反序列化为数据表中的实体对象
t model = jsonconvert.deserializeobject<t>(json);
//把状态全部变为不可更改
_context.entry(model).state = entitystate.unchanged;
//反序列化为动态对象中的属性
var jsonmodel = jsonconvert.deserializeobject<dynamic>(json);
//定义一个list来添加属性
list<string> listname = new list<string>();
//动态添加要修改的字段
foreach (propertyinfo info in model.gettype().getproperties())
{
//如果ef表中有实体对象,则排除,否则更新会报错,保留枚举
if ((info.propertytype.isclass && info.propertytype == typeof(string)) || info.propertytype.isclass == false)
{
//解决大小写问题
foreach (var property in jsonmodel)
{
if (info.name.tolower().trim() == property.name.tolower().trim())
{
listname.add(info.name);
}
}
}
}
//转换要修改的字段为数组
string[] pronames = string.join(",", listname).split(",");
//寻找主键
propertyinfo pkprop = typeof(t).getproperties().where(p => p.getcustomattributes(typeof(keyattribute), false).length > 0).firstordefault();
//遍历修改,并排除主键
foreach (string name in pronames)
{
if (name.tolower() != pkprop.name.tolower())
{
_context.entry(model).property(name).ismodified = true;
}
}
//return db.savechanges();
}
/// <summary>
/// 更新指定实体,不更新指定字段
/// </summary>
/// <typeparam name="t">数据表实体model模型</typeparam>
/// <param name="modelnew">动态json数据</param>
/// <param name="fieldpronames">不更新的字段列表数组</param>
protected virtual void update<t>(dynamic modelnew, string fieldpronames)
{
//序列化动态json为字符串
string json = modelnew.tostring();
//反序列化为数据表中的实体对象
t model = jsonconvert.deserializeobject<t>(json);
//把状态全部变为不可更改
_context.entry(model).state = entitystate.unchanged;
//反序列化为动态对象中的属性
var jsonmodel = jsonconvert.deserializeobject<dynamic>(json);
//定义一个list来添加属性
list<string> listname = new list<string>();
//动态添加要修改的字段
foreach (propertyinfo info in model.gettype().getproperties())
{
//如果ef表中有实体对象,则排除,否则更新会报错,保留枚举
if ((info.propertytype.isclass && info.propertytype == typeof(string)) || info.propertytype.isclass == false)
{
//解决大小写问题
foreach (var property in jsonmodel)
{
if (info.name.tolower().trim() == property.name.tolower().trim())
{
listname.add(info.name);
}
}
}
}
//转换要修改的字段为数组
string[] pronames = string.join(",", listname).split(",");
//寻找主键
propertyinfo pkprop = typeof(t).getproperties().where(p => p.getcustomattributes(typeof(keyattribute), false).length > 0).firstordefault();
//遍历修改,并排除主键
foreach (string name in pronames)
{
if (name.tolower() != pkprop.name.tolower() && !fieldpronames.split(",").select(n => n.tolower()).contains(name.tolower()))
{
_context.entry(model).property(name).ismodified = true;
}
}
//return db.savechanges();
}
/// <summary>
/// 更新指定实体,不更新指定字段,如果每个表中有相同不更新的字段,可以这样写
/// </summary>
/// <typeparam name="t">数据表实体model模型</typeparam>
/// <param name="modelnew">动态json数据</param>
protected virtual void updatespecify<t>(dynamic modelnew)
{
//序列化动态json为字符串
string json = modelnew.tostring();
//反序列化为数据表中的实体对象
t model = jsonconvert.deserializeobject<t>(json);
//把状态全部变为不可更改
_context.entry(model).state = entitystate.unchanged;
//反序列化为动态对象中的属性
var jsonmodel = jsonconvert.deserializeobject<dynamic>(json);
//定义一个list来添加属性
list<string> listname = new list<string>();
//定义不需要更新的字段
string fieldpronames = "field1,field2,field3,createdate,creator,isdel,updator,updatedate";
//动态添加要修改的字段
foreach (propertyinfo info in model.gettype().getproperties())
{
//如果ef表中有实体对象,则排除,否则更新会报错,保留枚举
if ((info.propertytype.isclass && info.propertytype == typeof(string)) || info.propertytype.isclass == false)
{
//解决大小写问题
foreach (var property in jsonmodel && !fieldpronames.split(",").select(n => n.tolower()).contains(info.name.tolower()))
{
if (info.name.tolower().trim() == property.name.tolower().trim())
{
listname.add(info.name);
}
}
}
}
//转换要修改的字段为数组
string[] pronames = string.join(",", listname).split(",");
//寻找主键
propertyinfo pkprop = typeof(t).getproperties().where(p => p.getcustomattributes(typeof(keyattribute), false).length > 0).firstordefault();
//遍历修改,并排除主键
foreach (string name in pronames)
{
if (name.tolower() != pkprop.name.tolower())
{
_context.entry(model).property(name).ismodified = true;
}
}
//return db.savechanges();
}
/// <summary>
/// 更新指定实体,不更新指定字段,如果每个表中有相同不更新的字段,可以这样写,扩展方法
/// </summary>
/// <typeparam name="t">数据表实体model模型</typeparam>
/// <param name="modelnew">动态json数据</param>
/// <param name="fieldpronames">不更新的字段列表数组</param>
protected virtual void updatespecify<t>(dynamic modelnew, string fieldpronames)
{
//序列化动态json为字符串
string json = modelnew.tostring();
//反序列化为数据表中的实体对象
t model = jsonconvert.deserializeobject<t>(json);
//把状态全部变为不可更改
_context.entry(model).state = entitystate.unchanged;
//反序列化为动态对象中的属性
var jsonmodel = jsonconvert.deserializeobject<dynamic>(json);
//定义一个list来添加属性
list<string> listname = new list<string>();
//定义不需要更新的字段
string fieldpronameses = "field1,field2,field3,createdate,creator,isdel,updator,updatedate," + fieldpronames;
//动态添加要修改的字段
foreach (propertyinfo info in model.gettype().getproperties())
{
//如果ef表中有实体对象,则排除,否则更新会报错,保留枚举
if ((info.propertytype.isclass && info.propertytype == typeof(string)) || info.propertytype.isclass == false)
{
//解决大小写问题
foreach (var property in jsonmodel && !fieldpronameses.split(",").select(n => n.tolower()).contains(info.name.tolower()))
{
if (info.name.tolower().trim() == property.name.tolower().trim())
{
listname.add(info.name);
}
}
}
}
//转换要修改的字段为数组
string[] pronames = string.join(",", listname).split(",");
//寻找主键
propertyinfo pkprop = typeof(t).getproperties().where(p => p.getcustomattributes(typeof(keyattribute), false).length > 0).firstordefault();
//遍历修改,并排除主键
foreach (string name in pronames)
{
if (name.tolower() != pkprop.name.tolower())
{
_context.entry(model).property(name).ismodified = true;
}
}
//return db.savechanges();
}
}
}

利用泛型+反射 添加动态修改数据表的方法完成之后去测试吧。新建个controller

using microsoft.aspnetcore.mvc;
using system.threading.tasks;
namespace asp.net.core.ef
{
/// <summary>测试修改控制器</summary>
[route("api/[controller]")]
[apicontroller]
public class democontroller : pagebase
{
/// <summary>构造函数</summary>
/// <param name="context">依赖注入数据库连接sql</param>
public democontroller(dbcontext context) : base(context)
{
}
/// <summary>测试修改数据</summary>
/// <param name="modelmodify">动态修改的json实体</param>
/// <returns></returns>
[httpput]
public async task<iactionresult> putmodel(dynamic modelmodify)
{
update<membermodel>(modelmodify);
update<membermodel>(modelmodify, "testfield1,testfield2,testfield3");
updatespecify<membermodel>(modelmodify);
updatespecify<membermodel>(modelmodify, "testfield1,testfield2,testfield3");
return ok("修改成功,请查询数据库");
}
}
}

前端测试json数据

{
"id": 1,
"testfield1": "demo1",
"testfield2": "demo2",
"testfield3": "demo3",
}

好了,完功,这样后端开发就很舒服了,可以说轻松加愉快,对于前端也很舒服!解脱了很多时间!!