Guia definitivo de aplicação em cascata definitiva

Question

Existem recursos da Internet que possuem um guia definitivo para todas as configurações da Cascade para o Nibernate que incluirão exemplos da estrutura da classe, HBM e as implicações das ações com cada uma das configurações de cascata para todos os relacionamentos com o NH.

Além disso, seria útil se houvesse exemplos para que associações comuns fossem feitas da maneira mais correta, como a configuração de uma tabela de estados que você nunca acabará com a exclusão de um estado ou que excluir um objeto que possui uma propriedade de usuário criada por que Nunca acabar excluindo o usuário em uma cascata etc.

Answer 1

O seguinte é adaptado da referência de hibernato de Java http://docs.jboss.org/hibernate/stable/core/manual/en-us/html/objectstate.html#objectstate-transitive para Niberate 3.0 (ou seja, o atual tronco SVN).

Para cada operação básica da sessão de Nibernato - incluindo persist (), merge (), salvorUpdate (), delete (), Lock (), refresh (), despet (), replicar () - existe um estilo cascata correspondente. Respectivamente, os estilos em cascata são nomeados persistentes, mesclar, mesclar, salvar update, excluir, bloquear, atualizar, despejar, replicar. O estilo de cascata para salvar () e update () é salvador; Para SaveAndupDateCopy (), é a mesclagem; e para persistonflush () é persistente. E remover é um alias para excluir.

Se você deseja que uma operação seja cascata ao longo de uma associação, deve indicar isso no documento de mapeamento. Por exemplo:

<one-to-one name="person" cascade="persist"/>

Estilos em cascata meu ser combinado:

<one-to-one name="person" cascade="persist,delete,lock"/>

Você pode usar o cascade = "all" para especificar que todas as operações devem ser cascatas ao longo da associação. A cascade padrão = "Nenhum" especifica que nenhuma operação deve ser em cascata.

Um estilo especial em cascata, Delete-Orphan, aplica-se apenas a associações um para muitos e indica que a operação de exclusão () deve ser aplicada a qualquer objeto filho que seja removido da associação. E o-delso-Orfão é o mesmo de todos, excluir-Orphan.

Recomendações:

• Geralmente não faz sentido ativar a cascata em umu003Cmany-to-one> ouu003Cmany-to-many> Associação. Cascade é frequentemente útil parau003Cone-to-one> eu003Cone-to-many> associações.
• Se a vida útil do objeto infantil for delimitada pela vida útil do objeto pai, faça dele um objeto de ciclo de vida especificando cascade = "todos os delicios-Orphan".
• Caso contrário, você pode não precisar de cascata. Mas se você acha que geralmente trabalha com os pais e os filhos juntos na mesma transação, e deseja salvar algumas digitação, considere usar o cascade = "persistir, mesclar, mesclar, save-update".

O mapeamento de uma associação (uma única associação valorizada ou uma coleção) com Cascade = "All" marca a associação como uma relação entre pais/crianças em que salvar/atualizar/excluir os pais resulta em salvar/atualizar/excluir da criança ou crianças. Uma criança que se torna não referenciada por seus pais não é excluída automaticamente, exceto no caso de umu003Cone-to-many> Associação mapeada com Cascade = "Delete-Orphan". A semântica precisa das operações em cascata para um relacionamento pai/filho são as seguintes:

• Se um pai for passado para persistir (), todas as crianças são passadas para persistir ()
• Se um pai for passado para Merge (), todas as crianças são passadas para mesclar ()
• Se um pai for passado para salvar (), atualizar () ou saveorUpdate (), todas as crianças são passadas para o salvador ()
• Se uma criança transitória ou desapegada for referenciada por um pai persistente, ela é passada para o salvador ()
• Se um pai for excluído, todas as crianças são passadas para excluir ()
• Se uma criança é desreferenciada por um pai persistente, nada de especial acontece - o pedido deve excluir explicitamente a criança, se necessário - a menos que Cascade = "Delete -Orphan", nesse caso, a criança "órfã" é excluída.

Answer 2

Isso pode ser um conselho óbvio, mas eu sugeriria navegar no antigo post feito por Ayende. Um rápido procurar Para Nibernate e Cascade em seu site, revelaram alguns posts interessantes. Eles podem, no entanto, ser um pouco escassos para suas necessidades.

Mesmo que não seja um recurso da Internet por si só, eu também recomendaria Nibernate em ação. Ele aborda cascatas em alguma profundidade nos capítulos 3, 4 e 6. O livro tem como alvo o Nibernate 1.2. Acredito, porém, que haverá uma nova edição do livro direcionada ao lançamento 3.0 do Nibernate; Pode valer a pena ficar de olho.

Por mais que eu gostasse de ver um guia definitivo para Cascades, eu não vi um. Talvez você possa resumir algumas das postagens do blog por aí discutindo Cascades com sua própria postagem em seu próprio blog.

Answer 3

Não conheço nenhum guia "definitivo", mas o melhor recurso que conheço é um post de Ayende, que é um dos gurus definitivos do Nibernate:

Nibernate Cascades: as diferentes entre todos, todos os-delicios-orfãos e save-update

Para mim, eu realmente só uso cascade="none" e cascade="all". all-delete-orphan às vezes é uma opção. Todo o resto é suspeito. Por exemplo, por que devo criar implicitamente uma instância porque é referenciada, quando vive mais tempo e o objeto que contém? Para mim, existem apenas duas situações: o objeto é dependente ou independente.

Answer 4

A resposta aceita explica isso em detalhes com arquivos HBM. Esta resposta cobre o mesmo com o mapeamento por código. Eles são quase iguais; Apenas mapeado para suas cordas HBM.

Formulário de artigo Ayende explica bem:

• Nenhum - não faça cascatas, deixe os usuários lidam com eles sozinhos.
• Save-update-Quando o objeto for salvo/atualizado, verifique as associações e salve/atualize qualquer objeto que o exija (incluindo salvar/atualizar as associações no cenário de muitos para muitos).
• Excluir - Quando o objeto for excluído, exclua todos os objetos da associação.
• Delete -Orphan - Quando o objeto é excluído, exclua todos os objetos da associação. Além disso, quando um objeto é removido da associação e não associado a outro objeto (órfão), também o exclua.
• Todos - quando um objeto for salvar/atualizar/excluir, verifique as associações e salve/atualize/exclua todos os objetos encontrados.
• All-Delte-Orphan-Quando um objeto for salvar/atualizar/excluir, verifique as associações e salve/atualize/exclua todos os objetos encontrados. Além disso, quando um objeto é removido da associação e não associado a outro objeto (órfão), também o exclua.

Também, isto Pergunta explica poucas implementações internas de Cascade.

[Flags]
public enum Cascade
{
    None = 0,
    Persist = 2,
    Refresh = 4,
    Merge = 8,
    Remove = 16,
    Detach = 32,
    ReAttach = 64,
    DeleteOrphans = 128,
    All = 256,
}
private static IEnumerable<string> CascadeDefinitions(this Cascade source)
{
    if (source.Has(Cascade.All))
    {
        yield return "all";
    }
    if (source.Has(Cascade.Persist))
    {
        yield return "save-update, persist";
    }
    if (source.Has(Cascade.Refresh))
    {
        yield return "refresh";
    }
    if (source.Has(Cascade.Merge))
    {
        yield return "merge";
    }
    if (source.Has(Cascade.Remove))
    {
        yield return "delete";
    }
    if (source.Has(Cascade.Detach))
    {
        yield return "evict";
    }
    if (source.Has(Cascade.ReAttach))
    {
        yield return "lock";
    }
    if (source.Has(Cascade.DeleteOrphans))
    {
        yield return "delete-orphan";
    }
}

Observe isso Cascade.All Não inclui Cascade.DeleteOrphans. Nesse caso, pode ser necessário incluí -lo usando Cascade.All | Cascade.DeleteOrphans.

Alternativamente, você pode usar Include Método de extensão Cascade.All.Include(Cascade.DeleteOrphans).

Em combinação com Cascade, você pode precisar olhar para Inverse também; Especificou o proprietário da associação. Referir-se isto Pergunta para mais detalhes.