小编Sam*_*les的帖子

我想知道是否有人对此问题有任何建议.

我使用带有自定义IEqualityComparer的intersect和except(Linq)来查询设置差异并设置两个ISyncableUsers序列的交集.

public interface ISyncableUser
{
    string Guid { get; }
    string UserPrincipalName { get; }
}

两个ISyncableUsers是否相等的逻辑是有条件的.条件围绕两个属性Guid和UserPrincipalName中的任何一个是否具有值.解释这种逻辑的最好方法是使用代码.下面是我的客户IEqualityComparer的Equals方法的实现.

public bool Equals(ISyncableUser userA, ISyncableUser userB)
{
    if (userA == null && userB == null)
    {
        return true;
    }

    if (userA == null)
    {
        return false;
    }

    if (userB == null)
    {
        return false;
    }

    if ((!string.IsNullOrWhiteSpace(userA.Guid) && !string.IsNullOrWhiteSpace(userB.Guid)) &&
        userA.Guid == userB.Guid)
    {
        return true;
    }

    if (UsersHaveUpn(userA, userB))
    {
        if (userB.UserPrincipalName.Equals(userA.UserPrincipalName, StringComparison.InvariantCultureIgnoreCase))
        {
            return true;
        }
    }
    return false;
} …

我正在使用testcafe编写一些基于授权/角色的前端到端到端测试，并且需要确保某些菜单元素没有显示（负大小写声明），并且无法弄清楚如何断言选择器不匹配。

我试过了：

await t.expect(Selector('.m-menu__linktext').withText('Overview').innerText).notOk()

但这失败了：

无法获得有关节点的信息，因为指定的选择器与DOM树中的任何节点都不匹配。

如何断言选择器与页面上的任何元素都不匹配？

该图像确实说明了一切，每天都有重复的标签，而我真正想要的只是每个条形图上有一个标签。我的数据集由 8 个数据点组成：

[
   {     
      "date":"2019-06-21T00:00:00.000Z",    
      "value":44.6,      
   },
   {      
      "date":"2019-06-22T00:00:00.000Z",      
      "value":916.4,      
   },
   {
      "date":"2019-06-23T00:00:00.000Z",    
      "value":948.4,      
   },
   {    
      "date":"2019-06-24T00:00:00.000Z",    
      "value":872.4,      
   },
   {      
      "date":"2019-06-25T00:00:00.000Z",      
      "value":952.4,      
   },
   {      
      "date":"2019-06-26T00:00:00.000Z",      
      "value":1006.4,      
   },
   {      
      "date":"2019-06-27T00:00:00.000Z",      
      "value":945.4,   
   },
   {      
      "date":"2019-06-28T00:00:00.000Z",
      "value":320.8,
   }
]

我的图表定义如下：

{
        '$schema': 'https://vega.github.io/schema/vega-lite/v3.json',
        'description': 'Electricity consumption by month',
        'height': 320,
        'autosize': {
            'type': 'fit',
            'resize': false,
            'contains': 'padding'
        },
        'layer': [{
            'data': {
                'name': 'data'
            },
            'layer': [{
                'mark': 'bar',
                'encoding': {
                    'x': { 'field': 'date', 'timeUnit': 'day', 'type': 'temporal', 'axis': { …

这个问题的灵感来自stackexchange 和facebook API(http://api.stackexchange.com/docs/authentication)上的文档,但可能更广泛地适用于OAUTH 2.0.

我的问题是,当隐式模型看起来更简单,为什么要验证和访问内容时,为什么要使用显式身份验证模型？

隐式方法是否存在限制,这是node.js应用程序最合适的方法,它在技术上是服务器端应用程序,但似乎适合使用客户端javascript库.

编辑

在进行一些阅读后,似乎Web客户端流的"隐含"性质源于资源所有者(用户)隐含地信任客户端(Web浏览器)的事实.这意味着简化的流程是合适的,因为这是隐含的信任.

这仍然导致这样的问题:当通过OAUTH 2.0执行身份验证时,资源所有者(用户)必须警惕它们是否隐含地信任客户端.这似乎是一种潜在的危险立场,因为它代表用户承担意识和知识,并且似乎可能导致安全问题.

这是我们一遍又一遍地讨论过的事情,人们的意见在这方面似乎有很大不同.

基本问题,在进行TDD时,应该在循环的重构步骤之后添加额外的单元测试.我不是在谈论你的下一个测试开始你的下一个周期,而是测试以涵盖由于重构而产生的任何变化.

这可能最好用现实生活中的例子来解释.在TDD周期的绿色之后,我们有以下代码:

    public bool ShouldVerifyDomain
    {
        get
        {
            return this.Orders.SelectMany(x => x.Items).Any(x => x.Product.RequiresDomainVerification);
        }
    }

现在,我看看这个,并想一想,linq语句可能有点整洁,更容易阅读,而不是违反Demeter,让我们重构一下.所以我创建了以下内容Order:

 public bool HasItemsThatRequireDomainVerification
 {
     get
     {
          return this.Items.Any(x => x.Product.RequiresCascadeDomainVerification);
     }
 }

并修改ShouldVerifyDomain为:

  public bool ShouldVerifyDomain
  {
      get
      {
           return this.Orders.Any(x => x.HasItemsThatRequireDomainVerification);
      }
  }

好吧,那看起来好一点,我对此感到高兴.让我们继续我的列表上的下一个测试......但是......等等,我们现在HasItemsThatRequireDomainVerification通过另一个对象上的属性测试该属性....是一个真正的单元测试还是我应该添加一个测试(s )直接测试HasItemsThatRequireDomainVerification.

我的感受？我不认为它会增加很多价值.我认为这会增加套件的维护负担,花费时间并没有真正让我们对未来的变化更有信心.

它能给我们带来什么？公共界面的"文档" Order.

思考？

考虑具有以下特征的系统：

• 存储从多个传感器/输入收集的时间序列数据/度量。
• 在不同的时间从许多不同的系统收集数据点（指标）。
• 这些指标通常都是一个数据点（例如，温度和湿度不是同时报告的，而是单独报告的，并且时间戳会不同）
• 收集的指标类型将随着时间的推移而扩展-系统处于开放状态，并且随着时间的推移将支持其他输入（例如，今天我们收集温度，湿度和cpu，明天可能会添加监视CO2和RAM的传感器）。
• 给定时间段的所有指标摘要都需要通过查询获得，这很可能是最常见的查询方案。

我可以想到三种建模方法。

1.宽表-具有每个类别的表（已覆盖）

注意：由于数据点是单独收集的，因此具有很多稀疏值。存储新指标需要新列

2.窄表-带有每个指标的表（已覆盖）

注意：新指标的存储需要一个新表

3.类型表（未涵盖）-具有单个指标表（未涵盖）

注意：新指标的存储仅需要metricType表中的新行，而无需更改架构。尽管由于按时间段在所有指标上进行分组而不需要联接，因此可以担心由于块大小而对性能造成的影响，因此可以更快吗？

我想知道是否有人可以评论或提出选项，让我指出一些性能基准，包括3以及1和2，或者通常就每种方法的适用性提供任何建议。我计划对此进行自己的实验，完成后将发布结果，但在此阶段，您将不胜感激。:)

请注意，不建议使用nosql解决方案，我知道该领域的选项，并正在分别评估该选项

我一直想知道这个问题,并且未能找到关于这个问题的很多评论,而且我自己也未能得出结论.

在创建对象时,最好的做法是使对象在暴露数据和允许操作数据方面尽可能地受到限制.如果您可以使对象不可变,尤其是在多线程应用程序中,那么最好这样做.

话虽如此,C#似乎更倾向于不遵循此规则的开发人员,允许类的定义更简单,更重要的是,更容易维护.

采用以下只读不可变类:

public class ActiveDirectoryUser
{
    private readonly string firstName, lastName, office, username, email;

    public ActiveDirectoryUser(string firstName, string lastName, string office, string username, string email)
    {
        this.firstName = firstName;
        this.lastName = lastName;
        this.office = office;
        this.username = username;
        this.email = email;
    }

    public string FirstName
    {
        get { return firstName; }
    }

    public string LastName
    {
        get { return lastName; }
    }

    ...

    public string Email
    {
        get { return email; }
    }
}

并将其与下面更简单的示例进行比较,该示例不是只读的.

public class ActiveDirectoryUser …

以下摘录来自FX Cop警告.

不访问实例数据或调用实例方法的方法可以标记为static(在Visual Basic中为Shared).将方法标记为静态后,编译器将向这些成员发出非虚拟调用站点.发出非虚拟调用站点将阻止在运行时检查每个调用,以确保当前对象指针为非null.这可以为性能敏感的代码带来可测量的性能提升.在某些情况下,无法访问当前对象实例表示正确性问题.

我理解如果私有方法不访问实例数据或方法时使私有方法静态的性能优势,但我不确定在大多数情况下上述建议是否良好.如果您正在编写极其性能关键的代码,并且您无法选择在c#中编写它,我可以理解这种情绪,但考虑到通常,健壮,易于阅读和易于重构的代码优于性能你真的遵循这个建议吗？

我对私有静态方法的问题是,当你需要重构一个类时,我发现静态方法使得这样做更加困难.如果您有大量静态方法,并且需要更改一个以使用实例变量,并且该方法被其他私有静态方法使用,则最终必须进行更多更改才能使其正常工作.下面是一个例子(请记住这是一个最小的实现,只是为了证明这一点):

public class Test
    {
        private IService myService;

        private static void DoSomething()
        {
            DoSomethingElse();
        }

        private static void DoSomethingElse()
        {
            DoSomethingMore();
        }

        private static void DoSomethingMore()
        {
            Console.Write("DO SOMETHING");
        }
    }

如果我想myService在DoSomethingMore方法中使用,这意味着我不仅必须使该方法非静态,而且还必须使用前两种方法.这看起来很麻烦.

其他人对此有何看法？