-之動態查詢,查詢邏輯封裝復用

基於領域驅動設計(DDD)超輕量級快速開發架構詳細介紹請看

https://www.cnblogs.com/neozhu/p/13174234.html

需求

1. 配合EasyUI datagird filter實現多字段(任意字段)的篩選
2. 根據業務需求篩選特定的狀態或條件,如:查看結案的訂單,最近30天的訂單,查看屬於我的訂單.等等,這些邏輯是固定也是可以被重用,但又不想每次寫相同的條件,那麼下面我會給我的解決方案.

需求1隻是一個偷懶的實現方式,因為datagrid自帶這個功能,但又不想根據具體的需求來畫查詢條件,如果需求必須要再datagrid上面做一塊查詢條件的輸入那目前只能在前端自己手工添加,在組織後傳入後台,暫時不在這裏討論

需求2可能不太好解釋,看完代碼就自然理解為什麼要這麼做了,這麼做的好處有哪些

具體實現的方式

 默認情況下 datagrid 有幾列就可以對這幾列進行篩選,對於日期型的字段會採用between,選擇2個時間之間進行篩選,数字類型會提供大於小於等符號選擇,可以自行嘗試,其原理是datagrid 會根據datagrid 頭部輸入的值生成一個Json字符串發送後台請求數據

JSON:格式

filterRules: [
{field:field,op:op,value:value},

{field:field,op:op,value:value},

] 

• 通常的做法是一個一個判斷加條件

  1 var filters = JsonConvert.DeserializeObject<IEnumerable<filterRule>>(filterRules); 
  2 foreach (var rule in filters)
  3         {
  4           if (rule.field == "Id" && !string.IsNullOrEmpty(rule.value) && rule.value.IsInt())
  5           {
  6             var val = Convert.ToInt32(rule.value);
  7             switch (rule.op)
  8             {
  9               case "equal":
 10                 this.And(x => x.Id == val);
 11                 break;
 12               case "notequal":
 13                 this.And(x => x.Id != val);
 14                 break;
 15               case "less":
 16                 this.And(x => x.Id < val);
 17                 break;
 18               case "lessorequal":
 19                 this.And(x => x.Id <= val);
 20                 break;
 21               case "greater":
 22                 this.And(x => x.Id > val);
 23                 break;
 24               case "greaterorequal":
 25                 this.And(x => x.Id >= val);
 26                 break;
 27               default:
 28                 this.And(x => x.Id == val);
 29                 break;
 30             }
 31           }
 32           if (rule.field == "Name" && !string.IsNullOrEmpty(rule.value))
 33           {
 34             this.And(x => x.Name.Contains(rule.value));
 35           }
 36           if (rule.field == "Code" && !string.IsNullOrEmpty(rule.value))
 37           {
 38             this.And(x => x.Code.Contains(rule.value));
 39           }
 40 
 41           if (rule.field == "Address" && !string.IsNullOrEmpty(rule.value))
 42           {
 43             this.And(x => x.Address.Contains(rule.value));
 44           }
 45 
 46           if (rule.field == "Contect" && !string.IsNullOrEmpty(rule.value))
 47           {
 48             this.And(x => x.Contect.Contains(rule.value));
 49           }
 50 
 51           if (rule.field == "PhoneNumber" && !string.IsNullOrEmpty(rule.value))
 52           {
 53             this.And(x => x.PhoneNumber.Contains(rule.value));
 54           }
 55 
 56           if (rule.field == "RegisterDate" && !string.IsNullOrEmpty(rule.value))
 57           {
 58             if (rule.op == "between")
 59             {
 60               var datearray = rule.value.Split(new char[] { '-' });
 61               var start = Convert.ToDateTime(datearray[0]);
 62               var end = Convert.ToDateTime(datearray[1]);
 63 
 64               this.And(x => SqlFunctions.DateDiff("d", start, x.RegisterDate) >= 0);
 65               this.And(x => SqlFunctions.DateDiff("d", end, x.RegisterDate) <= 0);
 66             }
 67           }
 68           if (rule.field == "CreatedDate" && !string.IsNullOrEmpty(rule.value))
 69           {
 70             if (rule.op == "between")
 71             {
 72               var datearray = rule.value.Split(new char[] { '-' });
 73               var start = Convert.ToDateTime(datearray[0]);
 74               var end = Convert.ToDateTime(datearray[1]);
 75 
 76               this.And(x => SqlFunctions.DateDiff("d", start, x.CreatedDate) >= 0);
 77               this.And(x => SqlFunctions.DateDiff("d", end, x.CreatedDate) <= 0);
 78             }
 79           }
 80 
 81 
 82           if (rule.field == "CreatedBy" && !string.IsNullOrEmpty(rule.value))
 83           {
 84             this.And(x => x.CreatedBy.Contains(rule.value));
 85           }
 86 
 87          if (rule.field == "LastModifiedDate" && !string.IsNullOrEmpty(rule.value))
 88           {
 89             if (rule.op == "between")
 90             {
 91               var datearray = rule.value.Split(new char[] { '-' });
 92               var start = Convert.ToDateTime(datearray[0]);
 93               var end = Convert.ToDateTime(datearray[1]);
 94 
 95               this.And(x => SqlFunctions.DateDiff("d", start, x.LastModifiedDate) >= 0);
 96               this.And(x => SqlFunctions.DateDiff("d", end, x.LastModifiedDate) <= 0);
 97             }
 98           }
 99 
100           if (rule.field == "LastModifiedBy" && !string.IsNullOrEmpty(rule.value))
101           {
102             this.And(x => x.LastModifiedBy.Contains(rule.value));
103           }
104 
105         }

View Code

• 新的做法是動態根據field,op,value生成一個linq 表達式,不用再做繁瑣的判斷,這塊代碼也可以被其它項目使用,非常好用

namespace SmartAdmin
{
 
  public static class PredicateBuilder
  {

    public static Expression<Func<T, bool>> FromFilter<T>(string filtergroup) {
      Expression<Func<T, bool>> any = x => true;
      if (!string.IsNullOrEmpty(filtergroup))
      {
        var filters = JsonSerializer.Deserialize<filter[]>(filtergroup);

          foreach (var filter in filters)
          {
            if (Enum.TryParse(filter.op, out OperationExpression op) && !string.IsNullOrEmpty(filter.value))
            {
              var expression = GetCriteriaWhere<T>(filter.field, op, filter.value);
              any = any.And(expression);
            }
          }
      }

      return any;
    }

    #region -- Public methods --
    public static Expression<Func<T, bool>> GetCriteriaWhere<T>(Expression<Func<T, object>> e, OperationExpression selectedOperator, object fieldValue)
    {
      var name = GetOperand<T>(e);
      return GetCriteriaWhere<T>(name, selectedOperator, fieldValue);
    }

    public static Expression<Func<T, bool>> GetCriteriaWhere<T, T2>(Expression<Func<T, object>> e, OperationExpression selectedOperator, object fieldValue)
    {
      var name = GetOperand<T>(e);
      return GetCriteriaWhere<T, T2>(name, selectedOperator, fieldValue);
    }

    public static Expression<Func<T, bool>> GetCriteriaWhere<T>(string fieldName, OperationExpression selectedOperator, object fieldValue)
    {
      var props = TypeDescriptor.GetProperties(typeof(T));
      var prop = GetProperty(props, fieldName, true);
      var parameter = Expression.Parameter(typeof(T));
      var expressionParameter = GetMemberExpression<T>(parameter, fieldName);
      if (prop != null && fieldValue != null)
      {
       
        BinaryExpression body = null;
        switch (selectedOperator)
        {
          case OperationExpression.equal:
            body = Expression.Equal(expressionParameter, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType)?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(body, parameter);
          case OperationExpression.notequal:
            body = Expression.NotEqual(expressionParameter, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(body, parameter);
          case OperationExpression.less:
            body = Expression.LessThan(expressionParameter, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(body, parameter);
          case OperationExpression.lessorequal:
            body = Expression.LessThanOrEqual(expressionParameter, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(body, parameter);
          case OperationExpression.greater:
            body = Expression.GreaterThan(expressionParameter, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(body, parameter);
          case OperationExpression.greaterorequal:
            body = Expression.GreaterThanOrEqual(expressionParameter, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(body, parameter);
          case OperationExpression.contains:
            var contains = typeof(string).GetMethod("Contains", new[] { typeof(string) });
            var bodyLike = Expression.Call(expressionParameter, contains, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(bodyLike, parameter);
          case OperationExpression.endwith:
            var endswith = typeof(string).GetMethod("EndsWith",new[] { typeof(string) });
            var bodyendwith = Expression.Call(expressionParameter, endswith, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(bodyendwith, parameter);
          case OperationExpression.beginwith:
            var startswith = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
            var bodystartswith = Expression.Call(expressionParameter, startswith, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(bodystartswith, parameter);
          case OperationExpression.includes:
            return Includes<T>(fieldValue, parameter, expressionParameter, prop.PropertyType);
          case OperationExpression.between:
            return Between<T>(fieldValue, parameter, expressionParameter, prop.PropertyType);
          default:
            throw new Exception("Not implement Operation");
        }
      }
      else
      {
        Expression<Func<T, bool>> filter = x => true;
        return filter;
      }
    }

    public static Expression<Func<T, bool>> GetCriteriaWhere<T, T2>(string fieldName, OperationExpression selectedOperator, object fieldValue)
    {


      var props = TypeDescriptor.GetProperties(typeof(T));
      var prop = GetProperty(props, fieldName, true);

      var parameter = Expression.Parameter(typeof(T));
      var expressionParameter = GetMemberExpression<T>(parameter, fieldName);

      if (prop != null && fieldValue != null)
      {
        switch (selectedOperator)
        {
          case OperationExpression.any:
            return Any<T, T2>(fieldValue, parameter, expressionParameter);

          default:
            throw new Exception("Not implement Operation");
        }
      }
      else
      {
        Expression<Func<T, bool>> filter = x => true;
        return filter;
      }
    }



    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr, Expression<Func<T, bool>> or)
    {
      if (expr == null)
      {
        return or;
      }

      return Expression.Lambda<Func<T, bool>>(Expression.OrElse(new SwapVisitor(expr.Parameters[0], or.Parameters[0]).Visit(expr.Body), or.Body), or.Parameters);
    }

    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr, Expression<Func<T, bool>> and)
    {
      if (expr == null)
      {
        return and;
      }

      return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(new SwapVisitor(expr.Parameters[0], and.Parameters[0]).Visit(expr.Body), and.Body), and.Parameters);
    }

    #endregion
    #region -- Private methods --

    private static string GetOperand<T>(Expression<Func<T, object>> exp)
    {
      if (!( exp.Body is MemberExpression body ))
      {
        var ubody = (UnaryExpression)exp.Body;
        body = ubody.Operand as MemberExpression;
      }

      var operand = body.ToString();

      return operand.Substring(2);

    }

    private static MemberExpression GetMemberExpression<T>(ParameterExpression parameter, string propName)
    {
      if (string.IsNullOrEmpty(propName))
      {
        return null;
      }

      var propertiesName = propName.Split('.');
      if (propertiesName.Count() == 2)
      {
        return Expression.Property(Expression.Property(parameter, propertiesName[0]), propertiesName[1]);
      }

      return Expression.Property(parameter, propName);
    }

    private static Expression<Func<T, bool>> Includes<T>(object fieldValue, ParameterExpression parameterExpression, MemberExpression memberExpression ,Type type)
    {
      var safetype= Nullable.GetUnderlyingType(type) ?? type;

      switch (safetype.Name.ToLower())
      {
        case  "string":
          var strlist = (IEnumerable<string>)fieldValue;
          if (strlist == null || strlist.Count() == 0)
          {
            return x => true;
          }
          var strmethod = typeof(List<string>).GetMethod("Contains", new Type[] { typeof(string) });
          var strcallexp = Expression.Call(Expression.Constant(strlist.ToList()), strmethod, memberExpression);
          return Expression.Lambda<Func<T, bool>>(strcallexp, parameterExpression);
        case "int32":
          var intlist = (IEnumerable<int>)fieldValue;
          if (intlist == null || intlist.Count() == 0)
          {
            return x => true;
          }
          var intmethod = typeof(List<int>).GetMethod("Contains", new Type[] { typeof(int) });
          var intcallexp = Expression.Call(Expression.Constant(intlist.ToList()), intmethod, memberExpression);
          return Expression.Lambda<Func<T, bool>>(intcallexp, parameterExpression);
        case "float":
          var floatlist = (IEnumerable<float>)fieldValue;
          if (floatlist == null || floatlist.Count() == 0)
          {
            return x => true;
          }
          var floatmethod = typeof(List<int>).GetMethod("Contains", new Type[] { typeof(int) });
          var floatcallexp = Expression.Call(Expression.Constant(floatlist.ToList()), floatmethod, memberExpression);
          return Expression.Lambda<Func<T, bool>>(floatcallexp, parameterExpression);
        default:
          return x => true;
      }
      
    }
    private static Expression<Func<T, bool>> Between<T>(object fieldValue, ParameterExpression parameterExpression, MemberExpression memberExpression, Type type)
    {
      
      var safetype = Nullable.GetUnderlyingType(type) ?? type;
      switch (safetype.Name.ToLower())
      {
        case "datetime":
          var datearray = ( (string)fieldValue ).Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
          var start = Convert.ToDateTime(datearray[0] + " 00:00:00", CultureInfo.CurrentCulture);
          var end = Convert.ToDateTime(datearray[1] + " 23:59:59", CultureInfo.CurrentCulture);
          var greater = Expression.GreaterThan(memberExpression, Expression.Constant(start, type));
          var less = Expression.LessThan(memberExpression, Expression.Constant(end, type));
          return Expression.Lambda<Func<T, bool>>(greater, parameterExpression)
            .And(Expression.Lambda<Func<T, bool>>(less, parameterExpression));
        case "int":
        case "int32":
          var intarray = ( (string)fieldValue ).Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
          var min = Convert.ToInt32(intarray[0] , CultureInfo.CurrentCulture);
          var max = Convert.ToInt32(intarray[1], CultureInfo.CurrentCulture);
          var maxthen = Expression.GreaterThan(memberExpression, Expression.Constant(min, type));
          var minthen = Expression.LessThan(memberExpression, Expression.Constant(max, type));
          return Expression.Lambda<Func<T, bool>>(maxthen, parameterExpression)
            .And(Expression.Lambda<Func<T, bool>>(minthen, parameterExpression));
        case "decimal":
          var decarray = ( (string)fieldValue ).Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
          var dmin = Convert.ToDecimal(decarray[0], CultureInfo.CurrentCulture);
          var dmax = Convert.ToDecimal(decarray[1], CultureInfo.CurrentCulture);
          var dmaxthen = Expression.GreaterThan(memberExpression, Expression.Constant(dmin, type));
          var dminthen = Expression.LessThan(memberExpression, Expression.Constant(dmax, type));
          return Expression.Lambda<Func<T, bool>>(dmaxthen, parameterExpression)
            .And(Expression.Lambda<Func<T, bool>>(dminthen, parameterExpression));
        case "float":
          var farray = ((string)fieldValue).Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
          var fmin = Convert.ToDecimal(farray[0], CultureInfo.CurrentCulture);
          var fmax = Convert.ToDecimal(farray[1], CultureInfo.CurrentCulture);
          var fmaxthen = Expression.GreaterThan(memberExpression, Expression.Constant(fmin, type));
          var fminthen = Expression.LessThan(memberExpression, Expression.Constant(fmax, type));
          return Expression.Lambda<Func<T, bool>>(fmaxthen, parameterExpression)
            .And(Expression.Lambda<Func<T, bool>>(fminthen, parameterExpression));
        case "string":
          var strarray = ( (string)fieldValue ).Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
          var smin = strarray[0];
          var smax = strarray[1];
        
          var strmethod = typeof(string).GetMethod("Contains");
          var mm = Expression.Call(memberExpression, strmethod, Expression.Constant(smin, type));
          var nn = Expression.Call(memberExpression, strmethod, Expression.Constant(smax, type));


          return Expression.Lambda<Func<T, bool>>(mm, parameterExpression)
            .Or(Expression.Lambda<Func<T, bool>>(nn, parameterExpression));
        default:
          return x => true;
      }

    }



    private static Expression<Func<T, bool>> Any<T, T2>(object fieldValue, ParameterExpression parameterExpression, MemberExpression memberExpression)
    {
      var lambda = (Expression<Func<T2, bool>>)fieldValue;
      var anyMethod = typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public)
      .First(m => m.Name == "Any" && m.GetParameters().Count() == 2).MakeGenericMethod(typeof(T2));

      var body = Expression.Call(anyMethod, memberExpression, lambda);

      return Expression.Lambda<Func<T, bool>>(body, parameterExpression);
    }

    private static PropertyDescriptor GetProperty(PropertyDescriptorCollection props, string fieldName, bool ignoreCase)
    {
      if (!fieldName.Contains('.'))
      {
        return props.Find(fieldName, ignoreCase);
      }

      var fieldNameProperty = fieldName.Split('.');
      return props.Find(fieldNameProperty[0], ignoreCase).GetChildProperties().Find(fieldNameProperty[1], ignoreCase);

    }
    #endregion
  }

  internal class SwapVisitor : ExpressionVisitor
  {
    private readonly Expression from, to;
    public SwapVisitor(Expression from, Expression to)
    {
      this.from = from;
      this.to = to;
    }
    public override Expression Visit(Expression node) => node == from ? to : base.Visit(node);
  }
  public enum OperationExpression
  {
    equal,
    notequal,
    less,
    lessorequal,
    greater,
    greaterorequal,
    contains,
    beginwith,
    endwith,
    includes,
    between,
    any
  }
}

View Code

 1 public async Task<JsonResult> GetData(int page = 1, int rows = 10, string sort = "Id", string order = "asc", string filterRules = "")
 2     {
 3       try
 4       {
 5         var filters = PredicateBuilder.FromFilter<Company>(filterRules);
 6         var total = await this.companyService
 7                              .Query(filters)
 8                              .AsNoTracking()
 9                              .CountAsync()
10                               ;
11         var pagerows = (await this.companyService
12                              .Query(filters)
13                               .AsNoTracking()
14                            .OrderBy(n => n.OrderBy(sort, order))
15                            .Skip(page - 1).Take(rows)
16                            .SelectAsync())
17                            .Select(n => new
18                            {
19                              Id = n.Id,
20                              Name = n.Name,
21                              Code = n.Code,
22                              Address = n.Address,
23                              Contect = n.Contect,
24                              PhoneNumber = n.PhoneNumber,
25                              RegisterDate = n.RegisterDate.ToString("yyyy-MM-dd HH:mm:ss")
26                            }).ToList();
27         var pagelist = new { total = total, rows = pagerows };
28         return Json(pagelist);
29       }
30       catch(Exception e) {
31         throw e;
32         }
33 
34     }

配合使用的代碼

• 對於固定查詢邏輯的封裝和復用,當然除了復用還可以明顯的提高代碼的可讀性.

public class OrderSalesQuery : QueryObject<Order>
{
    public decimal Amount { get; set; }
    public string Country { get; set; }
    public DateTime FromDate { get; set; }
    public DateTime ToDate { get; set; }

    public override Expression<Func<Order, bool>> Query()
    {
        return (x => 
            x.OrderDetails.Sum(y => y.UnitPrice) > Amount &&
            x.OrderDate >= FromDate &&
            x.OrderDate <= ToDate &&
            x.ShipCountry == Country);
    }
}

查看訂單的銷售情況,條件 金額,國家,日期

var orderRepository = new Repository<Order>(this);
    
var orders = orderRepository
    .Query(new OrderSalesQuery(){ 
        Amount = 100, 
        Country = "USA",
        FromDate = DateTime.Parse("01/01/1996"), 
        ToDate = DateTime.Parse("12/31/1996" )
    })
    .Select();

調用查詢方法

public class CustomerLogisticsQuery : QueryObject<Customer>
{
    public CustomerLogisticsQuery FromCountry(string country)
    {
        Add(x => x.Country == country);
        return this;
    }

    public CustomerLogisticsQuery LivesInCity(string city)
    {   
        Add(x => x.City == city);
        return this;
    }
}

客戶查詢 根據國家和城市查詢

public class CustomerSalesQuery : QueryObject<Customer>
{
    public CustomerSalesQuery WithPurchasesMoreThan(decimal amount)
    {
        Add(x => x.Orders
            .SelectMany(y => y.OrderDetails)
            .Sum(z => z.UnitPrice * z.Quantity) > amount);

        return this;
    }

    public CustomerSalesQuery WithQuantitiesMoreThan(decimal quantity)
    {
        Add(x => x.Orders
            .SelectMany(y => y.OrderDetails)
            .Sum(z => z.Quantity) > quantity);

        return this;
    }
}

客戶的銷售情況,金額和數量

var customerRepository = new Repository<Customer>(this);

var query1 = new CustomerLogisticsQuery()
    .LivesInCity("London");

var query2 = new CustomerSalesQuery()
    .WithPurchasesMoreThan(100)
    .WithQuantitiesMoreThan(10);

customerRepository
    .Query(query1.And(query2))
    .Select()
    .Dump();

復用上面的定義的查詢方法

以上這些都是改項目提供的方法,非常的好用

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化

寫在前面

曾經我和前端朋友聊天的時候，我說我希望有一天可以用C#寫前端，不過當時更多的是美好的想象，而現在這一切正變得真實……

什麼是Blazor

我們知道瀏覽器可以正確解釋並執行JavaScript代碼，那麼瀏覽器是如何執行C#代碼的呢？答案是通過WebAssembly。通過WebAssembly，我們可以讓瀏覽器運行很多的高級語言，如 C#、C、C++、GO等，並使他們運行在基於內存安全的沙箱環境中。如下圖所示：

作為一個已經五六年沒有寫過前端的.NET程序員，遇到Blazor實在是幸運中的幸運。它又讓我可以很愉快的寫前端了，而且還是用C#去寫，我也就不用再分出精力去學習其他的JS框架了。

我們可以認為Blazor是.NET對WebAssembly的實現。通過使用Blazor，我們可以使用C#語言來取代JS去開發交互式Web UI。

值得一提的是，Blazor是由Browser和Razor這兩個單詞合併而成的，意思就是Blazor可以基於客戶端執行Razor視圖后將HTML呈現給瀏覽器。所以想要更好的理解Blazor，就要首先更好的了解瀏覽器和Razor。

Blazor有以下幾個優點：

• 使用C＃來取代JavaScript創建豐富的交互式UI
• 基於.NET及其生態編寫服務器端和客戶端應用程序邏輯
• 糅合現有HTML和CSS技術，提供了廣泛的瀏覽器支持，包括移動瀏覽器(注意：Blazor取代的是基於JavaScript的UI交互，而其他部分如HTML、CSS，這些是我們的技術基礎)
• 與現代託管平台（例如Docker）集成。
• Blazor是開源的，其源碼位置在GitHub上

另外需要注意的，Blazor和Silverlight不可混為一談，Blazor是基於開放標準而構建的，本身不需要任何額外插件。而Silverlight帶有太多自有特性，所以不得不在瀏覽器上安裝插件以更好的支持其運行。

什麼是WebAssembly

概覽

WebAssembly是一種二進制格式的指令集，其設計目標是能夠在解釋或者將其編譯為本地機器代碼並執行他們的機器上運行，這類似於我們.NET編譯后的IL。

WebAssembly可以作為編譯高級編程語言的可移植目標，通過節省大小和加載時間，充分利用各種平台（移動平台和IOT平台）上的通用應用功能，使得WebAssembly可以以接近於本機（接近於本機的英語單詞是：near-native，在語言學里意思是精通語言的人，所說的話和說母語的人沒有什麼區別）的運行速度運行。

支持

WebAssembly已經獲得了大部分瀏覽器的支持。詳細內容可以移步至Can I Use

手寫一個例子

接下來我們看一個例子，方便起見，我們直接使用在線的WebAssembly編譯工具，地址是：https://mbebenita.github.io/WasmExplorer/。目前，這個工具只支持C和C++。不過也沒有什麼關係，我們寫一個簡單的方法用於測試即可。

• 首先我們定義了一個計算兩個數和的方法:

1 int Addition(int a, int b)
2 {
3   return a + b; 
4 }

• 然後點擊COMPILE

在中間的框里會生成WAT（即WebAssembly文本格式）的代碼，最右邊的是二進制了。中間的代碼部分可以幫助我們查看在編譯的過程中發生了什麼，會看到生成了一個名為_Z8Additionii的function，其中8表示這個方法名的長度，後面的i表示有多個參數，接下來我們會去調用它。

 1 (module
 2  (table 0 anyfunc)
 3  (memory $0 1)
 4  (export "memory" (memory $0))
 5  (export "_Z8Additionii" (func $_Z8Additionii))
 6  (func $_Z8Additionii (; 0 ;) (param $0 i32) (param $1 i32) (result i32)
 7   (i32.add
 8    (get_local $1)
 9    (get_local $0)
10   )
11  )
12 )

• 點擊Download，下載.WAT文件

• 接下來我們再寫一個HTML網頁出來，就用那種最簡單的HTML代碼，代碼如下：

 1 <HTML>
 2 <HEAD>
 3     <TITLE>WebAssembly Sample: Call C++ Code</TITLE>
 4     <script type="text/javascript">
 5         let addition = fetch('test.wasm')
 6             .then(response => response.arrayBuffer())
 7             .then(buffer => WebAssembly.compile(buffer))
 8             .then(module => { return new WebAssembly.Instance(module) })
 9             .then(instance => { addition = instance.exports._Z8Additionii }); 
10     </script>
11 </HEAD>
12 <BODY BGCOLOR="FFFFFF">
13     <h1>WebAssembly Sample: Call C++ Code</h1>
14 </BODY>
15 </HTML>

• 最終的效果圖

通過以上示例，我們基本上對Blazor和WebAssembly的部分運行機制有了一個比較清晰的認識了，接下來，我們繼續討論有關Blazor的內容。

參考鏈接：

https://webassembly.org/

https://webassembly.github.io/spec/js-api/index.html

https://caniuse.com/#search=wasm

https://webassembly.github.io/spec/js-api/index.html

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化

前言

相信你面試的時候，肯定被問過 hashCode 和 equals 相關的問題 。如：

• hashCode 是什麼？它是怎麼得來的？有什麼用？
• 經典題，equals 和 == 有什麼區別？
• 為什麼要重寫 equals 和 hashCode ？
• 重寫了 equals ，就必須要重寫 hashCode 嗎？為什麼？
• hashCode 相等時，equals 一定相等嗎？反過來呢？

好的，上面就是靈魂拷問環節。其實，這些問題仔細想一下也不難，主要是平時我們很少去思考它。

正文

下面就按照上邊的問題順序，一個一個剖析它。扒開 hashCode 的神秘面紗。

什麼是 hashCode？

我們通常說的 hashCode 其實就是一個經過哈希運算之後的整型值。而這個哈希運算的算法，在 Object 類中就是通過一個本地方法 hashCode() 來實現的（HashMap 中還會有一些其它的運算）。

public native int hashCode();

可以看到它是一個本地方法。那麼，想要了解這個方法到底是用來幹嘛的，最直接有效的方法就是，去看它的源碼註釋。

下邊我就用我蹩腳的英文翻譯一下它的意思。。。

返回當前對象的一個哈希值。這個方法用於支持一些哈希表，例如 HashMap 。

通常來講，它有如下一些約定：

• 若對象的信息沒有被修改，那麼，在一個程序的執行期間，對於相同的對象，不管調用多少次 hashCode 方法，都應該返回相同的值。當然，在相同程序的不同執行期間，不需要保持結果一致。
• 若兩個對象的 equals 方法返回值相同，那麼，調用它們各自的 hashCode 方法時，也必須返回相同的結果。（ps: 這句話解答了上邊的一些問題，後面會用例子來證明這一點）
• 當兩個對象的 equals 方法返回值不同時，那麼它們的 hashCode 方法不用保證必須返回不同的值。但是，我們應該知道，在這種情況下，我們最好也設計成 hashCode 返回不同的值。因為，這樣做有助於提高哈希表的性能。

在實際情況下，Object 類的 hashCode 方法在不同的對象中確實返回了不同的哈希值。這通常是通過把對象的內部地址轉換為一個整數來實現的。

ps: 這裏說的內部地址就是指物理地址，也就是內存地址。需要注意的是，雖然 hashCode 值是依據它的內存地址而得來的。但是，不能說 hashCode 就代表對象的內存地址，實際上，hashCode 地址是存放在哈希表中的。

上邊的源碼註釋真可謂是句句珠璣，把 hashCode 方法解釋的淋漓盡致。一會兒我通過一個案例說明，就能明白我為什麼這樣說了。

什麼是哈希表？

上文中提到了哈希表。什麼是哈希表呢？我們直接看百度百科的解釋。

用一張圖來表示它們的關係。

左邊一列就是一些關鍵碼(key)，通過哈希函數，它們都會得到一個固定的值，分別對應右邊一列的某個值。右邊的這一列就可以認為是一張哈希表。

而且，我們會發現，有可能有些 key 不同，但是它們對應的哈希值卻是一樣的，例如 aa，bb 都指向 1001 。但是，一定不會出現同一個 key 指向不同的值。

這也非常好理解，因為哈希表就是用來查找 key 的哈希地址的。在 key 確定的情況下，通過哈希函數計算出來的 哈希地址，一定也是確定的。如圖中的 dd 已經確定在 1002 位置了，那麼就不可能再佔據 1003 位置。

思考一下，如果有另外一個元素 ee 來了，它的哈希地址也落在 1002 位置，怎麼辦呢？

hashCode 有什麼用？

其實，上圖就已經可以說明一些問題了。我們通過一個 key 計算出它的 hashCode 值，就可以唯一確定它在哈希表中的位置。這樣，在查詢時，就可以直接定位到當前元素，提高查詢效率。

現在我們假設有這樣一個場景。我們需要在內存中的一塊兒區域存放 10000 個不同的元素（以aa,bb,cc,dd 等為例）。那怎麼實現不同的元素插入，相同的元素覆蓋呢？

我們最容易想到的方法就是，每當存一個新元素時，就遍歷一遍已經存在的元素，看有沒有相同的。這樣雖然也是可以實現的，但是，如果已經存在了 9000 個元素，你就需要去遍歷一下這 9000 個元素。很明顯，這樣的效率是非常低下的。

我們轉換一種思路，還是以上圖為例。若來了一個新元素 ff，首先去計算它的 hashCode 值，得出為 1003 。發現此處還沒有元素，則直接把這個新元素 ff 放到此位置。

然後，ee 來了，通過計算哈希值得到 1002 。此時，發現 1002 位置已經存在一個元素了。那麼，通過 equals 方法比較它們是否相等，發現只有一個 dd 元素，很明顯和 ee 不相等。那麼，就把 ee 元素放到 dd 元素的後邊（可以用鏈表形式存放）。

我們會發現，當有新元素來的時候，先去計算它們的哈希值，再去確定存放的位置，這樣就可以減少比較的次數。如 ff 不需要比較， ee 只需要和 dd 比較一次。

當元素越來越多的時候，新元素也只需要和當前哈希值相同的位置上，已經存在的元素進行比較。而不需要和其他哈希值不同的位置上的元素進行比較。這樣就大大減少了元素的比較次數。

圖中為了方便，畫的哈希表比較小。現在假設，這個哈希表非常的大，例如有這麼非常多個位置，從 1001 ~ 9999。那麼，新元素插入的時候，有很大概率會插入到一個還沒有元素存在的位置上，這樣就不需要比較了，效率非常高。但是，我們會發現這樣也有一個弊端，就是哈希表所佔的內存空間就會變大。因此，這是一個權衡的過程。

有心的同學可能已經發現了。我去，上邊的這個做法好熟悉啊。沒錯，它就是大名鼎鼎的 HashMap 底層實現的思想。對 HashMap 還不了解的，趕緊看這篇文章理一下思路。HashMap 底層實現原理及源碼分析

所以，hashCode 有什麼用。很明顯，提高了查詢，插入元素的效率呀。

equals 和 == 有什麼區別？

這是萬年不變，經久不衰的經典面試題了。讓我油然想起，當初為了面試，背誦過的面經了，簡直是一把心酸一把淚。現在還能記得這道題的標準答案：equals 比較的是內容， == 比較的是地址。

當時，真的就只是背答案，知其然而不知其所以然。再往下問，為什麼要重寫 equals ，就懵逼了。

首先，我們應該知道 equals 是定義在所有類的父類 Object 中的。

 public boolean equals(Object obj) {
     return (this == obj);
 }

可以看到，它的默認實現，就是 == ，這是用來比較內存地址的。所以，如果一個對象的 equals 不重寫的話，和 == 的效果是一樣的。

我們知道，當創建兩個普通對象時，一般情況下，它們所對應的內存地址是不一樣的。例如，我定義一個 User 類。

public class User {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public User() {

    }
}

public class TestHashCode {
    public static void main(String[] args) {
        User user1 = new User("zhangsan", 20);
        User user2 = new User("lisi", 18); 

        System.out.println(user1 == user2);
        System.out.println(user1.equals(user2));
    }
}
// 結果： false	false

很明顯，zhangsan 和 lisi 是兩個人，兩個不同的對象。因此，它們所對應的內存地址不同，而且內容也不相等。

注意，這裏我還沒有對 User 重寫 equals，實際此時 equals 使用的是父類 Object 的方法，返回的肯定是不相等的。因此，為了更好地說明問題，我僅把第二行代碼修改如下：

//User user2 = new User("lisi", 18);
User user2 = new User("zhangsan", 20);

讓 user1 和 user2 的內容相同，都是 zhangsan，20歲。按我們的理解，這雖然是兩個對象，但是應該是指的同一個人，都是張三。但是，打印結果，如下：

這有悖於我們的認知，明明是同一個人，為什麼 equals 返回的卻不相等呢。因此，此時我們就需要把 User 類中的 equals 方法重寫，以達到我們的目的。在 User 中添加如下代碼（使用 idea 自動生成代碼）：

public class User {
    ... //省略已知代碼
        
    @Override
    public boolean equals(Object o) {
        //若兩個對象的內存地址相同，則說明指向的是同一個對象，故內容一定相同。
        if (this == o) return true;
        //類都不是同一個，更別談相等了
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        //比較兩個對象中的所有屬性，即name和age都必須相同，才可認為兩個對象相等
        return age == user.age &&
                Objects.equals(name, user.name);
    }
   
}
//打印結果：  false 	true

再次執行程序，我們會發現此時 equals 返回 true ，這才是我們想要的。

因此，當我們使用自定義對象時。如果需要讓兩個對象的內容相同時，equals 返回 true，則需要重寫 equals 方法。

為什麼要重寫 equals 和 hashCode ？

在上邊的案例中，其實我們已經說明了為什麼要去重寫 equals 。因為，在對象內容相同的情況下，我們需要讓對象相等。因此，不能用 Object 類的默認實現，只去比較內存地址，這樣是不合理的。

那 hashCode 為什麼要重寫呢？ 這就涉及到集合，如 Map 和 Set （底層其實也是 Map）了。

我們以 HashMap JDK1.8的源碼來看，如 put 方法。

我們會發現，代碼中會多次進行 hash 值的比較，只有當哈希值相等時，才會去比較 equals 方法。當 hashCode 和 equals 都相同時，才會覆蓋元素。get 方法也是如此（先比較哈希值，再比較equals），

只有 hashCode 和 equals 都相等時，才認為是同一個元素，找到並返回此元素，否則返回 null。

這也對應 “hashCode 有什麼用？”這一小節。 重寫 equals 和 hashCode 的目的，就是為了方便哈希表這樣的結構快速的查詢和插入。如果不重寫，則無法比較元素，甚至造成元素位置錯亂。

重寫了 equals ，就必須要重寫 hashCode 嗎？

答案是肯定的。首先，在上邊的 JDK 源碼註釋中第第二點，我們就會發現這句說明。其次，我們嘗試重寫 equals ，而不重寫 hashCode 看會發生什麼現象。

public class TestHashCode {
    public static void main(String[] args) {
        User user1 = new User("zhangsan", 20);
        User user2 = new User("zhangsan", 20);

        HashMap<User, Integer> map = new HashMap<>();
        map.put(user1,90);
        System.out.println(map.get(user2));
    }
}
// 打印結果： null

對於代碼中的 user1 和 user2 兩個對象來說，我們認為他是同一個人張三。定義一個 map ，key 存儲 User 對象， value 存儲他的學習成績。

當把 user1 對象作為 key ，成績 90 作為 value 存儲到 map 中時，我們肯定希望，用 key 為 user2 來取值時，得到的結果是 90 。但是，結果卻大失所望，得到了 null 。

這是因為，我們自定義的 User 類，雖然重寫了 equals ，但是沒有重寫 hashCode 。當 user1 放到 map 中時，計算出來的哈希值和用 user2 去取值時計算的哈希值不相等。因此，equals 方法都沒有比較的機會。認為他們是不同的元素。然而，其實，我們應該認為 user1 和 user2 是相同的元素的。

用圖來說明就是，user1 和 user2 存放在了 HashMap 中不同的桶裡邊，導致查詢不到目標元素。

因此，當我們用自定義類來作為 HashMap 的 key 時，必須要重寫 hashCode 和 equals 。否則，會得到我們不想要的結果。

這也是為什麼，我們平時都喜歡用 String 字符串來作為 key 的原因。 因為， String 類默認就幫我們實現了 equals 和 hashCode 方法的重寫。如下，

// String.java
public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        //從前向後依次比較字符串中的每個字符
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;
		//把字符串中的每個字符都取出來，參与運算
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        //把計算出來的最終值，存放在hash變量中。
        hash = h;
    }
    return h;
}

重寫 equals 時，可以使用 idea 提供的自動代碼，也可以自己手動實現。

public class User {
    ... //省略已知代碼
        
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
   
}
//此時，map.get(user2) 可以得到 90 的正確值

在重寫了 hashCode 后，使用自定義對象作為 key 時，還需要注意一點，不要在使用過程中，改變對象的內容，這樣會導致 hashCode 值發生改變，同樣得不到正確的結果。如下，

public class TestHashCode {
    public static void main(String[] args) {
        User user = new User("zhangsan", 20);

        HashMap<User, Integer> map = new HashMap<>();
        map.put(user,90);
        System.out.println(map.get(user));
        user.setAge(18); //把對象的年齡修改為18
        System.out.println(map.get(user));
    }
}
// 打印結果：
// 90
// null

會發現，修改后，拿到的值是 null 。這也是，hashCode 源碼註釋中的第一點說明的，hashCode 值不變的前提是，對象的信息沒有被修改。若被修改，則有可能導致 hashCode 值改變。

此時，有沒有聯想到其他一些問題。比如，為什麼 String 類要設計成不可以變的呢？這裏用 String 作為 HashMap 的 key 時，可以算作一個原因。你肯定不希望，放進去的時候還好好的，取出來的時候，卻找不到元素了吧。

String 類內部會有一個變量(hash)來緩存字符串的 hashCode 值。只有字符串不可變，才可以保證哈希值不變。

hashCode 相等時，equals 一定相等嗎？

很顯然不是的。在 HashMap 的源碼中，我們就能看到，當 hashCode 相等時（產生哈希碰撞），還需要比較它們的 equals ，才可以確定是否是同一個對象。因此，hashCode 相等時， equals 不一定相等 。

反過來，equals 相等的話， hashCode 一定相等嗎？ 那必須的。equals 都相等了，那說明在 HashMap 中認為它們是同一個元素，所以 hashCode 值必須也要保證相等。

結論：

• hashCode 相等，equals 不一定相等。
• hashCode 不等，equals 一定不等。
• equals 相等， hashCode 一定相等。
• equals 不等， hashCode 不一定不等。

關於最後這一點，就是 hashCode 源碼註釋中提到的第三點。當 equals 不等時，不用必須保證它們的 hashCode 也不相等。但是為了提高哈希表的效率，最好設計成不等。

因為，我們既然知道它們不相等了，那麼當 hashCode 設計成不等時。只要比較 hashCode 不相等，我們就可以直接返回 null，而不必再去比較 equals 了。這樣，就減少了比較的次數，無疑提高了效率。

結尾

以上就是 hashCode 和 equals 相關的一些問題。相信已經可以解答你心中的疑惑了，也可以和面試官侃侃而談。再也不用擔心，面試官說換人了。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!