Das EntitySet kann nicht aktualisiert werden, da es eine DefiningQuery enthält und kein <UpdateFunction> -Element vorhanden ist

Ich verwende Entity Framework 1 mit .net 3.5.

Ich mache so etwas Einfaches:

var roomDetails = context.Rooms.ToList();

foreach (var room in roomDetails)
{        
   room.LastUpdated = DateTime.Now;
}

Ich erhalte diesen Fehler, wenn ich Folgendes versuche:

 context.SaveChanges();

Ich bekomme den Fehler:

Das EntitySet kann nicht aktualisiert werden, da es eine DefiningQuery enthält und im Element <ModificationFunctionMapping> kein <UpdateFunction> -Element vorhanden ist, um den aktuellen Vorgang zu unterstützen.

Ich mache viele Aktualisierungen im Kontext und habe keine Probleme. Es ist nur, wenn ich versuche, diese bestimmte Entität zu aktualisieren.

Alle meine Suchvorgänge zeigen dasselbe, dass für die Entität, die ich aktualisieren möchte, kein Primärschlüssel deklariert ist. Aber leider habe ich einen Primärschlüssel deklariert ...

Dies geschieht normalerweise aus einem der folgenden Gründe:

• Der Entitätssatz wird in der Datenbankansicht zugeordnet
• Eine benutzerdefinierte Datenbankabfrage
• Die Datenbanktabelle hat keinen Primärschlüssel

Danach müssen Sie möglicherweise noch im Entity Framework-Designer aktualisieren (oder alternativ die Entität löschen und dann hinzufügen), bevor der Fehler nicht mehr angezeigt wird.

Fügen Sie der Tabelle einfach einen Primärschlüssel hinzu. Das ist es. Problem gelöst.

ALTER TABLE <TABLE_NAME>
ADD CONSTRAINT <CONSTRAINT_NAME> PRIMARY KEY(<COLUMN_NAME>)

Dies ist bei mir der Fall. Das einfache Entfernen führte zu einem weiteren Fehler. Ich habe die Schritte dieses Beitrags bis auf den letzten befolgt. Zur Vereinfachung habe ich die 4 Schritte aus dem Beitrag, den ich zur Lösung des Problems befolgt habe, wie folgt kopiert:

1. Klicken Sie mit der rechten Maustaste auf die edmx-Datei und wählen Sie Öffnen mit, XML-Editor
2. Suchen Sie die Entität im Element edmx: StorageModels
3. Entfernen Sie die DefiningQuery vollständig
4. Benennen Sie das store:Schema="dbo"in um Schema="dbo"(andernfalls generiert der Code einen Fehler, der besagt, dass der Name ungültig ist).

Beachten Sie nur, dass Ihre Entität möglicherweise einen Primärschlüssel hat , Ihre Tabelle in der Datenbank jedoch keinen Primärschlüssel .

UPDATE: Ich habe in letzter Zeit ein paar positive Stimmen dazu bekommen, also dachte ich mir, ich würde die Leute wissen lassen, dass der Rat, den ich unten gebe, nicht der beste ist. Seit ich anfänglich damit angefangen habe, Entity Framework für alte schlüssellose Datenbanken zu verwenden, habe ich festgestellt, dass das Beste, was Sie bei weitem tun können, darin besteht, es zuerst mit dem umgekehrten Code zuerst auszuführen. Es gibt ein paar gute Artikel darüber, wie das geht. Folgen Sie ihnen einfach, und wenn Sie einen Schlüssel hinzufügen möchten, verwenden Sie Datenanmerkungen, um den Schlüssel zu "fälschen".

Nehmen wir zum Beispiel an, ich weiß, dass meine Tabelle Orders, obwohl sie keinen Primärschlüssel hat, immer nur eine Bestellnummer pro Kunde hat. Da dies die ersten beiden Spalten in der Tabelle sind, habe ich die Code-First-Klassen so eingerichtet, dass sie folgendermaßen aussehen:

    [Key, Column(Order = 0)]
    public Int32? OrderNumber { get; set; }

    [Key, Column(Order = 1)]
    public String Customer { get; set; }

Auf diese Weise täuschen Sie EF im Grunde vor, dass es einen Clustered Key gibt, der aus OrderNumber und Customer besteht. Auf diese Weise können Sie Einfügungen, Aktualisierungen usw. für Ihren schlüssellosen Tisch vornehmen.

Wenn Sie mit Reverse Code First nicht allzu vertraut sind, finden Sie ein gutes Tutorial zu Entity Framework Code First. Suchen Sie dann einen unter Reverse Code First (der Code First mit einer vorhandenen Datenbank ausführt). Dann komm einfach zurück und schau dir noch einmal meine wichtigsten Ratschläge an. :) :)

Ursprüngliche Antwort :

Erstens: Wie andere bereits gesagt haben, besteht die beste Option darin, der Tabelle einen Primärschlüssel hinzuzufügen. Punkt. Wenn Sie dies tun können, lesen Sie nicht weiter.

Aber wenn Sie nicht können oder sich einfach nur hassen, gibt es eine Möglichkeit, dies ohne den Primärschlüssel zu tun.

In meinem Fall arbeitete ich mit einem Legacy-System (ursprünglich flache Dateien auf einem AS400, der auf Access portiert und dann auf T-SQL portiert wurde). Also musste ich einen Weg finden. Das ist meine Lösung. Das Folgende funktionierte für mich mit Entity Framework 6.0 (das neueste auf NuGet zum Zeitpunkt dieses Schreibens).

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihre EDMX-Datei. Wählen Sie "Öffnen mit ..." und dann "XML (Text) Editor". Wir werden den automatisch generierten Code hier von Hand bearbeiten.

2. Suchen Sie nach einer Zeile wie dieser:
   <EntitySet Name="table_name" EntityType="MyModel.Store.table_name" store:Type="Tables" store:Schema="dbo" store:Name="table_nane">

3. store:Name="table_name"Vom Ende entfernen .

4. Wechseln Sie store:Schema="whatever"zuSchema="whatever"

5. Schauen Sie unter diese Zeile und finden Sie das <DefiningQuery>Tag. Es wird eine große alte select-Anweisung enthalten. Entfernen Sie das Tag und seinen Inhalt.

6. Jetzt sollte Ihre Linie ungefähr so ​​aussehen:
   <EntitySet Name="table_name" EntityType="MyModel.Store.table_name" store:Type="Tables" Schema="dbo" />

7. Wir müssen noch etwas ändern. Gehen Sie Ihre Datei durch und finden Sie Folgendes:
   <EntityType Name="table_name">

8. In der Nähe wird wahrscheinlich ein kommentierter Text angezeigt, der Sie darauf hinweist, dass kein Primärschlüssel identifiziert wurde. Daher wurde der Schlüssel abgeleitet und die Definition ist eine schreibgeschützte Tabelle / Ansicht. Sie können es verlassen oder löschen. Ich habe es gelöscht.

9. Unten ist das <Key>Tag. Dies wird Entity Framework zum Einfügen / Aktualisieren / Löschen verwenden. Stellen Sie also sicher, dass Sie dies richtig machen. Die Eigenschaft (oder Eigenschaften) in diesem Tag müssen eine eindeutig identifizierbare Zeile angeben. Nehmen wir zum Beispiel an, ich weiß, dass meine Tabelle orders, obwohl sie keinen Primärschlüssel hat, immer nur eine Bestellnummer pro Kunde hat.

Meins sieht also so aus:

<EntityType Name="table_name">
              <Key>
                <PropertyRef Name="order_numbers" />
                <PropertyRef Name="customer_name" />
              </Key>

Im Ernst, mach das nicht falsch. Nehmen wir an, obwohl es niemals Duplikate geben sollte, gelangen irgendwie zwei Zeilen mit derselben Bestellnummer und demselben Kundennamen in mein System. Whooops! Das bekomme ich, wenn ich keinen Schlüssel benutze! Also benutze ich Entity Framework, um eines zu löschen. Da ich weiß, dass das Duplikat die einzige Bestellung ist, die heute aufgegeben wird, mache ich Folgendes:

var duplicateOrder = myModel.orders.First(x => x.order_date == DateTime.Today);
myModel.orders.Remove(duplicateOrder);

Erraten Sie, was? Ich habe gerade sowohl das Duplikat als auch das Original gelöscht! Das liegt daran, dass ich Entity Framework mitgeteilt habe, dass order_number / cutomer_name mein Primärschlüssel ist. Als ich ihm sagte, er solle duplicateOrder entfernen, war das im Hintergrund ungefähr so:

DELETE FROM orders
WHERE order_number = (duplicateOrder's order number)
AND customer_name = (duplicateOrder's customer name)

Und mit dieser Warnung ... sollten Sie jetzt bereit sein zu gehen!

Dies kann auch passieren, wenn das Datenmodell veraltet ist.

Hoffentlich erspart dies jemand anderem Frustration :)

Ich habe die gleiche Fehlermeldung erhalten, aber in meinem Szenario habe ich versucht, Entitäten, die aus einer Viele-zu-Viele-Beziehung abgeleitet wurden, mithilfe eines PJT (Pure Join Table) zu aktualisieren.

Beim Lesen der anderen Beiträge dachte ich, ich könnte das Problem beheben, indem ich der Join-Tabelle ein zusätzliches PK-Feld hinzufüge. Wenn Sie jedoch einer Join-Tabelle eine PK-Spalte hinzufügen, handelt es sich nicht mehr um ein PJT, und Sie verlieren alle Vorteile des Entity Frameworks wie die automatische Zuordnung von Beziehungen zwischen den Entitäten.

In meinem Fall bestand die Lösung darin, die Join-Tabelle in der Datenbank so zu ändern, dass eine PK erstellt wird, die BEIDE der fremden ID-Spalten enthält.

Wenn Ihre Tabelle keinen Primärschlüssel hat, kann ein Fehler auftreten. In diesem Fall ist die Tabelle "schreibgeschützt", und der Befehl db.SaveChanges () führt immer zu einem Fehler

Setzen Sie den Primärschlüssel, speichern Sie die Tabelle und aktualisieren Sie sie. Gehen Sie dann zu Model.edmx, löschen Sie die Tabelle und rufen Sie sie erneut ab.

Fügen Sie einfach einen Primärschlüssel hinzu

Hinweis: Stellen Sie sicher, dass beim Aktualisieren Ihres EF-Diagramms aus der Datenbank, die Sie auf die richtige Datenbank verweisen , in meinem Fall die Verbindungszeichenfolge auf eine lokale Datenbank anstatt auf die aktuelle Dev DB, Schuljunge, verweist Fehler, den ich kenne, aber ich wollte dies posten, weil es sehr frustrierend sein kann, wenn Sie überzeugt sind, dass Sie den Primärschlüssel hinzugefügt haben und immer noch den gleichen Fehler erhalten

Ich hatte das gleiche Problem. Wie dieser Thread sagte, hatte meine Tabelle keine PK, also habe ich die PK festgelegt und den Code ausgeführt. Aber leider kam wieder ein Fehler. Als Nächstes habe ich die DB-Verbindung gelöscht (.edmx-Datei im Modellordner des Projektmappen-Explorers löschen) und neu erstellt. Fehler danach verschwunden. Vielen Dank an alle, die Ihre Erfahrungen geteilt haben. Das spart viel Zeit.

Ich habe dieses Problem erhalten, weil ich mein EDMX aus einer vorhandenen Datenbank generiert habe (von jemand anderem entworfen, und ich verwende den Begriff "entworfen" hier lose).

Es stellte sich heraus, dass der Tisch überhaupt keine Schlüssel hatte. EF generierte das Modell mit vielen mehreren Schlüsseln. Ich musste der Datenbank-Tabelle in SQL einen Primärschlüssel hinzufügen und dann mein Modell in VS aktualisieren.

Das hat es für mich behoben.

Dies ist keine neue Antwort, hilft aber jemandem, der nicht sicher ist, wie er den Primärschlüssel für seine Tabelle festlegen soll. Verwenden Sie dies in einer neuen Abfrage und führen Sie es aus. Dadurch wird die UniqueID-Spalte als Primärschlüssel festgelegt.

USE [YourDatabaseName]
GO

Alter table  [dbo].[YourTableNname]
Add Constraint PK_YourTableName_UniqueID Primary Key Clustered (UniqueID);
GO

In meinem Fall habe ich vergessen, den Primärschlüssel für die Tabelle zu definieren. Weisen Sie also wie in Bild gezeigt zu und aktualisieren Sie Ihre Tabelle aus "Modell aus Datenbank aktualisieren" aus der EDMX-Datei. Hoffe es wird helfen !!!

Das Hinzufügen des Primärschlüssels hat auch bei mir funktioniert!

Sobald dies erledigt ist, können Sie das Datenmodell wie folgt aktualisieren, ohne es zu löschen:

Klicken Sie mit der rechten Maustaste auf die edmx Entity Designer-Seite und klicken Sie auf "Modell aus Datenbank aktualisieren".

Ich hatte genau das gleiche Problem, leider löst das Hinzufügen des Primärschlüssels das Problem nicht. So löse ich meine:

1. Stellen Sie sicher, dass Sie einen primary keyauf dem Tisch haben, damit ich meine Tabelle ändere und einen Primärschlüssel hinzufüge.
2. Delete the ADO.NET Entity Data Model (edmx-Datei), in der ich meine Datenbank abbilde und mit ihr verbinde.
3. Add again a new file of ADO.NET Entity Data Model um eine Verbindung mit meiner Datenbank herzustellen und meine Modelleigenschaften zuzuordnen.
4. Clean and rebuild the solution.

Problem gelöst.

Fügen Sie einfach einen Primärschlüssel zu Ihrer Tabelle hinzu und erstellen Sie dann Ihre EF neu

Ich musste nur die Tabelle aus dem Modell entfernen und das Modell erneut aktualisieren, um die Tabelle zurückzubringen. Ich denke, der Primärschlüssel wurde erstellt, nachdem die Tabelle in das Modell gezogen wurde.

Ich hatte dieses Problem und glaube, es wurde verursacht, weil ich den Index für den Primärschlüssel meiner Tabelle gelöscht und durch einen Index für einige der anderen Felder in der Tabelle ersetzt hatte.

Nachdem ich den Primärschlüsselindex gelöscht und den edmx aktualisiert hatte, funktionierten die Einfügungen nicht mehr.

Ich habe die Tabelle auf die ältere Version aktualisiert, den edmx aktualisiert und alles funktioniert wieder.

Ich sollte beachten, dass beim Öffnen des EDMX zur Behebung dieses Problems überprüft wurde, ob ein Primärschlüssel definiert war. Keiner der oben genannten Vorschläge hat mir also geholfen. Das Aktualisieren des Index für den Primärschlüssel schien jedoch zu funktionieren.

Öffnen Sie Ihre .edmx-Datei im XML-Editor, entfernen Sie das Tag aus dem Tag und ändern Sie den Speicher: Schema = "dbo" in Schema = "dbo". Erstellen Sie die Lösung jetzt neu. Der Fehler wird behoben und Sie können die Daten speichern.

Ich fand, dass die ursprüngliche Antwort auf das Aktualisieren der EDMX-Datei in meiner Situation am besten funktioniert. Ich war einfach nicht sehr glücklich darüber, das Modell jedes Mal zu ändern, wenn es aus der Datenbank aktualisiert wurde. Aus diesem Grund habe ich eine zusätzliche Textvorlagendatei geschrieben, die automatisch aufgerufen wird, wenn sich das Modell geändert hat - genau wie die Entitäten neu generiert wurden. Ich poste es hier in diesem Kommentar. Damit es funktioniert, stellen Sie sicher, dass Sie es wie {Modellname} .something.tt benennen und im selben Ordner wie Ihr .edmx-Ordner speichern. Ich habe es {Modellname} .NonPkTables.tt genannt. Aufgrund der ungültigen Dateierweiterungsdefinition in der zweiten Zeile wird keine eigene Datei generiert. Fühlen Sie sich frei zu benutzen.

<#@ template language="C#" debug="false" hostspecific="true"#>
<#@ output extension="/" #>
<#@ assembly name="System.Core" #>
<#@ assembly name="System.Data" #>
<#@ assembly name="System.Windows.Forms" #>
<#@ assembly name="System.Xml" #>
<#@ assembly name="System.Xml.Linq"#>
<#@ assembly name="%VS120COMNTOOLS%..\IDE\EntityFramework.dll" #>
<#@ assembly name="%VS120COMNTOOLS%..\IDE\Microsoft.Data.Entity.Design.dll" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Windows.Forms" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Xml" #>
<#@ import namespace="System.Xml.Linq" #>
<#@ import namespace="System.Globalization" #>
<#@ import namespace="System.Reflection" #>
<#@ import namespace="System.Data.Entity.Core.Metadata.Edm" #>
<#@ import namespace="System.Data.Entity.Core.Mapping" #>
<#@ import namespace="System.CodeDom" #>
<#@ import namespace="System.CodeDom.Compiler" #>
<#@ import namespace="Microsoft.CSharp"#>
<#@ import namespace="System.Text"#>
<#@ import namespace="System.Diagnostics" #>

<#
    string modelFileName= this.Host.TemplateFile.Split('.')[0] + ".edmx";
    string edmxPath = this.Host.ResolvePath( modelFileName );

    // MessageBox.Show( this.Host.TemplateFile + " applied." );
    var modelDoc = XDocument.Load(edmxPath);
    var root = modelDoc.Root;
    XNamespace nsEdmx = @"http://schemas.microsoft.com/ado/2009/11/edmx";
    XNamespace ns = @"http://schemas.microsoft.com/ado/2009/11/edm/ssdl";

    var runtime = root.Elements(nsEdmx + "Runtime").First();
    var storageModels = runtime.Elements(nsEdmx + "StorageModels").First();
    XNamespace nsStore = @"http://schemas.microsoft.com/ado/2007/12/edm/EntityStoreSchemaGenerator";

    var schema = storageModels.Elements(ns + "Schema").First();
    XNamespace nsCustomAnnotation = @"http://schemas.microsoft.com/ado/2013/11/edm/customannotation";

    var entityTypes = schema.Nodes().OfType<XComment>().Where(c => c.Value.Contains("warning 6002: The table/view"));
    bool changed = false;

    foreach (var node in entityTypes)
    {
        var element = node.ElementsAfterSelf().First();
        string entityName = element.Attribute("Name").Value;

        // Find EntitySet in EntityContainer.
        var entityContainer = schema.Elements(ns + "EntityContainer").First();
        var entitySet = entityContainer.Elements(ns + "EntitySet").First(s => s.Attribute("Name").Value == entityName);

        // Change "store:Schema" attribute to "Schema" attribute.
        var attribute = entitySet.Attribute(nsStore + "Schema");

        if (attribute != null)
        {
            string schemaName = entitySet.Attribute(nsStore + "Schema").Value;
            entitySet.Attribute(nsStore + "Schema").Remove();
            entitySet.Add(new XAttribute("Schema", schemaName));
            changed |= true;
        }

        // Remove the DefiningQuery element.
        var definingQuery = entitySet.Element(ns + "DefiningQuery");

        if (definingQuery != null)
        {
            definingQuery.Remove();
            changed |= true;        
            Debug.WriteLine(string.Format("Removed defining query of EntitySet {0}.", entityName));
        }
    }

    if (changed)
        modelDoc.Save(edmxPath);
#>

Ich hatte die gleiche Fehlermeldung beim Einfügen eines Datensatzes in eine Tabelle mit einer Viele-zu-Viele- Beziehung. Mein Datenbankschema war:

Student (Id , Name)
Course (Code , Title),
Student-Course (Student_ID, Course_Code)

Tabelle : Student und Course haben Primärschlüssel Id und - Code jeweils , während der Tisch Schüler-Kurs hat zwei Fremdschlüssel abgebildet mit Studenten und Kurstabellen.

Logischerweise ist das Schema korrekt, aber ich habe einen Fehler in der Datenbank gemacht, da jede Tabelle einen Primärschlüssel haben sollte.

Meine SQL-Definition für den Studentenkurs war:

CREATE TABLE [dbo].[Student-Course] (
    [StudentID]  VARCHAR (12) NOT NULL,
    [CourseCode] VARCHAR (10) NOT NULL,
    CONSTRAINT [FK_Student-Course_ToCourse] FOREIGN KEY ([Course_Code]) REFERENCES [dbo].[Course] ([Code]) ON DELETE CASCADE,
    CONSTRAINT [FK_Student-Course_ToStudent] FOREIGN KEY ([Student_ID]) REFERENCES [dbo].[Student] ([Id]) ON DELETE CASCADE
);

Ich habe ein Paar Fremdschlüssel zum Primärschlüssel dieser Tabelle gemacht und aktualisiert auf:

CREATE TABLE [dbo].[Student-Course] (
    [StudentID]  VARCHAR (12) NOT NULL,
    [CourseCode] VARCHAR (10) NOT NULL,
    CONSTRAINT [PK_Student-Course] PRIMARY KEY CLUSTERED ([Student_ID] ASC, [Course_Code] ASC),
    CONSTRAINT [FK_Student-Course_ToCourse] FOREIGN KEY ([Course_Code]) REFERENCES [dbo].[Course] ([Code]) ON DELETE CASCADE,
    CONSTRAINT [FK_Student-Course_ToStudent] FOREIGN KEY ([Student_ID]) REFERENCES [dbo].[Student] ([Id]) ON DELETE CASCADE
);

Hoffe, es wird Probleme für einige Leute lösen.