Question

我想将此方法中的foreach转换为linq表达式。我有2次尝试/捕获，因为我不能总是指望在guid或guidToFind列表中传递的字符串是有效的guid字符串。

    public static bool IsGuidInList(List<string> guids, string guidToFind)
    {
        try
        {
            var guid = new Guid(guidToFind.Trim());
            foreach (var g in guids)
            {
                try
                {
                    var g2 = new Guid(g.Trim());
                    if (g2 == guid)
                        return true;
                }
                catch {} // swallow exception
            }
        }
        catch{} // swallow exception
        return false;
    }

Answer 1

   var tg = Guid.Empty; 
   guids.Any(g=> g!= null 
       && Guid.TryParse(g.Trim(), out tg) && new Guid(g.Trim()) == guid)

Answer 2

public static bool IsGuidInList(List<string> guids, string guidToFind)
{
    try
    {
        var guid = new Guid(guidToFind.Trim());
        return
            guids
            .Select(x =>
            {
                Guid result;
                return Guid.TryParse(x, out result) ? (Guid?)result : null;
            })
            .Where(x => x.HasValue)
            .Any(x => x.Value == guid);
    }
    catch { } // swallow exception
    return false;
}

Answer 3

这个答案与已发布的其他答案没有什么特别的不同，但我个人会用这个：

    public static bool ContainsGuid(this IEnumerable<string> guids, string guidToFind)
    {
        if (guids == null) throw new ArgumentNullException(nameof(guids));
        if (guidToFind == null) throw new ArgumentNullException(nameof(guidToFind));

        if (!Guid.TryParse(guidToFind, out var guid)) 
            throw new ArgumentException($"Could not convert '{guidToFind}' to a GUID");

        return guids
            .Select(s => Guid.TryParse(s, out var result) ? (Guid?)result : null)
            .Contains(guid);
    }

差异在于：

扩展方法（个人喜好）
较新的C＃功能，例如'out var result'（个人喜好）
明确验证参数（取决于你所追求的行为，但我是一个忠实粉丝）

最后一项引出了一个重要观点：如果你的程序将一组字符串作为输入作为输入，那么为什么不在那时验证这些字符串并保留一个IEnumerable of Guid？为GUID做同样的事情，代码变成了：

IEnumerable<Guid> guidList = // validated elsewhere
var found = guidList.Contains(guid);

Answer 4

对于伟大的答案而言，不过我和杰森·博伊德斯的答案一致，但是稍微修改了我自己以摆脱最后的尝试/捕获。我用我期望的结果运行这些测试：

bad guidToFind string
好的guidToFind字符串，所有有效guid字符串的列表

好的guidToFind字符串，大多数有效的guid字符串列表

public static bool IsGuidInList(List<string> guids, string guidToFind)
{
    Guid guid;
    if (!Guid.TryParse(guidToFind.Trim(), out guid))
        return false;

    return
        guids
            .Select(x =>
            {
                Guid result;
                return Guid.TryParse(x, out result) ? (Guid?)result : null;
            })
            .Where(x => x.HasValue)
            .Any(x => x.Value == guid);
}

更新：在使用上述方法进行代码审查的反馈后，我能够进行更多改进，结果就是这样：

    public static bool IsGuidInList(IEnumerable<string> guids, string guidToFind)
    {
        Guid guid;
        if (!Guid.TryParse(guidToFind.Trim(), out guid))
            return false;

        return guids.Any(x => { Guid result;
            Guid.TryParse(x, out result);
            return result == guid;
        });
    }

Answer 5

不像其他解决方案那样简洁，但我发现它可读

    public static bool IsGuidInList(List<string> guids, string guidToFind)
    {
        Guid outGuid;

        var inGuidToFind = Guid.TryParse(guidToFind, out outGuid) ? outGuid : Guid.Empty;
        if (inGuidToFind == Guid.Empty)
            return false;

        var inGuids = new List<Guid>();
        guids.Where(i => Guid.TryParse(i, out outGuid)).ForEach(i => inGuids.Add(new Guid(i)));

        return inGuids.Contains(inGuidToFind);
    }

用guid比较foreq到linq

5 个答案: