宜春网:.net core WebAPI+EF “动态”接收前台json,并动态修改数据库

2020-03-14 28 views 0

扫一扫用手机浏览

用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",
}

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

 

,

sUnbet代理登录

欢迎进入sUnbet代理登录!Sunbet 申博提供申博 开[户(sunbet 开[户)、SunbetAPP「下载」、Sunbet客户端「下载」、Sunbet代理合作等业务。

Sunbet内容转载自互联网,如有侵权,联系Sunbet删除。

本文链接地址:http://www.18hao-soso.com/post/1200.html

相关文章