C# 如何处理具有相同结构的不同实体-linq查询本质上是相同的

我有两个不同的数据库实体，第一个实体具有完全相同的结构，但命名约定不同。有没有一种方法可以简化在DoWorkWithSimilar中查询它们时产生的看似重复的代码

我尝试过使用泛型，但在让linq查询正常工作时遇到了困难。我也尽量避免使用泛型，因为我喜欢更明确。然而，这两个类中具有相似方法的DoWorkWithSimular方法非常相似。我正试图想出一个更好的方法来简化这两个类DoWorkSimilarOne和DoWorkSimilarTwo，但是，由于我对底层类结构的限制。。。我在挣扎。没有更好的办法了吗

 public class DoWorkSimilarOne : IDoWork
    {
        public IUnitOfWork unitOfWork;
        public DoWorkSimilarOne(IUnitOfWork _unitOfWork)
        {
           unitOfWork = _unitOfWork;
        }
        public IEnumerable<int> DoWorkWithSimilar(IEnumerable<int> otherIds)
        {

            IEnumerable<int> similarOneIds = unitOfWork.OtherSimilarOnes
                .Where(x => otherIds.Contains(x.Other.OtherId))
                .SelectMany(x => x.SimilarOnes)
                .Select(x => x.SimilarOneId).ToList();
            return similarOneIds;
        }

    }

    public class DoWorkSimilarTwo : IDoWork
    {
        public IUnitOfWork unitOfWork;
        public DoWorkSimilarTwo(IUnitOfWork _unitOfWork)
        {
           unitOfWork = _unitOfWork;
        }

        public IEnumerable<int> DoWorkWithSimilar(IEnumerable<int> otherIds)
        {

            IEnumerable<int> similarTwoIds = unitOfWork.OtherSimilarTwos
                .Where(x => otherIds.Contains(x.Other.OtherId))
                .SelectMany(x => x.SimilarTwos)
                .Select(x => x.SimilarTwoId).ToList();
            return similarTwoIds;
        }

    }

    public class SimilarOne
    {
        public int SimilarOneId { get; set; }
        public OtherSimilarOnes OtherSimilarOne { get; set; }
    }

    public class SimilarTwo
    {
        public int SimilarTwoId { get; set; }
        public OtherSimilarTwos OtherSimilarTwo { get; set; }
    }

    public class Other
    {
        public int OtherId { get; set; }
    }

    public class OtherSimilarOnes
    {
        public int Id { get; set; }
        public Other Other { get; set; }
        public IEnumerable<SimilarOne> SimilarOnes { get; set; }
    }

    public class OtherSimilarTwos
    {
        public int Id { get; set; }
        public Other Other { get; set; }
        public IEnumerable<SimilarTwo> SimilarTwos { get; set; }
    }

    public interface IDoWork
    {
        IEnumerable<int> DoWorkWithSimilar(IEnumerable<int> otherIds);
    }

---

在我看来，您只需要使您的方法泛型并添加一些基类，对吗

public abstract class ObjectWithId
{
    public int Id { get; set; }
}

public class ObjectThatRelates<T> : ObjectWithId
    where T : ObjectWithId
{
    public int OtherId { get; set; }
    public IEnumerable<T> Similar { get; set; }
}

public class Object1 : ObjectWithId
{
    public ObjectThatRelates<Object1> { get; set; }
}

public class Object2 : ObjectWithId
{
    public ObjectThatRelates<Object2> { get; set; }
}

然后你的方法变成：

public IEnumerable<int> DoWorkWithSimilar<T>(IEnumerable<int> otherIds)
{
    IEnumerable<int> similarOneIds = unitOfWork.ObjectThatRelates<T>
        .Where(x => otherIds.Contains(x.OtherId))
        .SelectMany(x => x.Similar)
        .Select(x => x.Id).ToList();
     return similarOneIds;
}

---

当然，您对IUnitOfWork的定义必须更改，以便它可以返回ObjectThatRelated或ObjectThatRelated，但这应该允许您避免重复工作。

制作一个接口，并让您的服务逻辑在接口上而不是acutal实体上运行……或者传入选择器lambda。但是其中有三个非常不合适。这些类有点相似还是完全相同？我在这里不使用泛型，而只是创建一个接口，其中包含两个实体的所有属性，它们现在具有相同的名称和类型。然后，因为数据库第一个实体是部分的，所以只需执行公共部分类FirstEntity:IMyInterface{}和公共部分类SecondEntity:IMyInterface{}。没有更多，因为两个实体都已经实现了该接口。即使没有DI，您也可以将您的方法重写为DoWorkWithSimilarIQueryable查询、IEnumerable OtherID，然后将其用于两个集合。我了解这是如何工作的，但我首先受到数据库设置的限制。。。我不能改变课程，我想部分课程我可以。