C＃模型用戶，使用實體框架代碼的好友請求和好友

Question

我之前曾在此處就類似主題問過一個問題，但此后采取了不同的方法。 這是我的模型：

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
};

我可以使用這種方法添加好友，當我從數據庫中獲取好友時，它們會填充，例如：

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);
}

當我運行上面的代碼時，執行后數據庫中的好友表如下所示：

當我得到一個用戶時，如果該用戶是RequestedBy或RequestedTo我將不會使用Entity Framework獲取Friend中的所有行。 這與EF有關嗎？ 例如使用Fluent API？ 我還想映射鍵，以便不需要[ApplicationUser_Id] 。

Answer 1

@Mukesh感謝您的回答，但我決定采用另一種方法，因為您的解決方案未將Friend中的所有行都作為用戶是RequestedBy還是RequestedTo。 這是我的解決方案：

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
};

Answer 2

當我得到一個用戶時，如果該用戶是RequestedBy或RequestedTo，我將不會使用Entity Framework獲取Friend中的所有行。 這與EF有關嗎？

是的，您絕對可以這樣做，只是您需要通過將false值設置為LazyLoadingEnabled來禁用延遲加載功能，

context.Configuration.LazyLoadingEnabled = false;

如果您也想在上述情況下獲取朋友，則可以通過包含導航屬性來獲取朋友列表。

context.User.Include(x => x.Friends).ToList();

我還想映射鍵，以便不需要[ApplicationUser_Id]。

為了實現這一點，需要使用ForeignKey屬性，以便它不會在表中生成[Application_Id]列，請遵循以下更新的模型。

public class ApplicationUser
    {
        [Key]
        public virtual int Id { get; set; }
        public ApplicationUser()
        {
            Friends = new List<Friend>();
        }
        [Required]
        public string Alias { get; set; }

        [ForeignKey("RequestedBy_Id")]
        public virtual ICollection<Friend> Friends { get; set; }
    }

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

        [ForeignKey("RequestedBy")]
        public virtual int RequestedBy_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
    };