0

我的数据库中存储了一个字符串：

"Users.ElementAt(1).LastName"

然后我有一个像这样的对象：

        MyClass myclass = new MyClass ()
        {
            Users = new List<User>()
            {
                new User()
                {
                    LastName = "LastName1"
                },
                new User()
                {
                    LastName = "LastName2"
                },
            }
        };

有没有办法针对我的对象解析/评估/运行给定的字符串以获取每个用户的姓氏？

我一直在使用 DynamicLinq 库，但我遇到了 ElementAt(1) 的问题，并显示错误消息：

“不存在适用的聚合方法‘ElementAt’”

有人可以在这里提供一些指导吗？我是否必须求助于编写自己的解析器并使用反射？

4

3 回答 3

0

我不确定你是否真的需要动态 linq 来做你想做的事。根据我的经验，如果您使用 C# .NET 4.5 或 4.0，只要常规 System.Linq 应该处理查找位置索引，并且元素应该可以正常工作。这是一个应该可以正常工作的简单控制台应用程序：

using System;
using System.Collections.Generic;
using System.Linq;


public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}


class Program
{
    public static List<User> Users;

    static void Main(string[] args)
    {
            Users = new List<User>
            {
                new User
                    {
                        FirstName = "Brett",
                        LastName = "M"
                    },
                new User
                    {
                        FirstName = "John",
                        LastName = "Doe"
                    },
            new User
                {
                    FirstName = "Sam",
                    LastName = "Dilat"
                }
            };

        Console.WriteLine("Should work as long as object is defined and instantiated");
        Console.WriteLine(Users.ElementAt(1).FirstName);


        Console.WriteLine("\nIterate Through List with Linq\n I use a string you can add to another list or whatever\n\n");

        string s = "";

        Users.ForEach(n => s += "Position: " + Users.IndexOf(n) + " " + n.LastName + Environment.NewLine);
        Console.WriteLine(s);

        Console.ReadLine();
    }

}

如果您只想通过该集合的属性在集合中查找特定对象，则可以使用“FindIndex”方法：

Console.WriteLine("Index of Dilat: " + Users.FindIndex(n => n.LastName.Equals("Dilat")));

编辑 9-27-13 用于拆分字符串。

如果您想获取一个字符串并将其拆分为一个很好的可启用列表以进行迭代，您也可以这样做。您只需要找到分隔符。如果你没有，你将不得不使用一些更复杂的正则表达式魔法。

保持一切不变，但替换我的 MAIN 方法：

string split = "Brett,Same,John,Frank";

        List<string> stringList = split.Split(',').ToList();

        string s = "";

        stringList.ForEach(n => s += n + Environment.NewLine);

        s += "\n\nFor Observing Element at\n";

        s += "John is at: " + stringList.FindIndex(n => n.Equals("John"));

        s += "\n\nGetting Poco Objects assigned and listed\n";

        var list = stringList.Select(u => new User
            {
                FirstName = u,
                LastName = "Something"
            }).ToList();

        list.ForEach(n => s += "User: " + n.FirstName + " " + n.LastName + "At: " + list.IndexOf(n) + Environment.NewLine);
于 2013-09-26T22:50:39.790 回答
0 
var allLastNamesInList= Users.Select(x=> x.LastName).toList();

该语句将遍历列表并获取所有姓氏。您甚至可以使用 order by，以便按顺序获取姓氏。

这是您正在寻找的要求还是不同的要求？

于 2013-09-27T01:53:46.457 回答
0

看起来 DynamicLinq 的表达式解析器只支持标准 LINQ 运算符方法的子集：

interface IEnumerableSignatures
{
    void Where(bool predicate);
    void Any();
    void Any(bool predicate);
    void All(bool predicate);
    void Count();
    void Count(bool predicate);
    void Min(object selector);
    void Max(object selector);
    void Sum(int selector);
    void Sum(int? selector);
    void Sum(long selector);
    void Sum(long? selector);
    void Sum(float selector);
    void Sum(float? selector);
    void Sum(double selector);
    void Sum(double? selector);
    void Sum(decimal selector);
    void Sum(decimal? selector);
    void Average(int selector);
    void Average(int? selector);
    void Average(long selector);
    void Average(long? selector);
    void Average(float selector);
    void Average(float? selector);
    void Average(double selector);
    void Average(double? selector);
    void Average(decimal selector);
    void Average(decimal? selector);
    void Take(int count);
    void Union(IQueryable right);
    void OrderBy(LambdaExpression exp);
    void OrderByDescending(LambdaExpression exp);
}

如您所见，ElementAt不在其中。好消息是，简单地添加void ElementAt(int index);到IEnumerableSignatures似乎工作得很好。也就是说，当然，假设您使用的 LINQ 查询提供程序将处理ElementAt运算符；完全有可能不会。

但是，如果修改 DynamicLinq 源不是一个选项，那么不，核心 .NET Framework 或 LINQ 中没有工具可以解析和评估这些类型的表达式。还有其他选择（请参阅 ScriptCS，Roslyn），但我怀疑您正在朝着要解决的任何实际问题的“矫枉过正”的解决方案漂移。

于 2013-10-10T16:34:40.417 回答