Question

我基本上有业务层，业务实体和数据访问（SQL）层。

业务实体层由业务层和数据访问层引用。

我已经做了一个测试来设置延迟加载，我调用的函数将实体从业务层填充到实体层。

问题：循环依赖！我无法从BE调用BL，因为BL使用了BL

以下是有趣的代码：

实体属性：

 // Not lazyloaded properties
        public int Id { get; set; }
        public string Description { get; set; }

        // lazy loaded properties
        private Lazy<AuditTypeEntity> _auditType = null;
        public AuditTypeEntity auditType
        {
            get
            {
                return _auditType.Value;
            }
        }

我做过的实体构造函数（但我不能使用它，因为有一个循环的重新划分：BL调用BE所以BE可以'调用BL）：

public MyEntity()
        {
        _auditType = new Lazy<AuditTypeEntity>(() => BusinessLayer.GetAuditTypeById(_auditTypeId).Value);
}

修改

我正在使用ADO.NET并填充实体对象。

以下是我如何调用DAL图层的示例：

public static IList<Nature> GetAllNature()
        {
            using (DAOManager daomanager = DAOFactory.CreateDaoManager(DataSource.DB_Belval))
            {
                return daomanager.GetNatureDAO().GetAll(BE.EnumEntity.NATURE.ANOMALY);
            }
        }

Answer 1

以下是有关如何实现此目标的示例。因此，您可以使用自定义构造函数来提供Lazy依赖项。

！ DAL是唯一一个应该处理懒惰的人！

class Program
{
    static void Main(string[] args)
    {
        var bll = new BLL();
        var person = bll.GetPerson();
        var orders = person.Orders; // GetOrders in DAL will be excuted here
    }
}

// BLL project
public class BLL
{
    public Person GetPerson()
    {
        return new DAL().GetPerson(1);
    }
}

// Entity Project
public class Person
{
    public Person()
    {

    }
    public Person(Lazy<IEnumerable<Order>> orders)
    {
        _orders = orders;
    }
    public int Id { get; set; }
    public string Name { get; set; }
    private Lazy<IEnumerable<Order>> _orders = null;

    public IEnumerable<Order> Orders
    {
        get { return _orders?.Value; }
        set { _orders = new Lazy<IEnumerable<Order>>(() => value); }
    }

}

public class Order
{
    public int Id { get; set; }
    public string Name { get; set; }
}

// DAL Project
public class DAL
{
    public Person GetPerson(int id)
    {
        var person = new Person(new Lazy<IEnumerable<Order>>(() => GetOrders(id))) // Init lazy
        {
            Id = id,
            Name = "Person"
        };
        return person;
    }

    public IEnumerable<Order> GetOrders(int personId)
    {
        return new List<Order> { new Order { Id = 2, Name = "Order" } };
    }
}

BL和BE之间的延迟加载时的循环依赖性

1 个答案: