LINQ：如何声明 IEnumerable[AnonymousType]？

Question

这是我的功能：

    private IEnumerable<string> SeachItem(int[] ItemIds)
    {
        using (var reader = File.OpenText(Application.StartupPath + @"\temp\A_A.tmp"))
        {
            var myLine = from line in ReadLines(reader)
                         where line.Length > 1
                         let id = int.Parse(line.Split('\t')[1])
                         where ItemIds.Contains(id)
                         let m = Regex.Match(line, @"^\d+\t(\d+)\t.+?\t(item\\[^\t]+\.ddj)")
                         where m.Success == true
                         select new { Text = line, ItemId = id, Path = m.Groups[2].Value };
            return myLine;
        }
    }

我收到一个编译错误，因为“myLine”不是 IEnumerable[string]，而且我不知道如何编写 IEnumerable[Anonymous]

“无法将类型'System.Collections.Generic.IEnumerable[AnonymousType#1]'隐式转换为'System.Collections.Generic.IEnumerable[string]'”

Answer 1

您不能声明IEnumerable<AnonymousType>，因为该类型在构建时没有（已知）名称。因此，如果您想在函数声明中使用此类型，请将其设为普通类型。或者只是修改您的查询以返回 IENumerable<String> 并坚持使用该类型。

或者使用下面的 select 语句返回 IEnumerable<KeyValuePair<Int32, String>>。

select new KeyValuePair<Int32, String>(id, m.Groups[2].Value)

Answer 2

我不一定推荐这个... 这是对类型系统的一种颠覆，但您可以这样做：

1) 更改您的方法签名以返回 IEnumerable（非泛型）

2) 添加cast by example 助手：

public static class Extensions{
    public static IEnumerable<T> CastByExample<T>(
            this IEnumerable sequence, 
            T example) where T: class
    {
        foreach (Object o in sequence)
            yield return o as T;
    }
}

3) 然后像这样调用方法：

var example = new { Text = "", ItemId = 0, Path = "" };
foreach (var x in SeachItem(ids).CastByExample(example))
{
    // now you can access the properties of x 
    Console.WriteLine("{0},{1},{2}", x.Text, x.ItemId, x.Path);
}

你就完成了。

关键在于，如果您在两个地方创建具有相同顺序、类型和属性名称的匿名类型，则类型将被重用。了解这一点后，您可以使用泛型来避免反射。

希望这会有所帮助 亚历克斯

Answer 3

SearchItem 上的方法签名表明该方法返回一个IEnumerable<string>，但在您的 LINQ 查询中声明的匿名类型不是string 类型。如果要保留相同的方法签名，则必须将查询更改为仅选择 strings。例如

return myLine.Select(a => a.Text);

如果您坚持返回查询选择的数据，如果您将 return 语句替换为

，则可以返回 IEnumerable<object>

return myLine.Cast<object>();

然后你可以使用反射来消费对象。

但实际上，如果您要在声明它的方法之外使用匿名类型，您应该定义一个类并让该方法返回该类的 IEnumerable。匿名类型很方便，但容易被滥用。

Answer 4

您的函数试图返回 IEnumerable，而您正在执行的 LINQ 语句实际上返回的是 IEnumerable，其中 T 是编译时生成的类型。匿名类型并不总是匿名的，因为它们在编译代码后采用特定的具体类型。

但是，由于匿名类型在编译之前是短暂的，因此只能在创建它们的范围内使用。为了在您提供的示例中支持您的需求，我想说最简单的解决方案是创建一个简单的实体存储您的查询结果：

public class SearchItemResult
{
    public string Text { get; set; }
    public int ItemId { get; set; }
    public string Path { get; set; }
}

public IEnumerable<SearchItemResult> SearchItem(int[] itemIds)
{
    // ...
    IEnumerable<SearchItemResult> results = from ... select new SearchItemResult { ... }
}

但是，如果您的最终目标不是检索某种对象，并且您只对路径感兴趣...那么您仍然可以生成一个 IEnumerable：

IEnumerable<string> lines = from ... select m.Groups[2].Value;

我希望这有助于阐明您对 LINQ、可枚举和匿名类型的理解。 :)

Answer 5

返回 ValueTuple 而不是匿名类。例如（使用“命名元组”）-

(Text: line, ItemId: id, Path: m.Groups[2].Value)

https://docs.microsoft.com/en-us/dotnet/csharp/tuples

而不是-

new { Text = line, ItemId = id, Path = m.Groups[2].Value }

ValueTuple 是 C# 版本 7 的一部分，最初是作为单独的 NuGet 包 (System.ValueTuple) 实现的。从 .NET 4.7 开始，它是一种内置类型。对于 .NET Core，2.0 之前的版本需要 NuGet 包，但它是 2.0 版内置的。

Answer 6

要记住的一点是LINQ 语句使用deferred execution。这意味着您的LINQ 语句实际上不会执行，除非您在foreach 语句中对其进行迭代，或者在myLine 上调用.ToList() 方法。
对于您的示例，请尝试更改：

return myLine;

收件人：

return myLine.ToList();

Answer 7

此链接可能对最终来到这里的其他人有用 https://idreesdotnet.blogspot.com/2019/08/c-how-to-create-list-of-anonymous-type.html

第一个解决方案（共 6 个）非常简单

1：首先创建匿名类型的对象，然后将其传递给数组并调用 ToList() 方法。

   var o1 = new { Id = 1, Name = "Foo" };
   var o2 = new { Id = 2, Name = "Bar" };
   var list = new[] { o1, o2 }.ToList();