Блог

Вот что я сделал для Select пользователей в своей модели, а затем удалил все null записи:

         model.Users = users
            .Select(u =>
        {
            var membershipUser = Membership.GetUser(u.UserName);
            return membershipUser != null
                ? new UserBriefModel
                {
                    Username = u.UserName,
                    Fullname = u.FullName,
                    Email = membershipUser.Email,
                    Roles = u.UserName.GetRoles()
                }
                : null;
        })
            .Where(u => u != null)
            .ToList();
  

Интересно, есть ли способ объединить SELECT WHERE предложение and .

Я пытался:

         model.Users = users
            .Select(u =>
            {
                var membershipUser = Membership.GetUser(u.UserName);
                if (membershipUser != null)
                    return new UserBriefModel
                    {
                        Username = u.UserName,
                        Fullname = u.FullName,
                        Email = membershipUser.Email,
                        Roles = u.UserName.GetRoles()
                    };
            })
            .ToList();
  

Но intellisense предлагает синтаксическую ошибку. Что заставляет меня добавить return null оператор:

         model.Users = users
            .Select(u =>
            {
                var membershipUser = Membership.GetUser(u.UserName);
                if (membershipUser != null)
                    return new UserBriefModel
                    {
                        Username = u.UserName,
                        Fullname = u.FullName,
                        Email = membershipUser.Email,
                        Roles = u.UserName.GetRoles()
                    };
                return null;
            })
            .ToList();
  

Итак, как правильно написать это SELECT утверждение, чтобы в моей модели были выбраны только допустимые записи?

Концептуально здесь фактически есть три операции:

1. спроецируйте имя пользователя на пользователя-участника
2. отфильтровывать пользователей с нулевым членством
3. спроецируйте пользователей-членов на модель

Именно так должен выглядеть ваш запрос. Ваш самый первый запрос уже пытался объединить шаги 1 и 3 вместе, но вы испытываете трудности, потому что второй шаг действительно должен быть посередине двух, и препятствия, которые вам нужно преодолеть, чтобы обойти, не очень хороши.

Запрос на самом деле становится более простым и читаемым (и становится идиоматическим кодом LINQ), когда вы представляете все три операции по отдельности.

 model.Users = users
    .Select(user => new
    {
        user,
        membershipUser = Membership.GetUser(user.UserName)
    })
    .Where(pair => pair.membershipUser != null)
    .Select(pair => new UserBriefModel
    {
        Username = pair.user.UserName,
        Fullname = pair.user.FullName,
        Email = pair.membershipUser.Email,
        Roles = pair.user.UserName.GetRoles()
    })
    .ToList();
  

Это запрос, который также может быть более эффективно написан в синтаксисе запроса:

 model.Users = from user in users
                let membershipUser = Membership.GetUser(user.UserName)
                where membershipUser != null
                select new UserBriefModel
                {
                    Username = user.UserName,
                    Fullname = user.FullName,
                    Email = membershipUser.Email,
                    Roles = user.UserName.GetRoles()
                };
  

Что касается буквального вопроса о том, можете ли вы объединить проецирование и фильтрацию в одну операцию LINQ, это, безусловно, возможно. Это было бы неподходящим решением проблемы, но использование SelectMany может позволить вам фильтровать и проецировать одновременно. Это можно сделать, проецируя элемент либо на последовательность из одного элемента, содержащую значение, на которое вы хотите его спроецировать, либо на пустую последовательность, основанную на предикате.

 model.Users = users
    .SelectMany(u =>
    {
        var membershipUser = Membership.GetUser(u.UserName);
        return membershipUser != null
            ? new[]{ new UserBriefModel
            {
                Username = u.UserName,
                Fullname = u.FullName,
                Email = membershipUser.Email,
                Roles = u.UserName.GetRoles()
            }}
            : Enumerable.Empty<UserBriefModel>();
    }).ToList();
  

Конечно, каждый раз, когда вы используете этот код, котенок погибает. Не убивайте котят; вместо этого используйте предыдущий запрос.

Я не думаю, что это возможно, Select сопоставлю все 1-1, насколько я знаю … если вы пытаетесь отфильтровать, вам понадобится Where .

редактировать редактировать: я больше не верю SelectMany , что могу это сделать (как показал Серви).

Я не знаю ни о каком методе Linq, который позволит вам произвольно добавлять или не добавлять значение в результирующий IEnumerable.

Для этого лямбда (селектор, предикат, фильтр …) должен иметь возможность управлять этим добавлением. И только предикаты (Where ) могут это сделать. В вашем случае вам нужно будет выполнить предикат (Where) и выбрать. Не существует комбинационного метода, который будет выполнять оба для вас одновременно, за исключением одного непрямого метода, описанного в конце ответа.

 model.Users = users
   .Where(u => Membership.GetUser(u.UserName) != null)
   .Select(u =>
    {
       return new UserBriefModel
         {
             Username = u.UserName,
             Fullname = u.FullName,
             Email = Membership.GetUser(u.UserName).Email,
             Roles = u.UserName.GetRoles()
          };
    })
    .ToList();
  

Мы либо получаем два Membership.getUser(u.UserName) с такой предварительной фильтрацией, либо заканчиваем вашей первоначальной постфильтрацией.

Это просто меняет сложность. И трудно сказать, где производительность будет лучше. Это зависит от того, является ли Membership.GetUser это быстрым, и есть много пользователей, не являющихся членами — для моего примера. Или, если Membership.GetUser это требует много ресурсов и мало пользователей, не являющихся членами, ваш пример с postfilter лучше.

Как и любое решение, основанное на производительности, оно должно быть тщательно рассмотрено и проверено. В большинстве случаев разница минимальна.

Как уже было показано в другом сообщении и указано г-ном ‘Servy’, это можно сделать, используя один вызов SelectMany SelectMany, выбирая либо пустой IEnumerable, либо 1-элементный массив. Но я по-прежнему считаю первое утверждение технически правильным, потому что SelectMany возвращает коллекцию элементов (он точно не добавляет или не добавляет один элемент напрямую):

  model.Users = users
       .SelectMany(u =>
       {
           var membership = Membership.GetUser(u.UserName);

           if (membership == null)
               return Enumerable.Empty<UserBriefModel>();

           return new UserBriefModel[]
           {
               new UserBriefModel()
               {
                   Username = u.UserName,
                   Fullname = u.FullName,
                   Email = membership.Email,
                   Roles = u.UserName.GetRoles()
               }
           };
       })
        .ToList();
  

Для этого можно использовать один метод:

 private IEnumerable<UserBriefModel> SelectUserBriefModels(IEnumerable<User> users)
{
    foreach (var user in users)
    {
        var membershipUser = Membership.GetUser(user.UserName);
        if (membershipUser != null)
        {
            yield return new UserBriefModel
            {
                Username = user.UserName,
                Fullname = user.FullName,
                Email = membershipUser.Email,
                Roles = user.UserName.GetRoles()
            };
        }
    }
}
  

Вы бы использовали его так:

 model.Users = SelectUserBriefModels(users);
  

 model.Users = users
    .Where(u => u.Membership != null)
    .Select(u => new UserBriefModel
            {
                Username = u.UserName,
                Fullname = u.FullName,
                Email = u.Membership.Email,
                Roles = u.UserName.GetRoles()
            })
    .ToList();
  

Сначала фильтруйте, затем выберите. Для этого решения вам необходимо иметь свойство навигации, чтобы вы могли делать u.Membership.Email вместо membershipUser.Email .

Мои пользователи выглядят примерно так:

 public class UserProfile
{
    // other properties

    public virtual Membership Membership { get; set; }
}
  

где Membership находится объект, представляющий таблицу членства и отображаемый через:

 modelBuilder.Entity<Membership>()
   .HasRequired<UserProfile>(m => m.User)
   .WithOptional(u => u.Membership);
  

Затем вы можете выбрать все одним запросом. Некоторые другие решения здесь также работают нормально, но каждый вызов Membership.GetUser(u.UserName) приводит к одному дополнительному вызову DB.