LINQ to entities - Sélectionner tous les amis de l'Utilisateur et le Chat entre eux

Question 1

Comment puis-je Sélectionner tous les amis de l'utilisateur actuellement connecté et les Chats Privés (Id Chat) entre l'utilisateur et de ses amis? Je suis en mesure d'obtenir les amis de l'utilisateur, mais j'ai du mal également à obtenir le Chat entre eux.

            // Select all the User's friends and the chat (Id) between them
            var friends = await _context.Friendships // Get the Friendships
                .Include(x => x.Friend).ThenInclude(x => x.ChatUsers).ThenInclude(x => x.Chat)
                .Where(x => x.Status == StatusCode.Accepted && x.ApplicationUserId == userId)
                .Select(x => x.Friend)
                .ToListAsync();

L'amitié table

    public class Friendship
    {
        // The primary keys/foreign keys of the associated tables
        public string ApplicationUserId { get; set; }
        public string ApplicationFriendUserId { get; set; }

        // Reference to the user that has the friend
        public User ApplicationUser { get; set; }

        // Reference to the friend
        public User Friend { get; set; }

        // The status of the friendship
        public StatusCode Status { get; set; }
    }

Table utilisateur

    public class User : IdentityUser
    {
        // Reference to all user's chats
        public ICollection<ChatUser> ChatUsers { get; set; }

        // Reference to all the user's friendships
        public ICollection<Friendship> UsersFriendships { get; set; }

        // Reference to all the friend's friendships (their point of view)
        public ICollection<Friendship> FriendsFriendships { get; set; }
    }

ChatUser table

    public class ChatUser
    {
        // The primary key/foreign keys of the associated tables
        public int ChatId { get; set; }
        public string UserId { get; set; }

        // The role that the User can be
        public UserRole Role { get; set; }

        // Reference to the chat
        public Chat Chat { get; set; }

        // Reference to the user
        public User User { get; set; }
    }

Chat

    
    public class Chat
    {
        // The primary key
        public int Id { get; set; }

        // The chat's name
        public string Name { get; set; }

        // The chat type, e.g room, private
        public ChatType Type { get; set; }

        // Reference to all the Chat's Users
        public ICollection<ChatUser> ChatUsers { get; set; }
    }

Merci

Question 2

Cette requête:

var friends = await _context.Friendships // Get the Friendships
    .Include(x => x.Friend).ThenInclude(x => x.ChatUsers).ThenInclude(x => x.Chat)
    .Where(x => x.Status == StatusCode.Accepted && x.ApplicationUserId == userId)
    .Select(x => x.Friend)
    .ToListAsync();

... charge de l'utilisateur des amis avec les amis correspondant chats qui pourrait inclure des chats pas à l'utilisateur courant.

Avec cette structure de domaine pour les chats et les amitiés il semble plutôt difficile de les essayer et de les relier de façon significative. Il est probablement possible avec une simple approche de deux passes:

var friendIds = _context.Users
    .Where(x => s.UserId == userId)
    .SelectMany(x => x.UsersFriendships.Where(f => f.Status == StatusCode.Accepted).Select(f => f.ApplicationFriendUserId))
    .ToList(); // Get all accepted Friend IDs.


 var chats = _context.Chats
     .Where(x => x.ChatUsers.Any(cu => cu.UserId) && x => x.ChatUsers.Any(cu => friendIds.Contains(cu.UserId)
     .Select(x => new 
     {
         Chat = x,
         Friends = x.ChatUsers.Where(cu => friendIds.Contains(cu.UserId)).Select(cu => cu.User).ToList()
      }).ToList();

Les Chats sont liées à deux utilisateurs ou plus, et elles ne sont pas restreintes/lié des amitiés.

Joe pourrait être amis avec Sam, Jane et John et chats active:

Chat 1: Joe <-> Sam

Chat 2: Joe <-> Jane

Chat 3: Joe <-> Jeanne <-> Sam

Chat 4: Joe <-> Frank

Chat 5: Joe <-> Franc <-> Sam

Nous souhaitons Chats 1, 2, 3, et 5 retournés. Il n'existe pas de conversations avec Jean, et nous ne nous soucions pas la discussion avec Frank, mais ne se soucient l'un avec Frank & Sam depuis que Sam est un ami. L'objectif serait d'identifier les chats que Joe est en participant à l'une ou plusieurs de ses amis. Pour chaque match, nous revenons à la discussion et à tous les Amis actuellement également en que le chat.

La mise en garde de la passe de deux approche est qu'elle suppose que la liste d'amis resterait raisonnablement petit, pas assez grande pour dépasser la IN() liste des produits pour obtenir la correspondance des Chats.

Steve Py · Answer 1 · 2021-11-23T04:50:49

Cette requête:

var friends = await _context.Friendships // Get the Friendships
    .Include(x => x.Friend).ThenInclude(x => x.ChatUsers).ThenInclude(x => x.Chat)
    .Where(x => x.Status == StatusCode.Accepted && x.ApplicationUserId == userId)
    .Select(x => x.Friend)
    .ToListAsync();

... charge de l'utilisateur des amis avec les amis correspondant chats qui pourrait inclure des chats pas à l'utilisateur courant.

Avec cette structure de domaine pour les chats et les amitiés il semble plutôt difficile de les essayer et de les relier de façon significative. Il est probablement possible avec une simple approche de deux passes:

var friendIds = _context.Users
    .Where(x => s.UserId == userId)
    .SelectMany(x => x.UsersFriendships.Where(f => f.Status == StatusCode.Accepted).Select(f => f.ApplicationFriendUserId))
    .ToList(); // Get all accepted Friend IDs.


 var chats = _context.Chats
     .Where(x => x.ChatUsers.Any(cu => cu.UserId) && x => x.ChatUsers.Any(cu => friendIds.Contains(cu.UserId)
     .Select(x => new 
     {
         Chat = x,
         Friends = x.ChatUsers.Where(cu => friendIds.Contains(cu.UserId)).Select(cu => cu.User).ToList()
      }).ToList();

Les Chats sont liées à deux utilisateurs ou plus, et elles ne sont pas restreintes/lié des amitiés.

Joe pourrait être amis avec Sam, Jane et John et chats active:

Chat 1: Joe <-> Sam

Chat 2: Joe <-> Jane

Chat 3: Joe <-> Jeanne <-> Sam

Chat 4: Joe <-> Frank

Chat 5: Joe <-> Franc <-> Sam

Nous souhaitons Chats 1, 2, 3, et 5 retournés. Il n'existe pas de conversations avec Jean, et nous ne nous soucions pas la discussion avec Frank, mais ne se soucient l'un avec Frank & Sam depuis que Sam est un ami. L'objectif serait d'identifier les chats que Joe est en participant à l'une ou plusieurs de ses amis. Pour chaque match, nous revenons à la discussion et à tous les Amis actuellement également en que le chat.

La mise en garde de la passe de deux approche est qu'elle suppose que la liste d'amis resterait raisonnablement petit, pas assez grande pour dépasser la IN() liste des produits pour obtenir la correspondance des Chats.

LINQ to entities - Sélectionner tous les amis de l'Utilisateur et le Chat entre eux

La question

La meilleure réponse

Dans d'autres langues

Cette page est dans d'autres langues

Populaires dans cette catégorie

Questions populaires dans cette catégorie