Le moyen le plus efficace de mise à jour avec LINQ to SQL

Puis-je mettre à jour mon dossier employé comme donné dans la fonction ci-dessous ou dois-je faire une requête de l'employé de la collection en premier et ensuite mettre à jour les données?

  public int updateEmployee(App3_EMPLOYEE employee)
  {
      DBContextDataContext db = new DBContextDataContext();
      db.App3_EMPLOYEEs.Attach(employee);
      db.SubmitChanges();
      return employee.PKEY;
  }

Ou dois-je faire la suite?

public int updateEmployee(App3_EMPLOYEE employee)
{
    DBContextDataContext db = new DBContextDataContext();
    App3_EMPLOYEE emp = db.App3_EMPLOYEEs.Single(e => e.PKEY == employee.PKEY);
    db.App3_EMPLOYEEs.Attach(employee,emp);
    db.SubmitChanges();
    return employee.PKEY;
}

Mais je ne veux pas utiliser la deuxième option. Est-il un moyen efficace de mise à jour des données?

J'obtiens cette erreur par l'utilisation de deux façons:

Une tentative a été faite pour Attacher ou d'Ajouter une entité qui n'est pas nouveau, peut-être d'avoir été chargé d'une autre DataContext. Ce n'est pas pris en charge.

dans la deuxième méthode vous attachez de l'entité de contexte, car il est déjà rempli à partir d'elle. Appelez simplement SubmitChanges()

InformationsquelleAutor Pranay Rana | 2010-05-20

asp.net c#datacontext linq linq-to-sql

- Je trouver la suite contourner ce problème :

1) extraction et de mise à jour de l'entité (que je vais utiliser de cette façon parce que c'est ok pour moi )

public int updateEmployee(App3_EMPLOYEE employee)
{
    AppEmployeeDataContext db = new AppEmployeeDataContext();
    App3_EMPLOYEE emp = db.App3_EMPLOYEEs.Single(e => e.PKEY == employee.PKEY);
    emp.FIRSTNAME = employee.FIRSTNAME;//copy property one by one 
    db.SubmitChanges();
    return employee.PKEY;
}

2) désactiver ObjectTrackingEnabled comme suit

//but in this case lazy loading is not supported


    public AppEmployeeDataContext() : 
                    base(global::LinqLibrary.Properties.Settings.Default.AppConnect3DBConnectionString, mappingSource)
            {
                this.ObjectTrackingEnabled = false;
                OnCreated();
            }

3) enlever tous les objets liés à l'

partial class App3_EMPLOYEE
{
    public void Detach()
    {
        this._APP3_EMPLOYEE_EXTs = default(EntityRef<APP3_EMPLOYEE_EXT>);
    }
}

 public int updateEmployee(App3_EMPLOYEE employee)
{
    AppEmployeeDataContext db = new AppEmployeeDataContext();
    employee.Detach();
    db.App3_EMPLOYEEs.Attach(employee,true);
    db.SubmitChanges();
    return employee.PKEY;
}

4) utiliser l'horodatage dans la colonne

 http://www.west-wind.com/weblog/posts/135659.aspx

5) Créer une procédure stockée pour la mise à jour de vos données et de les appeler par db contexte

InformationsquelleAutor Pranay Rana

3

Vous ne pouvez pas attacher une modification de l'entité à un DataContext quand il n'y a pas de RowVersion colonne. Au lieu de cela, vous pouvez stocker entité d'origine dans votre application aussi longtemps que le maintien d'une copie des modifications de données. Ensuite, lorsque des modifications doivent être enregistrées vous pouvez joindre entité d'origine à un DataContext, changer ses valeurs pour correspondre à la modification de l'entité de valeurs et de soumettre les modifications.

Voici un exemple:
```
public int updateEmployee(App3_EMPLOYEE employee, App3_EMPLOYEE originalEmployee)
{
    DBContextDataContext db = new DBContextDataContext();
    db.App3_EMPLOYEEs.Attach(originalEmployee);

    //TODO: Copy values from employee to original employee

    db.SubmitChanges();
    return employee.PKEY;
}
```
Mise à jour:

Il y a une table dans la base de données avec les colonnes ID, le Nom, les Notes
```
//fetch an employee which will not be changed in the application
Employee original;
using(var db = new TestDbDataContext())
{
  original = db.Employees.First(e => e.ID == 2);
}

//create an instance to work with
var modified = new Employee {ID = original.ID, Name = original.Name, Notes = original.Notes};

//change some info
modified.Notes = string.Format("new notes as of {0}", DateTime.Now.ToShortTimeString());  
//update
using(var db = new TestDbDataContext())
{
  db.Employees.Attach(original);
  original.Notes = modified.Notes;
  db.SubmitChanges();
}
```
- pas vous obtenir pouvez-vous m'envoyer un lien ou un exemple de ce
- Je vais ajouter un peu de code de test pour démontrer l'ensemble du scénario
- maintenant je suis à l'aide de la même chose, adaptation de données de l'modifié à l'original
- donc, c'est la façon dont j'utilise pour ne pas avoir de demande supplémentaire pour l'état actuel d'un enregistrement dans la base de données. La différence est que j'attache une original entité pour le DataContext et ensuite modifier attaché entité avant de soumettre
- et l'erreur que vous obtenez, je pense, parce que quelque part dans votre application (où vous lisez des données) vous n'avez pas éliminé le datacontext et un employé de l'entité est attaché à elle. Donc, si vous utilisez la même instance du datacontext (qui a été utilisé pour la récupération des données) pour enregistrer, puis il devrait également fonctionner pour vous.
InformationsquelleAutor dh.
2

Il y a une discussion sur ce sujet ici MSDN à l'adresse s
vous recommandons d'utiliser un IsVersion champ et la méthode Attach

InformationsquelleAutor Devart
2

Vous pouvez attacher une seule modifié entité, à l'aide de cette surcharge:
```
db.App3_EMPLOYEEs.Attach(employee, true);//Attach as modfieied
```
Notez que pour que cela fonctionne, vous devez avoir à votre table une "Version" colonne de type timestamp"

InformationsquelleAutor yoel halb

C'est une fonction dans mon Référentiel de la classe que j'utilise pour mettre à jour les entités

protected void Attach(TEntity entity)
{
   try
    {
       _dataContext.GetTable<TEntity>().Attach(entity);
       _dataContext.Refresh(RefreshMode.KeepCurrentValues, entity);
    }
    catch (DuplicateKeyException ex) //Data context knows about this entity so just update values
    {
       _dataContext.Refresh(RefreshMode.KeepCurrentValues, entity);
    }
}

Où TEntity est votre DB Classe et en fonction de votre installation, vous pourriez juste voulez faire

_dataContext.Attach(entity);

InformationsquelleAutor Adam Bilinski

Utiliser cette étendre la méthode de mise à jour de toutes les propriétés qui sont les attributs de colonne:

public static void SaveToOriginal<T>(this T original, T actual)
    {
        foreach (var prop in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)
            .Where(info => info.GetCustomAttribute<System.Data.Linq.Mapping.ColumnAttribute>() != null))
        {
            prop.SetValue(original, prop.GetValue(actual));
        }
    }

Je veux dire, il faut d'abord récupérer l'original de la base de données, utilisez la méthode pour cartographier toutes les colonnes les attributs d'élément nouveau à l'original, et enfin faire un submit.
J'espère que cette aide.

InformationsquelleAutor Pedro Llanes

Vous devez vous connecter pour publier un commentaire.