要转换IQueryable的表达式<；t>；int列表<；选择ListItem>；

我想创建这样的存储库方法：

public List<SelectListItem> AllAsSelectListItems(
    Expression<Func<T, string>> valueProperty, 
    Expression<Func<T, string>> textProperty, 
    string selectedValue = "")
{
    // what goes here? I am having serious trouble with this bit!
}

这将使我能够这样称呼它：

List<SelectListItem> selectListItems = PersonRepository.AllAsSelectListItems(
    m => m.ID,
    m => m.Name,
    selectedIDAsString
);

并且，当selectedValue参数为"1"时，它应该会产生这样的结果：

List<SelectListItem>(){
    {Value: "1", Text: "Ted", Selected: true},
    {Value: "2", Text: "Sam", Selected: false},
    {Value: "3", Text: "Tracy", Selected: false}
};

我在使用通用AllAsSelectListItems()方法时遇到问题。

到目前为止，您可以在下面的代码中看到我的尝试。但这并不理想。

我使用硬编码字符串来用T属性填充SelectListItem属性。我认为表达式树是解决方案，但我很难对其进行正确的编码。

此外，分配ID属性会破坏它，因为它是int而不是string。

最后，我还在努力将selectedValue参数与SelectListItem.Value属性进行比较。

人员类别

public class Person
{
    public int ID {get;set;}
    public string Name {get;set;}
}

控制器

public class PersonController : Controller 
{
    public IPersonRepository Repository {get;set;}
    public PersonController(IPersonRepository repository) 
    {
        Repository = repository;
    }
    public ActionResult SelectPerson(int selectedID)
    {
        string selectedIDAsString = selectedID.ToString();
        var selectListItems = Repository.AllAsSelectListItems(
            m => m.ID,
            m => m.Name,
            selectedIDAsString
        );
        return View(selectListItems);
    }
}

存储库

public class PersonRepository : Repository
{
     // various specialised methods 
}
public class Repository<T> : IRepository<T> where T : DBEntity
{
    private ApplicationDbContext db = null;
    private DbSet<T> table = null;
    public RepositoryBase()
    {
        this.db = new ApplicationDbContext();
        table = db.Set<T>();
    }
    public RepositoryBase(ApplicationDbContext db)
    {
        this.db = db;
        table = db.Set<T>();
    }
    protected virtual IQueryable<T> AllAsQueryable(
        params Expression<Func<T, object>>[] includeExpressions)
    {
        return includeExpressions.Aggregate<Expression<Func<T, object>>, IQueryable<T>>
            (table, (current, expression) => current.Include(expression));
    }
    public List<SelectListItem> AllAsSelectListItems(
        Expression<Func<T, string>> valueProperty, 
        Expression<Func<T, string>> textProperty, 
        string selectedValue = "")
    {
        // temp hard coded values until we learn how to use the expression parameters properly
        string valuePropertyHardCoded = "Name";
        string textPropertyHardCoded = "Name";
        Type currentType = typeof(T);
        var itemParam = Expression.Parameter(currentType, "x");
        var valueMember = Expression.PropertyOrField(itemParam, valuePropertyHardCoded);
        var textMember = Expression.PropertyOrField(itemParam, textPropertyHardCoded);
        var selector = Expression.MemberInit(Expression.New(typeof(SelectListItem)),
            Expression.Bind(typeof(SelectListItem).GetMember("Value").Single(), valueMember),
            Expression.Bind(typeof(SelectListItem).GetMember("Text").Single(), textMember)
        );
        var lambda = Expression.Lambda<Func<T, SelectListItem>>(
            selector, itemParam);
        return AllAsQueryable().Select(lambda.Compile()).ToList();
    }
}