LINQ to SQL insert-si-inexistante

Je voudrais savoir si il y a un moyen plus simple d'insérer un enregistrement si elle n'existe pas déjà dans une table. Je suis toujours en train de construire mon LINQ to SQL compétences.

Voici ce que j'ai, mais il semble qu'il devrait y avoir un moyen plus facile.

public static TEntity InsertIfNotExists<TEntity>
(
    DataContext db,
    Table<TEntity> table,
    Func<TEntity,bool> where,
    TEntity record
)
    where TEntity : class
{
    TEntity existing = table.SingleOrDefault<TEntity>(where);

    if (existing != null)
    {
        return existing; 
    }
    else
    {
        table.InsertOnSubmit(record);

        //Can't use table.Context.SubmitChanges()
        //'cause it's read-only

        db.SubmitChanges();
    }

    return record;
}

InformationsquelleAutor core | 2008-09-19

c#linq-to-sql

14
```
public static void InsertIfNotExists<TEntity>
                    (this Table<TEntity> table,
                     TEntity entity,
                     Expression<Func<TEntity,bool>> predicate)
    where TEntity : class
{ 
    if (!table.Any(predicate)) 
    {
        table.InsertOnSubmit(record);
        table.Context.SubmitChanges();
    }
 }


table.InsertIfNotExists(entity, e=>e.BooleanProperty);
```
- Qu'est-ce que e => e.BooleanProperty? Les entités n'ont pas de BooleanProperty membre. Je n'ai jamais vu ça avant...
- Hmm, vous remarquerez que dans mon code, j'ai dit que le tableau.Contexte.SubmitChanges() ne fonctionne pas parce qu'il est d'obtenir uniquement. Apparemment j'ai fait une erreur.
- e=>e.BooleanProperty est juste un exemple. Il peut se tenir debout pour une expression qui renvoie une valeur booléenne.
- Une dernière question (merci pour votre aide, par le moyen!). Quel est l'avantage de l'utilisation de l'Expression<Func<TEntity,bool>> de juste Func<TEntity,bool>? Je vois à se rappeler d'une chose à propos de "compilé expressions." Quand dois-je emballer un Func<> dans une Expression<>, et peut-Action<>s être enveloppés trop?
- Si vous utilisez l'Expression, ça va être converti à SQL et exécutée dans la base de données. Un nu Func pouvez charger l'ensemble de la table en mémoire. Tout délégué peut être du type utilisé pour l'Expression< T>.
- N'est-ce pas créer une situation de concurrence? Quelque chose d'autre pourrait changer la base de données après le Tout() et avant la SubmitChanges() appel?
InformationsquelleAutor Mark Cidade
12

Comme d'autres l'ont souligné, le if (!Any()) { InsertOnSubmit(); } solutions ont toutes une condition de course. Si vous choisissez cette voie, lorsque vous appelez SubmitChanges, vous devez prendre en compte le fait que ce soit un) une SqlException pourraient être soulevées par un double insert, ou b) vous pourriez avoir des doublons dans la table.

Heureusement, nous pouvons utiliser la base de données pour éviter la condition de la course par l'application de l'unicité. Le code suivant suppose qu'il existe une contrainte primary key ou unique sur la table pour empêcher l'insertion de doublons.
```
using (var db = new DataContext()) {

    //Add the new (possibly duplicate) record to the data context here.

    try {
        db.SubmitChanges();
    } catch (SqlException ex) {
        const int violationOfPrimaryKeyContraint = 2627;
        const int violationOfUniqueConstraint = 2601;
        var duplicateRecordExceptionNumbers = new [] {
            violationOfPrimaryKeyContraint, violationOfUniqueConstraint
        };
        if (!duplicateRecordExceptionNumbers.Contains(ex.Number)) {
            throw;
        }
    }
}
```
Maintenant... les choses deviennent un peu juste plus compliqué si vous devez effectuer l'insertion dans un lot de transactions avec d'autres mises à jour de la base de données.

InformationsquelleAutor Michael Kropat
5

D'accord avec marxidad réponse, mais voir la note 1.

Remarque 1: à mon humble avis, il n'est pas sage d'appeler db.SubmitChanges() dans une méthode d'aide, parce que vous risquez de casser le contexte de la transaction. Cela signifie que si vous appelez la InsertIfNotExists<TEntity> au milieu d'un complexe de mise à jour de plusieurs entités vous enregistrez les modifications ne sont pas à la fois, mais dans les étapes.

Note 2: Le InsertIfNotExists<TEntity> méthode est très générique de la méthode qui fonctionne pour n'importe quel scénario. Si vous voulez juste discriminer les entités qui ont chargé à partir de la base de données à partir des entités qui ont été créé à partir du code, vous pouvez utiliser la partielle méthode OnLoaded de l'Entité de la classe comme ceci:
```
public partial class MyEntity
{
    public bool IsLoaded { get; private set; }
    partial void OnLoaded()
    {
        IsLoaded = true;
    }
}
```
Étant donné que (et la note 1), puis InsertIfNotExists fonctionnalité est réduit à ce qui suit:
```
if (!record.IsLoaded)
    db.InsertOnSubmit(record);
```
- Une meilleure conception de la méthode à appeler InsertOnSubmitIfNotExists() et de quitter la table.Contexte.SubmitChanges()
InformationsquelleAutor Panos

Petite modification pour la Marque de la réponse:

Si vous ne se soucient que de vérifier si l'entité existe par sa clé primaire, Marke de réponse peut être utilisée comme ceci:

public static void InsertIfNotExists<TEntity>
                    (this Table<TEntity> table
                     , TEntity entity
                    ) where TEntity : class
    {
        if (!table.Contains(entity))
        {
            table.InsertOnSubmit(entity);

        }
    }

InformationsquelleAutor Jamal

Vous devez vous connecter pour publier un commentaire.