WMS-Api/src/WMS.Web.Repositories/Configuration/DbContextExtensions.cs

using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace WMS.Web.Repositories.Configuration
{
    /// <summary>
    /// db上下文扩展类
    /// </summary>
    public static class DbContextExtensions
    {
        public static IEnumerable<T> SqlQuery<T>(this DatabaseFacade facade, string sql, bool isAlias = false, params object[] parameters) where T : class, new()
        {
            var dt = SqlQuery(facade, sql, parameters);
            if (isAlias)
                return dt.ToEnumerableAlias<T>();
            return dt.ToEnumerable<T>();
        }

        public static async Task<IEnumerable<T>> SqlQueryAsync<T>(this DatabaseFacade facade, string sql, bool isAlias = false, params object[] parameters) where T : class, new()
        {
            return await Task.Run(() =>
            {
                var dt = SqlQuery(facade, sql, parameters);
                if (isAlias)
                    return dt.ToEnumerableAlias<T>();
                return dt.ToEnumerable<T>();
            });
        }

        public static IEnumerable<T> ToEnumerable<T>(this DataTable dt) where T : class, new()
        {
            var propertyInfos = typeof(T).GetProperties();
            var ts = new T[dt.Rows.Count];
            var i = 0;
            foreach (DataRow row in dt.Rows)
            {

                try
                {
                    var t = new T();
                    foreach (var p in propertyInfos)
                        if (dt.Columns.IndexOf(p.Name) != -1 && row[p.Name] != DBNull.Value)
                            p.SetValue(t, row[p.Name], null);

                    ts[i] = t;
                    i++;
                }
                catch (Exception ex)
                {

                    throw ex;
                }


            }

            return ts;
        }

        /// <summary>
        /// 对象属性别名的映射关系
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static IEnumerable<T> ToEnumerableAlias<T>(this DataTable dt) where T : class, new()
        {
            var propertyInfos = typeof(T).GetProperties();
            var ts = new T[dt.Rows.Count];
            var i = 0;
            foreach (DataRow row in dt.Rows)
            {
                var t = new T();
                foreach (var p in propertyInfos)
                {
                    var attrs = p.GetCustomAttributes(typeof(System.ComponentModel.DataAnnotations.Schema.ColumnAttribute), true);
                    if (attrs.Length > 0)
                    {
                        try
                        {
                            var name = ((System.ComponentModel.DataAnnotations.Schema.ColumnAttribute)attrs[0]).Name;
                            if (dt.Columns.IndexOf(name) != -1 && row[name] != DBNull.Value)
                                p.SetValue(t, row[name], null);
                        }
                        catch (Exception ex)
                        {
                            throw ex;
                        }


                    }

                }

                ts[i] = t;
                i++;
            }

            return ts;
        }

        public static DataTable SqlQuery(this DatabaseFacade facade, string sql, params object[] parameters)
        {
            var cmd = CreateCommand(facade, sql, out var conn, parameters);
            var reader = cmd.ExecuteReader();
            var dt = new DataTable();
            dt.Load(reader);
            reader.Close();
            conn.Close();
            return dt;
        }

        private static DbCommand CreateCommand(DatabaseFacade facade, string sql, out DbConnection dbConn, params object[] parameters)
        {
            var conn = facade.GetDbConnection();
            dbConn = conn;
            conn.Open();
            var cmd = conn.CreateCommand();
            if (facade.IsMySql())
            {
                cmd.CommandText = sql;
                CombineParamsMySql(ref cmd, parameters);
            }
            if (facade.IsSqlServer())
            {
                cmd.CommandText = sql;
                CombineParams(ref cmd, parameters);
            }

            return cmd;
        }

        private static void CombineParams(ref DbCommand command, params object[] parameters)
        {
            if (parameters != null)
                foreach (SqlParameter parameter in parameters)
                {
                    if (!parameter.ParameterName.Contains("@"))
                        parameter.ParameterName = $"@{parameter.ParameterName}";
                    command.Parameters.Add(parameter);
                }
        }

        private static void CombineParamsMySql(ref DbCommand command, params object[] parameters)
        {
            if (parameters != null)
                foreach (MySqlConnector.MySqlParameter parameter in parameters)
                {
                    if (!parameter.ParameterName.Contains("@"))
                        parameter.ParameterName = $"@{parameter.ParameterName}";
                    command.Parameters.Add(parameter);
                }
        }

        public static bool ExecuteSqlCommand(this DatabaseFacade facade, string sql, params object[] parameters)
        {
            var cmd = CreateCommand(facade, sql, out var conn, parameters);
            try
            {
                cmd.ExecuteNonQuery();
                return true;
            }
            catch (Exception ex)
            {
                var msg = ex.Message;
                return false;
            }
            finally
            {
                conn.Close();
            }
        }


        public static IQueryable<T> SortBy<T>(this IQueryable<T> source, string sortExpression)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            string sortDirection = String.Empty;
            string propertyName = String.Empty;

            sortExpression = sortExpression.Trim();
            int spaceIndex = sortExpression.Trim().IndexOf(" ");
            if (spaceIndex < 0)
            {
                propertyName = sortExpression;
                sortDirection = "ASC";
            }
            else
            {
                propertyName = sortExpression.Substring(0, spaceIndex);
                sortDirection = sortExpression.Substring(spaceIndex + 1).Trim();
            }

            if (String.IsNullOrEmpty(propertyName))
            {
                return source;
            }

            ParameterExpression parameter = Expression.Parameter(source.ElementType, String.Empty);
            MemberExpression property = Expression.Property(parameter, propertyName);
            LambdaExpression lambda = Expression.Lambda(property, parameter);

            string methodName = (sortDirection == "ASC") ? "OrderBy" : "OrderByDescending";

            Expression methodCallExpression = Expression.Call(typeof(Queryable), methodName,
                                                new Type[] { source.ElementType, property.Type },
                                                source.Expression, Expression.Quote(lambda));

            return source.Provider.CreateQuery<T>(methodCallExpression);
        }
    }
}