使用 Lambda 和委托进行重构

Question

我刚刚安装了 VS2008，并遇到了一个问题，我确信可以使用 lambda 或委托（或组合！）来解决该问题。

    private string ReadData(TcpClient s, string terminator)
    {
        // Reads a byte steam into a string builder until either data is unavailable or the terminator has not been reached
        var sb = new StringBuilder();
        do
        {
            var numBytesRead = s.GetStream().Read(byteBuff, 0, byteBuff.Length);
            sb.AppendFormat("{0}", Encoding.ASCII.GetString(byteBuff, 0, numBytesRead));
        } while (s.GetStream().DataAvailable && !sb.ToString().Contains(terminator));

        return sb.ToString();
    }

问题是，有时我需要检查字符串是否包含两个不同值中的任何一个。 有时我可能需要检查三个值。

所以我的建议是将“!sb.ToString().Contains(terminator)”更改为传递到该方法中的函数。

我可以编写不同的函数，例如：

private bool compare1(string s, string t) {
    return s.contains(t)
}

private bool compare2(string s, string t1, string t2) {
    return (s.compare(t1) or s.compare(t2)
}

// etc...

然后，当我想要与 3 个不同的值进行比较时，创建这些函数之一的委托，然后将其传递给 ReadData() 方法。

当谈到代表时，我非常无能为力，我不确定这是否是 lambda 的正确位置，但有些东西告诉我确实如此。

调用代码是这样的：

            // Enter username .
        if (HasData(s,"login:"))
            SendData(s, switchUser + TelnetHelper.CRLF);

HasData 与 ReadData 相同，但返回一个 bool 而不是字符串（我也想使用一些技巧将其分解为一个方法 - 但这是第二个问题 - 不过请随意回答。

仅供参考：

     private bool HasData(TcpClient s, string terminator)
    {
        // Reads a byte steam into a string builder until either data is unavailable or the terminator has not been reached
        var sb = new StringBuilder();
        do
        {
            var numBytesRead = s.GetStream().Read(byteBuff, 0, byteBuff.Length);
            sb.AppendFormat("{0}", Encoding.ASCII.GetString(byteBuff, 0, numBytesRead));
        } while (s.GetStream().DataAvailable && !sb.ToString().Contains(terminator));

        return sb.ToString().Contains(terminator);
    }

Answer 1

听起来您正在寻找谓词函数。 无需对检查进行硬编码，而是将委托作为参数来执行检查

    private string ReadData(TcpClient s, Func<string,bool> predicate)
    {
        // Reads a byte steam into a string builder until either data is unavailable or the terminator has not been reached
        var sb = new StringBuilder();
        do
        {
            var numBytesRead = s.GetStream().Read(byteBuff, 0, byteBuff.Length);
            sb.AppendFormat("{0}", Encoding.ASCII.GetString(byteBuff, 0, numBytesRead));
        } while (s.GetStream().DataAvailable && !predicate(sb));

        return sb.ToString();
    }

然后您可以创建多个包装器，这些包装器仅创建适当的委托并将其传递下来

public bool HasData(TcpClient c, string terminator) {
  return HasData(c, (s) => s.Contains(terminator));
}

public bool HasData(TcpClient c, string t1, string t2) {
  return HasData(c, (s) => s.Contains(t1) || s.Contains(t2));
}

您甚至可以基于任意数量的终止符动态构建委托

public bool HasData(TcpClient c, params string[] terminatorList) {
  return HasData(c, (s) => terminatorList.Where(x => s.Contains(x)).Any());
}

Answer 2

一种选择是重载 ReadData() 方法以获取包含您要检查的值的字符串数组。 使用 扩展方法，您可以扩展 Contains() 来获取字符串数组。

您的 ReadData() 方法可以是：

private string ReadData(TcpClient s, string[] terminators) {
    // Reads a byte steam into a string builder until either data is unavailable or the terminator has not been reached
    var sb = new StringBuilder();
    do
    {
        var numBytesRead = s.GetStream().Read(byteBuff, 0, byteBuff.Length);
        sb.AppendFormat("{0}", Encoding.ASCII.GetString(byteBuff, 0, numBytesRead));
    } while (s.GetStream().DataAvailable && !sb.ToString().Contains(terminators));

    return sb.ToString();
}

Contains() 方法扩展可以是：

public static bool Contains ( this String str , String[] testValues )
{
    foreach ( var value in testValues )
    {
        if ( str.Contains( value ) )
            return true;
    }
    return false;
}

此实现消除了每次要测试不同数量的字符串时创建新谓词的需要。

Answer 3

因为 lambda 的语法对我自己（以及我团队的其他成员）来说有点陌生，所以我最终采用了稍微不同的解决方案。 当从上面的 .Any() 函数修改时，我无法弄清楚 .All() 的语法。

我还需要一个 .All() 函数，以确保找到列表中的所有终止符。 所以我最终采用了类似以下的内容：

delegate bool Predicate (string s, params [] string terminators);

bool HasAll(string s, params string [] terminators) {
    foreach (var t in terminators) {
       if (!s.contains(t)) return false;
    }
    return true;
}

bool HasAny(string s, params string [] terminators) {
    foreach (var t in terminators) {
        if (s.contains(t)) return true;
    }
    return false;
}
// Just looking now, I could also pass in a bool to switch between the two and remove one of these functions. But this is fairly clear


string ReadData(TcpClient sock, Function predicate, params [] string terminators) {
    var sb = new StringBuilder();
    do
    {  
        var numBytesRead = s.GetStream().Read(byteBuff, 0, byteBuff.Length);
        sb.AppendFormat("{0}", Encoding.ASCII.GetString(byteBuff, 0, numBytesRead));
    } while (s.GetStream().DataAvailable && !predicate(sb.ToString(), terminators);

    return sb.ToString();
}

然后调用代码如下所示：

private void someFunc() 
{
    Predicate any = new Predicate(HasAny);
    Predicate all = new Predicate(HasAll);
    String response;

    // Check all strings exist
    response = ReadData(this.sock, all, "(", ")", "->")
    if (all(response, "(", ")", "->")
        SendData(this.sock, ...);

    // Check any string exists
    response = ReadData(this.sock, any, "Hi", "Hey", "Hello");
    if (any(response, "Hi", "Hey", "Hello"))
       SendData(this.sock, ...);
}

我可能会在 Has[Any|All] 函数中添加空检查，将 do..while 反转为一段时间，然后检查响应！ = null 而不是重复参数。 该解决方案适合我的所有用例，并且我认为具有相当的人类可读性。 只要我做出上面提到的小改变。

这整件事凸显了我学习 lambda 表达式的需要！