Entity Framework - Problème lié à l'utilisation d'entités détachées

c# entity-framework

Question

Ok, dans cet exemple, j’ai une entité mère appelée Template. Un modèle a toujours un type. Le type est un FK qui existe très probablement. Le problème survient lors de la création d'un nouveau modèle et de l'ajout de ce type. Une fois que le type est ajouté et que vous allez ajouter le modèle, vous recevez une erreur. L'erreur que vous recevez dépend de l'approche. Est-ce que quelqu'un sait comment travailler avec ce genre de situation?

public static void AddTemplate(Template template)
    {
        using (TheEntities context = new TheEntities())
        {
            //if (template.TemplateType.EntityKey != null)
            //{
            //    context.Attach(template.TemplateType);
            //}

            context.AddToTemplates(template);
            context.SaveChanges();

            context.RemoveTracking(template);
        }
    }

J'ai essayé à la fois d'essayer d'attacher la clé existante et non. L’appel au bas de RemoveTracking est simplement une extension permettant d’appeler détacher sur un modèle et sur toutes les sous-entités éventuellement chargées.

Voici le test unitaire.

[TestMethod]
    public void CanAddAndDeleteATemplate()
    {
        Template template = new Template();
        template.Name = "Test";
        template.Description = "Test";

        TemplateType type = TemplateManager.FindTemplateTypeByName("Round");

        if (type == null)
        {
            type = new TemplateType();
            type.Name = "Round";
        }

        template.TemplateType = type;

        TemplateManager.AddTemplate(template);

        template = TemplateManager.FindTemplateByID(template.TemplateID);

        Assert.IsNotNull(template);

        TemplateManager.DeleteTemplate(template);

        template = TemplateManager.FindTemplateByID(template.TemplateID);

        Assert.IsNull(template);
    }

Le test unitaire fonctionne parfaitement en supposant qu'un modèle de type "Round" n'existe pas encore. Je commence à me demander si ce genre de choses est possible dans un environnement isolé.

METTRE À JOUR

Ok j'ai changé mon code pour AddTemplate à cela et maintenant ça marche ..

public static void AddTemplate(Template template)
    {
        using (TheEntities context = new TheEntities())
        {
            if (template.TemplateType.EntityKey != null)
            {
                TemplateType type = template.TemplateType;
                template.TemplateType = null;
                context.AttachTo("TemplateTypes", type);
                template.TemplateType = type;
            }


            context.AddToTemplates(template);
            context.SaveChanges();

            context.RemoveTracking(template);
        }
    }

Ainsi, pour toutes les entités enfant existantes ajoutées à un nouveau parent par un client, ce type de travail doit être effectué sur elles lorsqu'elles sont prêtes à être persistées. Y a-t-il une manière plus propre de faire ceci? Peut-être quelque chose d'un peu plus générique?

Réponse acceptée

Changer le code en ceci permet au gestionnaire d'état d'objet de suivre le changement et permet l'ajout du modèle.

public static void AddTemplate(Template template)
    {
        using (TheEntities context = new TheEntities())
        {
            if (template.TemplateType.EntityKey != null)
            {
                TemplateType type = template.TemplateType;
                template.TemplateType = null;
                context.AttachTo("TemplateTypes", type);
                template.TemplateType = type;
            }


            context.AddToTemplates(template);
            context.SaveChanges();

            context.RemoveTracking(template);
        }
    }


Related

Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow