Question

我已将以下属性添加到我的ApplicationUser类中，该类应该在当前用户的基础上返回其他结果。

public static IComparer<string> IdComparer
{
  get
  {
    return Comparer<string>.Create((x, y) =>
        {
          var curUser = HttpContext.Current.User;
          if (curUser != null)
          {
            var curId = curUser.Identity.GetUserId();
            if (x == curId)
              return -1;
            else if (y == curId)
              return 1;
          }
          return string.Compare(x, y);
        });
  }
}

无论如何，生成比较器的成本是否超过存储成本？我应该添加静态字段并为此属性返回单例吗？

我正在考虑返回相同的比较器：

private static object sync = new object();
private static IComparer<string> _IdComparer;
public static IComparer<string> IdComparer
{
  get
  {
    if (_IdComparer == null)
      lock (sync)
        if (_IdComparer == null)
          _IdComparer = Comparer<string>.Create((x, y) =>
              {
                var curUser = HttpContext.Current.User;
                if (curUser != null)
                {
                  var curId = curUser.Identity.GetUserId();
                  if (x == curId)
                    return -1;
                  else if (y == curId)
                    return 1;
                }
                return string.Compare(x, y);
              });
    return _IdComparer;
  }
}

这样安全吗？有任何更正或改进吗？

Answer 1

生成比较器肯定比存储它更费用。它是一个堆分配，并且不止一个（你必须为lambda分配自动生成的类）。

你可能不应该担心它。开销非常小。

您的编辑没问题。您甚至不需要使用锁或检查null。赋值操作保证是原子的。在最坏的情况下，您只需创建两次相同的比较器。

通过下面的初始化程序，我的意思是：

    static readonly IComparer<string> _IdComparer = Comparer<string>.Create((x, y) => {
        var curUser = HttpContext.Current.User;
        if (curUser != null) {
            var curId = curUser.Identity.GetUserId();
            if (x == curId)
                return -1;
            else if (y == curId)
                return 1;
        }
        return string.Compare(x, y);
    });

    public static IComparer<string> IdComparer {
        get {
            return _IdComparer;
        }
    }

我真的不明白你怎么不知道初始化器。

我应该在静态字段中缓存比较器吗？

1 个答案: