Domanda

Ho una classe base un'entità astratta definita in questo modo:

public abstract class SessionItem : Entity
{
    public virtual Session Session { get; set; }
}

Inoltre, sto usando la mappatura automatica:

private AutoPersistenceModel CreateAutomappings()
{
    return AutoMap
        // configuration
        .Conventions.Add(DefaultCascade.All())
        // more configuration
}

SessionItem ha diversi derivato classi / tavoli, e mi piacerebbe ignorare la politica a cascata per tutti loro. Ho provato quanto segue:

public class SessionItemAutommapingOverride : IAutoMappingOverride<SessionItem>
{
    public void Override(AutoMapping<SessionItem> mapping)
    {
        mapping.References(x => x.Session).Cascade.None();
    }
}

Ma purtroppo la sostituzione non è chiamato dal SessionItem è astratto (e non è mappata). Preferisco evitare l'override per ogni sottoclasse (usando IAutoMappingOverride).

C'è un modo per ignorare cascata per più tipi, senza l'utilizzo di IAutoMappingOverride <> per ciascuno di essi?

È stato utile?

Soluzione

public class SessionReferenceCascadeNone : IReferenceConvention, IReferenceConventionAcceptance
{
    public void Accept(IAcceptanceCriteria<IManyToOneInspector> criteria)
    {
        criteria.Expect(x =>
            typeof(SessionItem).IsAssignableFrom(x.EntityType) &&
            x.Property.PropertyType == typeof(Session));
    }

    public void Apply(IManyToOneInstance instance)
    {
        instance.Cascade.None();
    }
}

Altri suggerimenti

A quanto pare questo è possibile utilizzando IReferenceConvention:

public class CascadeNoneOverrideConvention : IReferenceConvention
{
    public void Apply(IManyToOneInstance instance)
    {
        // override
    }
}
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top