C＃模型用户，朋友请求和实体框架代码的朋友 [英] C# Model User, Friend Requests and Friends with Entity Framework Code First

问题描述

我以前在这方面提到过一个关于类似话题的问题，但从此采取了不同的做法。这是我的模型：

  public class ApplicationUser：IdentityUser< int，CustomUserLogin，CustomUserRole，CustomUserClaim> 
 {
 public ApplicationUser（）
 {
 Friends = new List< Friend>（）; 
} 
 
 [必需] 
 public string Alias {get;组; } 
 
 public virtual ICollection< Friend>新新旗新新新新新新新新新新新新新新新新新新新新新组; 
} 
 
 public class Friend 
 {
 public virtual int Id {get;组; } 
 
 public virtual ApplicationUser RequestedBy {get;组; } 
 
 public virtual ApplicationUser RequestedTo {get;组; } 
 
 public DateTime？ RequestTime {get;组; } 
 
 public FriendRequestFlag FriendRequestFlag {get;组; } 
} 
 
 public enum FriendRequestFlag 
 {
无，
已批准，
被拒绝，
已被阻止，
垃圾邮件
}; 
  

我可以添加这个方法的朋友，当我从数据库中获取它们时，它们会填充，例如： p>

  public void AddFriendRequest（ApplicationUser user，ApplicationUser friendUser）
 {
 var friendRequest = new Friend（）
 {
 RequestedBy = user，
 RequestedTo = friendUser，
 RequestTime = DateTime.Now，
 FriendRequestFlag = FriendRequestFlag.None 
}; 
 
 user.Friends.Add（friendRequest）; 
} 
  

当我运行上面的代码时，数据库中的friend表格如下所示执行后：

当我得到一个用户我会wan Entity Framework可以获得Friend的所有行，用户是 RequestedBy 或 RequestedTo 。这可能与EF有关吗？例如使用Fluent API？我还要映射密钥，以便不需要 [ApplicationUser_Id] 。

解决方案

@Mukesh感谢您的答案，但我决定采取另一种方法，因为您的解决方案没有获得Friend的所有行是用户是RequestedBy或RequestedTo。这是我的解决方案：

  public class ApplicationUser：IdentityUser< int，CustomUserLogin，CustomUserRole，
 CustomUserClaim> 
 {
 public async任务< ClaimsIdentity> GenerateUserIdentityAsync（UserManager< ApplicationUser，int> manager，string authenticationType）
 {
 //请注意，authenticationType必须与CookieAuthenticationOptions.AuthenticationType 
中定义的那个匹配。var userIdentity = await manager.CreateIdentityAsync（this， authenticationType）; 
 //在此添加自定义用户声明
 return userIdentity; 
} 
 
 public ApplicationUser（）
 {
 SentFriendRequests = new List< Friend>（）; 
 ReceievedFriendRequests = new List< Friend>（）; 
} 
 
 [必需] 
 public string Alias {get;组; } 
 
 public string Name {get;组; } 
 
 public byte [] ProfilePicture {get;组; } 
 
 public virtual ICollection< Friend> SentFriendRequests {get;组; } 
 
 public virtual ICollection< Friend> ReceievedFriendRequests {get;组; } 
 
 [NotMapped] 
 public virtual ICollection< Friend>朋友{
 get 
 {
 var friends = SentFriendRequests.Where（x => x.Approved）.ToList（）; 
 friends.AddRange（ReceievedFriendRequests.Where（x => x.Approved））; 
返回朋友; 
}} 
} 
 
 protected override void OnModelCreating（DbModelBuilder modelBuilder）
 {
 base.OnModelCreating（modelBuilder）; 
 
 modelBuilder.Conventions.Remove< OneToManyCascadeDeleteConvention>（）; 
 modelBuilder.Conventions.Remove< ManyToManyCascadeDeleteConvention>（）; 
 
 modelBuilder.Entity< Friend>（）
 .HasRequired（a => a.RequestedBy）
 .WithMany（b => b.SentFriendRequests）
 .HasForeignKey（c => c.RequestedById）; 
 
 modelBuilder.Entity< Friend>（）
 .HasRequired（a => a.RequestedTo）
 .WithMany（b => b.ReceievedFriendRequests）
 .HasForeignKey（c => c.RequestedToId）; 
} 
 
 public class Friend 
 {
 [Key，Column（Order = 0）] 
 public int RequestedById {get;组; } 
 [Key，Column（Order = 1）] 
 public int RequestedToId {get;组; } 
 public virtual ApplicationUser RequestedBy {get;组; } 
 public virtual ApplicationUser RequestedTo {get;组; } 
 
 public DateTime？ RequestTime {get;组; } 
 
 public DateTime？ BecameFriendsTime {get;组; } 
 
 public FriendRequestFlag FriendRequestFlag {get;组; } 
 
 [NotMapped] 
 public bool Approved => FriendRequestFlag == FriendRequestFlag.Approved; 
 
 public void AddFriendRequest（ApplicationUser user，ApplicationUser friendUser）
 {
 var friendRequest = new Friend（）
 {
 RequestedBy = user，
 RequestedTo = friendUser，
 RequestTime = DateTime.Now，
 FriendRequestFlag = FriendRequestFlag.None 
}; 
 user.SentFriendRequests.Add（friendRequest）; 
} 
} 
 
 public enum FriendRequestFlag 
 {
无，
已批准，
被拒绝，
已阻止， 
垃圾邮件
}; 
  

I have previously asked a question here on SO about a similar topic but have since taken a different approach. This is my model:

public class ApplicationUser : IdentityUser<int, CustomUserLogin, CustomUserRole,CustomUserClaim>
{   
    public ApplicationUser()
    {
        Friends = new List<Friend>();
    }

    [Required]
    public string Alias { get; set; }

    public virtual ICollection<Friend> Friends { get; set; }
}

public class Friend
{
    public virtual int Id { get; set; }

    public virtual ApplicationUser RequestedBy { get; set; }

    public virtual ApplicationUser RequestedTo { get; set; }

    public DateTime? RequestTime { get; set; }

    public FriendRequestFlag FriendRequestFlag { get; set; }
}

public enum FriendRequestFlag
{
    None,
    Approved,
    Rejected,
    Blocked,
    Spam
};

I can add Friends with this approach and they populate when I get them from database, sample:

public void AddFriendRequest(ApplicationUser user, ApplicationUser friendUser)
{
    var friendRequest = new Friend()
    {
        RequestedBy = user,
        RequestedTo = friendUser,
        RequestTime = DateTime.Now,
        FriendRequestFlag = FriendRequestFlag.None
    };

    user.Friends.Add(friendRequest);
}

When I run the code above, the friend table in the database looks like this after execution:

When I get a user I would wan't Entity Framework to get all rows in Friend were the user is either RequestedBy or RequestedTo. Is this possible to do with EF? For example with Fluent API? I would also like to map the keys so that [ApplicationUser_Id] is not needed.

解决方案

@Mukesh thanks for your answer but I decided to take another approach since your solution did not get all rows in Friend were the user is either RequestedBy or RequestedTo. This is my solution:

public class ApplicationUser : IdentityUser<int, CustomUserLogin, CustomUserRole,
CustomUserClaim>
{
    public async Task<ClaimsIdentity> GenerateUserIdentityAsync(UserManager<ApplicationUser, int> manager, string authenticationType)
    {
        // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
        var userIdentity = await manager.CreateIdentityAsync(this, authenticationType);
        // Add custom user claims here
        return userIdentity;
    }

    public ApplicationUser()
    {
        SentFriendRequests = new List<Friend>();
        ReceievedFriendRequests = new List<Friend>();
    }

    [Required]
    public string Alias { get; set; }

    public string Name { get; set; }

    public byte[] ProfilePicture { get; set; }

    public virtual ICollection<Friend> SentFriendRequests { get; set; }

    public virtual ICollection<Friend> ReceievedFriendRequests { get; set; }

    [NotMapped]
    public virtual ICollection<Friend> Friends {
        get
        {
            var friends = SentFriendRequests.Where(x => x.Approved).ToList();
            friends.AddRange(ReceievedFriendRequests.Where(x => x.Approved));
            return friends;
        } }
}

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    base.OnModelCreating(modelBuilder);

    modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();
    modelBuilder.Conventions.Remove<ManyToManyCascadeDeleteConvention>();

    modelBuilder.Entity<Friend>()
        .HasRequired(a => a.RequestedBy)
        .WithMany(b => b.SentFriendRequests)
        .HasForeignKey(c => c.RequestedById);

    modelBuilder.Entity<Friend>()
        .HasRequired(a => a.RequestedTo)
        .WithMany(b => b.ReceievedFriendRequests)
        .HasForeignKey(c => c.RequestedToId);
}

public class Friend
{
    [Key, Column(Order = 0)]
    public int RequestedById { get; set; } 
    [Key, Column(Order = 1)]
    public int RequestedToId { get; set; } 
    public virtual ApplicationUser RequestedBy { get; set; }
    public virtual ApplicationUser RequestedTo { get; set; }

    public DateTime? RequestTime { get; set; }

    public DateTime? BecameFriendsTime { get; set; }

    public FriendRequestFlag FriendRequestFlag { get; set; }

    [NotMapped]
    public bool Approved => FriendRequestFlag == FriendRequestFlag.Approved;

    public void AddFriendRequest(ApplicationUser user, ApplicationUser friendUser)
    {
        var friendRequest = new Friend()
        {
            RequestedBy = user,
            RequestedTo = friendUser,
            RequestTime = DateTime.Now,
            FriendRequestFlag = FriendRequestFlag.None
        };
        user.SentFriendRequests.Add(friendRequest);
    }
}

public enum FriendRequestFlag
{
    None,
    Approved,
    Rejected,
    Blocked,
    Spam
};

这篇关于C＃模型用户，朋友请求和实体框架代码的朋友的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！