Nibernato fluente impõe não anulável em referência de chave estrangeira

Question

Apenas molhar meus pés com algumas convenções fluentes de Nibernate Automap e encontrar algo que eu não conseguia descobrir. Suponho que não estou olhando no lugar certo ... basicamente tentando fazer cumprir não-nulo do lado "muitos" de um a muitos relacionamentos. Parece que, usando o AutomApping, ele sempre torna o ID da propriedade pai anulado no banco de dados.

Eu fiz algumas pesquisas no Stackoverflow e encontrei perguntas semelhantes, mas nada relacionado a automappicações e convenções (a menos que eu o perdesse).

Exemplo rápido ...

public class Group    // One Group
{
    public Group() { this.Jobs = new List<Job>(); }
    public virtual Guid Id { get; set; }
    public virtual string Name { get; set; }
    public virtual IList<Job> Jobs { get; protected set; }
}

public class Job    // Has many Jobs
{
    public virtual Guid Id { get; set; }
    public virtual string Name { get; set; }

    // Trying to make this field not-nullable in the database.
    public virtual Group Group { get; set; }
}

Eu pensei que seria capaz de apenas criar uma convenção como ...

public class OneToManyConvention : IHasOneConvention
{
    public void Apply(IOneToOneInstance instance)
    {
        // Nullable() isn't a valid method...
        instance.Not.Nullable();   
    }
}

Mas parece que o IOnetoonInstance não possui um método Nullable (). Eu posso fazer isso se criar um arquivo de mapa para o trabalho, mas tentando evitar arquivos de mapa e continuar com o mapeamento automático.

Eu me deparei com isso Link na lista de grupos fluentes descrevendo algo semelhante.

Que descreve algo assim ...

public class NotNullPropertyConvention : IPropertyConvention
{
    public bool Accept(IProperty target)
    {
            return true;
    }
    public void Apply(IProperty target)
    {
            target.Not.Nullable();
    }
}

Mas isso levanta as questões de ... 1) Como eu determinaria a iProperty para ser um emprego (ou qualquer propriedade infantil que seja um link para o pai)

2) Fazia uma menção nessa página de que o uso disso substituiria minhas substituições manuais, por exemplo. Se um link de propriedade muito específico precisava ser nulo. O que seria um problema (se ainda for um problema, mas não pode testar sem descobrir o número 1 primeiro)

Alguma idéia disso? Estou apenas perdendo alguma coisa?

---

Atualização 1

Ainda não vá. Mesmo o seguinte ainda não aplica não-nulo no esquema de banco de dados ...

public class FluentConvention : IPropertyConvention
{
    public void Apply(IPropertyInstance instance)
    {
        instance.Not.Nullable();
    }
}

No entanto, é para todos os outros campos ...
/dar de ombros

Alguma ideia?

---

Atualização 2

Enquanto essa não é a resposta que eu estava procurando, encontrei um trabalho por aí ... eu estava usando a Assembléia do Validador do Nibernato e, dentro dessa montagem, há um atributo [NotNull]. Se eu decorasse minha turma com o atributo Validador e associei o ValidationEngine ao Nibernate antes da criação do esquema, ele marcou a coluna FK Database como não indicável.

public class Job    // Has many Jobs
{
    public virtual Guid Id { get; set; }
    public virtual string Name { get; set; }

    [NHibernate.Validator.Constraints.NotNull]
    public virtual Group Group { get; set; }
}

Se alguém precisar do código completo para a inicialização do Nibernate + ValidationEngine, me avise. Ainda estou procurando uma maneira de fazer isso usando a rota da convenção de mapeamento puro, embora alguém tenha alguma informação ...

Obrigado!

Answer 1

Você pode substituir as propriedades mapeadas automaticamente como parte do seu automap em fluenttly.configure ().

Então você pode fazer isso:

.Override<Job>(map => map.References(x => x.Group).Not.Nullable())

Não é exatamente conveniente se você tiver muitas classes que precisam disso.

Editar: Você também pode especificar a substituição de uma classe que implementa a referência de que a renda como assim:

    public class JobMappingOverride : IAutoMappingOverride<Job>
    {
            public void Override(AutoMapping<Job> mapping)
            {
                    mapping.References(x => x.Group).Not.Nullable();
            }
    }

e inclua assim:

    .UseOverridesFromAssemblyOf<JobMappingOverride>()

Isso manteria sua configuração fluente um pouco mais limpa.

Answer 2

Parece que IPropertyConvention é chamado apenas em propriedades simples de suas classes. Se sua propriedade faz referência a outra classe, você precisa usar IReferenceConvention também.

Experimente isso:

public class FluentConvention : IPropertyConvention, IReferenceConvention  
{      
    public void Apply(IPropertyInstance instance)
    {          
        instance.Not.Nullable();      
    }

    public void Apply(IManyToOneInstance instance)
    {
        instance.Not.Nullable();
    }
}