Définition d'une clé étrangère à null lors de l'utilisation d'entity framework code first

Je suis en utilisant la base de données de mise en œuvre de l'Entity Framework Code First que la couche de données pour un projet, mais j'ai couru dans un problème.

J'ai besoin d'être en mesure de définir une clé étrangère à null pour supprimer une association dans la base de données.

J'ai 2 objets. L'un est appelé Projet.

public class Project
{
    public int ProjectId {get; set;}
    public Employee Employee {get;set;}
}

public class Employee
{
    public int EmployeeId {get; set;}
    public string EmployeeName {get;set;}
}

Cela correspond à ce que j'ai dans la Base de données:

CREATE TABLE Project(
    ProjectId int IDENTITY(1,1) NOT NULL,
    EmployeeId int NULL
)

CREATE TABLE Project(
    EmployeeId int IDENTITY(1,1) NOT NULL,
    EmployeeName varchar(100) NULL
)

Je peux affecter un Employé à un projet. Cependant, je veux être en mesure de supprimer un employé d'un projet et d'avoir le champ Employé nulle. Dans mon UI ce sera indiqué comme "Non Employés Affectés".

Cependant, à court d'une requête sql, je n'arrive pas à trouver un moyen de le faire dans l'entity framework 4.1.

J'ai essayé:

public void RemoveEmployeeFromProject(int projectId)
{
    var project = Context.Projects.FirstOrDefault(x => x.ProjectId == projectId);
    project.Employee = null;
    Context.SaveChanges();
}

Mais ce n'est pas faire n'importe quoi.

Quelqu'un a une idée?

InformationsquelleAutor mccow002 | 2011-06-21

c#entity-framework-4.1

63

Je pense que le problème est que dans la mesure où le contexte est concerné, vous n'avez pas fait quelque chose de changé.

Vous pouvez utiliser le chargement paresseux approche déjà suggéré en utilisant virtual, mais puisque vous n'avez pas demandé à ce que l'Employé d'être encore chargé, il est toujours null. Vous pouvez essayer ceci:
```
var forceLoad = project.Employee;
project.Employee = null; //Now EF knows something has changed
Context.SaveChanges();
```
Sinon, explicitement inclure dans votre demande initiale:
```
var project = Context.Projects.Include(x => x.Employee).FirstOrDefault(x => x.ProjectId == projectId);
project.Employee = null;
Context.SaveChanges();
```
Sur une note de côté, FirstOrDefault sera de retour null si aucune Project correspond à l'id donné. Si vous savez que le projet existe, vous pouvez simplement utiliser First. Vous pourriez même utiliser Single qui affirment qu'il n'y a qu'un seul projet. Si vous continuez à utiliser FirstOrDefault, je vous recommande de vérifier null avant de travailler avec project.
- Ouais, c'était la question. Merci!
- Eu le même problème, très utile, j'ai mon +1
- +1 - Résolu mon problème semblable.
- Je considère cela comme un bug dans l'EF. Voir la section entityframework.codeplex.com/workitem/2074 et SI la question stackoverflow.com/questions/21692401/...
- Lazy load était le coupable, gaspillé un peu de temps, mais c'est expliqué et corrigé.
- Ruttka comment cela fonctionne quand nous utilisons Store Procédure var liste = _db.La base de données.SqlQuery<Projet>("spGetProjectInfo @EmployeeID", sqlParams).ToListAsync (), j'obtiens la liste.Employé = null comment je peux être employés dans des projets
- C'est toujours valable sur EntityFrameworkCore 2.2.2 / .NET Core 2.2 je suis en utilisant le champ virtuel et je n'étais pas en mesure de nulify ce domaine si ce n'est pas compris avant. Après l'ajout d'un "xxxx.Inclure(a => un.myField)", puis les "myEntity.myField = null" se porte comme un charme.
InformationsquelleAutor David Ruttka
10

Vous pouvez le faire de cette façon, ce qui signifie que vous n'avez pas à charge de l'entité associée.
```
context.Entry(Project).Reference(r => r.Employee).CurrentValue = null;
```
- J'aime bien cette solution. Alors que prolixe, il s'auto-documents de ce qu'il se passe. La accepté de répondre à de forcer un lazy-load ou désireux de chargement et en désactivant la propriété est un peu hacky pour moi, et a le potentiel de réaliser une importante pénalité due à la charge inutile. Merci.
InformationsquelleAutor Sprintstar

La réponse à cette question est assez simple. EF ne pouvez pas déduire le type de la donnée à l'information que vous avez fournie.

Viens de le faire à la place:

public void RemoveEmployeeFromProject(int projectId)
{
    var project = Context.Projects.FirstOrDefault(x => x.ProjectId == projectId);
    project.EmployeeId = (int?)null;
    Context.SaveChanges();
}

et il va fonctionner.

InformationsquelleAutor user1325940

0

si vous activez le chargement paresseux en faisant de l'employé de la propriété virtuelle fonctionne-t-cela?
```
public class Project
{
    public int ProjectId {get; set;}
    public virtual Employee Employee {get;set;}
}
```
je voudrais aussi suggérer l'encapsulation de la suppression de la méthode dans le cadre de votre classe poco à rendre le sens plus clair. voir cette l'article pour plus de détails sur cette.
```
public class Project
{
    public int ProjectId {get; set;}
    public virtual Employee Employee {get;set;}
    public void RemoveEmployee()
    {
        Employee = null;
    }
}
```
- Malheureusement, non, ça ne fonctionne pas. Je pense qu'une partie de la raison est parce que avec un chargement différé activé, les valeurs que vous n'avez pas de demande sont mis à null. Ainsi, lorsque vous appelez le Contexte.SaveChanges, il doit ignorer les valeurs null si il ne remplace pas des valeurs réelles avec les valeurs qu'il ne se charge pas. Cela a un sens, jusqu'à ce que vous souhaitez définir une valeur null.
- j'ai pensé qu'il avait quelque chose à voir avec le chargement paresseux.
InformationsquelleAutor David Wick
0

Vous devez inclure dans la requête linq, la propriété de céder, en utilisant le même nom, il a dans le Projet de classe:
```
var project = Context.Projects.Include("Employee").FirstOrDefault(x => x.ProjectId == projectId);
```
InformationsquelleAutor ndarriulat

Comme une autre solution, j'ai compilé deux méthodes dans une méthode d'extension:

public static void SetToNull<TEntity, TProperty>(this TEntity entity, Expression<Func<TEntity, TProperty>> navigationProperty, DbContext context = null)
where TEntity : class
where TProperty : class
{
var pi = GetPropertyInfo(entity, navigationProperty);
if (context != null)
{
//If DB Context is supplied, use Entry/Reference method to null out current value
context.Entry(entity).Reference(navigationProperty).CurrentValue = null;
}
else
{
//If no DB Context, then lazy load first
var prevValue = (TProperty)pi.GetValue(entity);
}
pi.SetValue(entity, null);
}
static PropertyInfo GetPropertyInfo<TSource, TProperty>(    TSource source,    Expression<Func<TSource, TProperty>> propertyLambda)
{
Type type = typeof(TSource);
MemberExpression member = propertyLambda.Body as MemberExpression;
if (member == null)
throw new ArgumentException(string.Format(
"Expression '{0}' refers to a method, not a property.",
propertyLambda.ToString()));
PropertyInfo propInfo = member.Member as PropertyInfo;
if (propInfo == null)
throw new ArgumentException(string.Format(
"Expression '{0}' refers to a field, not a property.",
propertyLambda.ToString()));
if (type != propInfo.ReflectedType &&
!type.IsSubclassOf(propInfo.ReflectedType))
throw new ArgumentException(string.Format(
"Expression '{0}' refers to a property that is not from type {1}.",
propertyLambda.ToString(),
type));
return propInfo;
}

Cela vous permet de fournir une DbContext si vous en avez un, dans ce cas, il va utiliser la méthode la plus efficace et définir la CurrentValue de l'Entrée de Référence à null.

entity.SetToNull(e => e.ReferenceProperty, dbContext);

Si aucune DBContext est fourni, il sera paresseux charge en premier.

entity.SetToNull(e => e.ReferenceProperty);

InformationsquelleAutor jonh

Vous devez vous connecter pour publier un commentaire.