ORM 和层

很抱歉这一点在这里到处都是……但我感觉就像一只狗在追我的尾巴，此时我很困惑。

我试图找到开发 3 层解决方案（IL、BL、DL）的最简洁方法，其中 DL 使用 ORM 来抽象对数据库的访问。

在我见过的所有地方，人们都使用 LinqToSQL 或 LLBLGen Pro 来生成表示数据库表的对象，并在所有 3 层中引用这些类。 似乎 40 年的编码模式被忽略了——或者范式转变已经发生，而我错过了关于为什么这样做完全可以的解释部分。

然而，似乎仍然有一些基础来希望与数据存储机制无关——看看 LinqToSQL 刚刚发生了什么：很多代码是针对它编写的——仅针对 MS 放弃它...所以我想尽我所能隔离 ORM 部分，只是不知道如何。

因此，回到绝对的基础知识，以下是我希望以非常非常干净的方式组装的基本部分：

我开始的大会： UL.dll BL.dll 动态链接库

主要课程：

Message 类，具有公开 MessageAddress 对象集合（称为 MessageAddresses）的属性：

class Message 
{
    public MessageAddress From {get;}
    public MessageAddresses To {get;}
}

每层的功能：

BL 向 UI 公开一个名为 GetMessage (Guid id) 的方法，该方法返回 Message 的实例。

BL 依次包裹 DL。

DL 有一个 ProviderFactory，它包装了 Provider 实例。 DL.ProviderFactory 公开了（可能......我的问题的一部分）两个静态方法，称为 GetMessage(Guid id)，以及 保存消息（消息消息） 最终目标是能够将为 Linq2SQL 编写的提供程序替换为为 LLBLGen Pro 编写的提供程序，或另一个不针对 ORM 运行的提供程序（例如 VistaDB）。

设计目标： 我想要层分离。 我希望每一层只依赖于它下面的层，而不是上面的层。 我希望 ORM 生成的类仅位于 DL 层中。 我希望 UL 与 BL 共享 Message 类。

因此，这是否意味着：

a) 消息在BL中定义 b) DB 表的 Db/Orm/Manual 表示（“DbMessageRecord”或“MessageEntity”，或任何其他 ORM 的称呼）在 DL 中定义。 c) BL 依赖于 DL d) 在调用没有 ref 或不了解 BL 的 DL 方法之前，BL 必须将它们转换为 BL 实体（例如：DbMessageRecord）？

UL:

Main() 
{
    id = 1;
    Message m = BL.GetMessage(id);
    Console.Write (string.Format("{0} to {1} recipients...", m.From, m.To.Count));
}

BL:

static class MessageService 
{ 
    public static Message GetMessage(id)
    {
        DbMessageRecord message = DLManager.GetMessage(id);
        DbMessageAddressRecord[] messageAddresses = DLManager.GetMessageAddresses(id);

        return MapMessage(message, 
    }

    protected static Message MapMessage(DbMessageRecord dbMessage. DbMessageAddressRecord[] dbAddresses)
    {
        Message m = new Message(dbMessage.From);
        foreach(DbMessageAddressRecord dbAddressRecord in dbAddresses){
        m.To.Add(new MessageAddress (dbAddressRecord.Name, dbAddressRecord.Address);
    }
}

DL:

static class MessageManager 
{
    public static DbMessageRecord GetMessage(id);
    public static DbMessageAddressRecord  GetMessageAddresses(id);
}

问题： a) 显然，这迟早会带来大量工作。 b) 更多错误 c) 较慢 d) 由于 BL 现在依赖于 DL，并且引用 DL 中的类（例如 DbMessageRecord），因此似乎由于这些类是由 ORM 定义的，因此您不能删除一个 Provider，然后用另一个 Provider 替换它，...让整个练习变得毫无意义……不妨在整个 BL 中使用 ORM 的类。 e) 或者...在 BL 和 DL 之间需要另一个组件，并且需要另一个映射以使 BL 独立于底层 DL 类。

希望我能更清楚地提出问题......但我现在真的迷失了。任何帮助将不胜感激。

这有点乱，让我想起了我第一次尝试 Orm 和 DDD。 我个人使用核心域对象、消息传递对象、消息处理程序和存储库。 因此，我的 UI 向处理程序发送一条消息，该处理程序又通过存储库水合我的对象并执行该域对象中的业务逻辑。我使用 NHibernate 进行数据访问，使用 FluentNHibernate 进行类型化绑定，而不是松散的 goosey .hbm 配置。

因此，消息传递是我的 UI 和处理程序之间共享的全部内容，并且所有 BL 都在域中。

我知道我可能会因为我的解释而受到惩罚，如果不清楚，我稍后会辩护。

就我个人而言，我不太喜欢代码生成的对象。

我必须继续添加这个答案。 尝试将您的消息传递视为命令，而不是代表数据库的数据实体。我将给你举一个我的一个简单课程的例子，以及一个对我来说非常有效的基础设施决策，但我不能将其归功于：

[Serializable]
public class AddMediaCategoryRequest : IRequest<AddMediaCategoryResponse>
{
    private readonly Guid _parentCategory;
    private readonly string _label;
    private readonly string _description;

    public AddMediaCategoryRequest(Guid parentCategory, string label, string description)
    {
        _parentCategory = parentCategory;
        _description = description;
        _label = label;
    }

    public string Description
    {
        get { return _description; }
    }

    public string Label
    {
        get { return _label; }
    }

    public Guid ParentCategory
    {
        get { return _parentCategory; }
    }
}

[Serializable]
public class AddMediaCategoryResponse : Response 
{
    public Guid ID;
}


public interface IRequest<T> : IRequest where T : Response, new() {}


[Serializable]
public class Response
{
    protected bool _success;
    private string _failureMessage = "This is the default error message.  If a failure has been reported, it should have overwritten this message.";
    private Exception _exception;

    public Response()
    {
        _success = false;
    }

    public Response(bool success)
    {
        _success = success;
    }

    public Response(string failureMessage)
    {
        _failureMessage = failureMessage;
    }

    public Response(string failureMessage, Exception exception)
    {
        _failureMessage = failureMessage;
        _exception = exception;
    }

    public bool Success
    {
        get { return _success; }
    }

    public string FailureMessage
    {
        get { return _failureMessage; }
    }

    public Exception Exception
    {
        get { return _exception; }
    }

    public void Failed(string failureMessage)
    {
        _success = false;
        _failureMessage = failureMessage;
    }

    public void Failed(string failureMessage, Exception exception)
    {
        _success = false;
        _failureMessage = failureMessage;
        _exception = exception;
    }
}


public class AddMediaCategoryRequestHandler : IRequestHandler<AddMediaCategoryRequest,AddMediaCategoryResponse>
{
    private readonly IMediaCategoryRepository _mediaCategoryRepository;
    public AddMediaCategoryRequestHandler(IMediaCategoryRepository mediaCategoryRepository)
    {
        _mediaCategoryRepository = mediaCategoryRepository;
    }

    public AddMediaCategoryResponse HandleRequest(AddMediaCategoryRequest request)
    {
        MediaCategory parentCategory = null;
        MediaCategory mediaCategory = new MediaCategory(request.Description, request.Label,false);
        Guid id = _mediaCategoryRepository.Save(mediaCategory);
        if(request.ParentCategory!=Guid.Empty)
        {
            parentCategory = _mediaCategoryRepository.Get(request.ParentCategory);
            parentCategory.AddCategoryTo(mediaCategory);
        }
        AddMediaCategoryResponse response = new AddMediaCategoryResponse();
        response.ID = id;
        return response;
    }
}

我知道这种情况会一直持续下去，但这个基本系统在过去一年左右的时间里对我很有帮助

您可以看到处理程序允许域对象处理域特定逻辑