小编Pat*_*ski的帖子

我正在试验并行和 LINQ。看看下面的代码。它有效，但只是为了得到这个想法：

private void LoadImages(string path)
{
    images =
        Directory.GetFiles(path)
        .Select(f => GetImage(f))
        .ToList();
}

private Image GetImage(string path)
{
    return Image.FromFile(path);
}

所以我基本上是从指定目录中找到的每个文件中获取图像。问题是 - 如何使这种平行？现在就像迭代它们一样。我想“以某种方式”并行化它。不知何故，因为我太缺乏经验，无法提出如何实现这一目标的想法，所以这就是为什么我问你们，伙计们，依靠一些帮助来加快速度:)

我遇到了这段代码:

// A
private readonly int value;
public int RawValue => value;

// B
public int CompareTo(Foo other) => value.CompareTo(other.value);

// C
internal int x => unchecked((value & y) + 1);

有人可以解释一下这里发生了什么以及使用这些技术的常用方法是什么？

编辑 链接到代码:单击

为了性能,在O(n ^ 2)算法中,我希望将复杂度降低两倍.基本上,我有这种形状的结构:

0   1   2   3   4   5
----------------------
0                     | 1
1,  2                 | 2
3,  4,  5             | 3
6,  7,  8,  9         | 4
10, 11, 12, 13, 14    | 5
15, 16, 17, 18, 19, 20| 6

因此,我创建了一个大小的矢量((1+n)*n/2)- 显然,算术和.问题是我现在需要来回计算每个位置.例如,如果我想计算列2和行中的位置,5我可以像这样计算:

int get_position(int x, int y)
{
    int smaller = min(x, y);
    int greater = max(x, y);
    return ((1 + greater) * greater / 2) - greater + smaller;
}

问题是: …

这是我正在使用的简化版本，只是为了让您知道我想要完成的任务：

public Dictionary<int, Func<int>> Magic(Dictionary<int, int> dictionary)
{
    return dictionary
        .Select(v => new
        {
            key = v.Key,
            function = new Func<int>(() => v.Value + 5)   // *
        })
        .ToDictionary(v => v.key, v => v.function);
}

是否可以将标有（*）的线缩短一些？因为当我尝试删除多余的（在我看来）委托创建时，它会给出错误：

function = () => v.Value + 5   // *

但它不应该给出错误，很清楚返回的类型是什么......

我想要两个简单的属性:开始日期和结束日期.我想设置一个约束条件,即开始日期必须在结束日期之前.修改两个值时会出现问题 - 它们可能(一起!)组成一个新的正确对,但在添加它们时,会出现错误.简单的例子:

start = 5;
end = 10;

new_start = 20;
new_end = 30;

start = new_start; // error!
end = new_end;

这就是我介绍第三个属性的原因.问题是 - 代码看起来很糟糕(尤其是.Item1,.Item2).

有没有办法在C#中以更好的方式做到这一点？

    private DateTime start;
    private DateTime end;

    public DateTime Start { get { return start; } }
    public DateTime End { get { return end; } }


    public Tuple<DateTime, DateTime> Dates
    {
        get
        {
            return new Tuple<DateTime, DateTime>(Start, End);
        }
        set
        {
            if (value.Item1 <= value.Item2)
            {
                start = value.Item1;
                end = value.Item2;
            } …

我可以对C#中系统枚举的转换int值进行假设吗？

例如:

//DayOfWeek
(int)DayOfWeek.Monday == 1,
(int)DayOfWeek.Tuesday == 2,
(int)DayOfWeek.Wednesday == 3,
(int)DayOfWeek.Thursday == 4,
(int)DayOfWeek.Friday == 5,
(int)DayOfWeek.Saturday == 6,
(int)DayOfWeek.Sunday == 0

我的代码的逻辑取决于它.但是,我不想写自己的映射,因为它......只是一个错误的解决方案.

编辑 这里也有文化的东西.ISO标准 - 周一第1天.在美国 - 第一天的星期日.

我遇到了一个安全问题。请看下面的伪代码

public static bool TryLogin(string email, string password)
{
    if (UserExists(email)) // here is the problem
        return false;

    var hash = GetRealPasswordHash(email);
    var hash2 = GetHash(email, password);
    return SlowEquals(hash, hash2);
}

你们中的一些人可能已经看到了这个洞。攻击者可能会通过网络执行时间攻击 - 检测返回答案的速度，并基于该检测数据库中是否有用户！知道这一点后，攻击者现在可以检查他已经知道存在的用户的各种密码！

如果您没有看到问题或不相信这是一个问题，请解释一下（这是针对哈希，但类比问题在这里）：

在“长度恒定”时间内比较散列值可确保攻击者无法使用定时攻击在在线系统中提取密码的散列值，然后离线破解它。

检查两个字节序列（字符串）是否相同的标准方法是比较第一个字节，然后是第二个，然后是第三个，依此类推。一旦发现两个字符串的字节不同，您就会知道它们是不同的，并且可以立即返回否定响应。如果您通过两个字符串而没有发现任何不同的字节，则您知道这些字符串是相同的并且可以返回正结果。这意味着比较两个字符串可能需要不同的时间，具体取决于字符串匹配的程度。

例如，字符串“xyzabc”和“abcxyz”的标准比较会立即看到第一个字符不同，而不会费心检查字符串的其余部分。另一方面，当比较字符串“aaaaaaaaaaB”和“aaaaaaaaaaZ”时，比较算法在确定字符串不相等之前扫描“a”块。

在网络上运行定时攻击似乎是不可能的。然而，它已经完成，并且已被证明是实用的。

在这里你可以看到这篇文章

我应该怎么做呢，当我检测到用户不存在？我绝对应该执行更多计算，但这里有什么好的技术？你们在这种情况下使用什么？

如果这有任何意义，我正在使用 C#。

我读过，我应该只Result在await我绝对确定操作已完成时使用而不是使用。我不太确定下面会发生什么，想询问经验丰富的程序员这是否是await//Result的完全安全的用法async。

public static bool Success()
{
    return 0 < Execute("DELETE FROM Table WHERE Id = 12").Result;
}

public static async Task<int> Execute(string sql)
{
    using (var con = Connection)
    {
        con.Open();
        return await con.ExecuteAsync(sql);
    }
}

假设我有一些结构,例如Rectangle:

struct Rectangle
{
    int x0, x1, y0, y1;
};

是否可以以一种能够调用的方式创建Rectangle结构:

Rectangle rec;
cin >> rec;

？我认为应该可以以某种方式实现它,但我没有足够的经验.

放弃

我不是在找这个:

cin >> rec.x0 >> rec.x1 >> rec.y0 >> rec.y1;

我设法写了这个查询:

INSERT INTO UserRoles (UserId, RoleId)
VALUES (@UserId, (SELECT Id FROM Roles WHERE Name = @Name));

它按预期工作.问题是我觉得这是编写嵌套查询的坏方法(这里 - 在Roles表中找到与指定名称匹配的角色的id ).没有嵌套查询可以做到这一点吗？

有经验的程序员可能会笑,但我正在努力学习这一点,我不知道如何才能使这个查询变得更好.我非常感谢你的建议.

假设我们有这样一个数组:

var arr = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

我想执行聚合:

var sum = arr.Aggregate((a, b) => a + b);

当然,这只是简化它的一个例子.我没有处理int,但需要合并的更复杂的对象(它们是树).但是,这种聚合效果非常糟糕,因为它从左向右迭代,添加了两个相互对立的元素.在int的情况下,这没有任何区别,但是在复杂对象的情况下,更好的解决方案是以树的方式执行聚合.这是什么意思？

                   55
              36         19
      10             26      19
  3       7      11      15      19
1   2   3   4   5   6   7   8   9   10

我希望这个架构能够说清楚.

如何在C#的LINQ中实现这一目标？

问题

我有以下界面(可以更改,但只是为了提出想法):

public interface IObj<T>
{
    void Merge(IObj<T> other);
}

问题在于Merge操作.我无法找到确保传递给方法的参数与该类型相同的方法this.例如,看看以下实现:

public class A<T> : IObj<T>
{
    public void Merge(IObj<T> other)
    {
        var casted = other as A<T>;
        if (casted == null)
            throw new ArgumentException("Incorrect type.");

        // do the actual stuff
    }
}

实现接口的任何对象始终需要与相同类型的实例合并.因此,我需要编写这个样板代码,以便在我做任何事之前尝试进行转换.

题

是否可以通过合同/界面/其他任何方式确保这一点？

我试图为一个超酷的扩展IDictionary- GetValue如果没有设置默认值为null.这是我提出的代码(不起作用):

public static TValue GetValue<TKey, TValue> (this IDictionary<TKey,
    TValue> dictionary, TKey key, TValue defaultValue = null)
{
    TValue value;
    return dictionary.TryGetValue(key, out value)
        ? value
        : defaultValue;
}

如何才能做到这一点nullables？(比如,不包括int等).