Entity Framework 6 Code first Standardwert

203

Gibt es eine "elegante" Möglichkeit, einer bestimmten Eigenschaft einen Standardwert zu geben?

Vielleicht von DataAnnotations, so etwas wie:

[DefaultValue("true")]
public bool Active { get; set; }

Danke dir.

marino-krk
quelle
Vielleicht versuchen Sie es im Konstruktor this.Active = true;? Ich denke, der DB-Wert hat beim Abrufen Vorrang, aber seien Sie vorsichtig, wenn Sie neu sind, und fügen Sie dann zuerst eine Entität für ein Update ohne Abruf hinzu, da die Änderungsverfolgung dies möglicherweise sieht, wenn Sie den Wert aktualisieren möchten. Kommentar, weil ich EF schon lange nicht mehr verwendet habe und ich denke, dass dies ein Schuss in die Dunkelheit ist.
AaronLS
3
Vielen Dank für die Antwort. Ich habe diese Methode bisher verwendet. Stackoverflow.com/a/5032578/2913441, aber ich dachte, dass es vielleicht einen besseren Weg gibt.
Marino-Krk
2
public bool Inactive { get; set; }😉
Jesse Hufstetler
In Microsoft-Dokumenten heißt es: "Mit Datenanmerkungen können Sie keinen Standardwert festlegen."
hmfarimani
Bitte beachten Sie https://stackoverflow.com/a/59551802/8403632
shalitha senanayaka

Antworten:

166

Sie können dies tun, indem Sie die erste Migration des Codes manuell bearbeiten:

public override void Up()
{    
   AddColumn("dbo.Events", "Active", c => c.Boolean(nullable: false, defaultValue: true));
} 
gdbdable
quelle
6
Ich bin nicht sicher , ob dies funktionieren wird , wenn OP speziell nicht festgelegt Activeauf , truewenn eine der Erstellung Eventals auch Objekt. Der Standardwert befindet sich immer in falseeiner nicht nullbaren Bool-Eigenschaft. Sofern nicht geändert, wird das Entity-Framework in der Datenbank gespeichert. Oder fehlt mir etwas?
GFoley83
6
@ GFoley83, ja, du hast recht. Diese Methode fügt nur Standardeinschränkungen auf Datenbankebene hinzu. Für eine vollständige Lösung müssen Sie auch den Standardwert im Konstruktor der Entität zuweisen oder eine Eigenschaft mit einem gesicherten Feld verwenden, wie in der obigen Antwort gezeigt
gdbdable
1
Dies funktioniert für Basistypen. Verwenden Sie für etwas wie DATETIMEOFFSET den Wert defaultValueSql: "SYSDATETIMEOFFSET" und NICHT den Standardwert, da dieser Standardwert: System.DateTimeOffset.Now in eine Zeichenfolge des aktuellen System-Datums- / Zeitversatzwerts aufgelöst wird.
OzBob
3
AFAIK Ihre manuellen Änderungen gehen verloren, wenn die Migration neu aufgebaut wird
Alexander Powolozki
1
@ninbit Ich denke, Sie sollten zuerst eine Migration schreiben, um sie auf Datenbankebene zu entfernen, und dann Ihre DAL-Zuordnung ändern
gdbdable
74

Es ist eine Weile her, aber eine Notiz für andere hinterlassen. Ich habe mit einem Attribut erreicht, was benötigt wird, und meine Modellklassenfelder mit diesem Attribut nach Belieben dekoriert.

[SqlDefaultValue(DefaultValue = "getutcdate()")]
public DateTime CreatedDateUtc { get; set; }

Habe die Hilfe dieser 2 Artikel bekommen:

Was ich getan habe:

Attribut definieren

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
public class SqlDefaultValueAttribute : Attribute
{
    public string DefaultValue { get; set; }
}

Im "OnModelCreating" des Kontexts

modelBuilder.Conventions.Add( new AttributeToColumnAnnotationConvention<SqlDefaultValueAttribute, string>("SqlDefaultValue", (p, attributes) => attributes.Single().DefaultValue));

Im benutzerdefinierten SqlGenerator

private void SetAnnotatedColumn(ColumnModel col)
{
    AnnotationValues values;
    if (col.Annotations.TryGetValue("SqlDefaultValue", out values))
    {
         col.DefaultValueSql = (string)values.NewValue;
    }
}

Registrieren Sie dann im Konstruktor für die Migrationskonfiguration den benutzerdefinierten SQL-Generator.

SetSqlGenerator("System.Data.SqlClient", new CustomMigrationSqlGenerator());
Ravinsp
quelle
6
Sie können dies sogar global tun, ohne [SqlDefaultValue(DefaultValue = "getutcdate()")]jede Entität anzulegen. 1) Einfach entfernen modelBuilder.Conventions.Add( new AttributeToColumnAnnotationConvention<SqlDefaultValueAttribute, string>("SqlDefaultValue", (p, attributes) => attributes.Single().DefaultValue)); 2) HinzufügenmodelBuilder.Properties().Where(x => x.PropertyType == typeof(DateTime)).Configure(c => c.HasColumnType("datetime2").HasDatabaseGeneratedOption(DatabaseGeneratedOption.Computed).HasColumnAnnotation("SqlDefaultValue", "getdate()"));
Daniel Skowroński
1
Wo ist der benutzerdefinierte SqlGenerator bitte?
24 ʙᴀᴋᴇʀ
3
Benutzerdefinierte SqlGenerator kam von hier: andy.mehalick.com/2014/02/06/…
Ravinsp
1
@ravinsp Warum sollten Sie die MigrationCodeGenerator-Klasse nicht so anpassen, dass die Migration die richtigen Informationen anstelle des SqlGenerator-Codes enthält? Der SQL-Code ist der letzte Schritt ...
Alex
@ Alex Es lohnt sich zu versuchen! Das würde auch funktionieren und wäre eleganter als das Einfügen von SQL-Code. Ich bin mir jedoch nicht sicher, wie komplex es ist, den C # MigrationCodeGenerator zu überschreiben.
Ravinsp
73

Die obigen Antworten haben wirklich geholfen, aber nur einen Teil der Lösung geliefert. Das Hauptproblem besteht darin, dass die Einschränkung für die Spalte in der Datenbank nicht entfernt wird, sobald Sie das Standardwertattribut entfernen. Der vorherige Standardwert bleibt also weiterhin in der Datenbank.

Hier finden Sie eine vollständige Lösung des Problems, einschließlich des Entfernens von SQL-Einschränkungen beim Entfernen von Attributen. Ich verwende auch das native DefaultValueAttribut von .NET Framework erneut .

Verwendung

[DatabaseGenerated(DatabaseGeneratedOption.Computed)]
[DefaultValue("getutcdate()")]
public DateTime CreatedOn { get; set; }

Damit dies funktioniert, müssen Sie die Dateien IdentityModels.cs und Configuration.cs aktualisieren

Datei IdentityModels.cs

Fügen Sie diese Methode in Ihrer ApplicationDbContextKlasse hinzu / aktualisieren Sie sie

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
            base.OnModelCreating(modelBuilder);
            var convention = new AttributeToColumnAnnotationConvention<DefaultValueAttribute, string>("SqlDefaultValue", (p, attributes) => attributes.SingleOrDefault().Value.ToString());
            modelBuilder.Conventions.Add(convention);
}

Datei Configuration.cs

Aktualisieren Sie Ihren ConfigurationKlassenkonstruktor, indem Sie einen benutzerdefinierten SQL-Generator wie folgt registrieren:

internal sealed class Configuration : DbMigrationsConfiguration<ApplicationDbContext>
{
    public Configuration()
    {
        // DefaultValue Sql Generator
        SetSqlGenerator("System.Data.SqlClient", new DefaultValueSqlServerMigrationSqlGenerator());
    }
}

Fügen Sie als Nächstes eine benutzerdefinierte SQL-Generatorklasse hinzu (Sie können sie der Datei Configuration.cs oder einer separaten Datei hinzufügen ).

internal class DefaultValueSqlServerMigrationSqlGenerator : SqlServerMigrationSqlGenerator
{
    private int dropConstraintCount = 0;

    protected override void Generate(AddColumnOperation addColumnOperation)
    {
        SetAnnotatedColumn(addColumnOperation.Column, addColumnOperation.Table);
        base.Generate(addColumnOperation);
    }

    protected override void Generate(AlterColumnOperation alterColumnOperation)
    {
        SetAnnotatedColumn(alterColumnOperation.Column, alterColumnOperation.Table);
        base.Generate(alterColumnOperation);
    }

    protected override void Generate(CreateTableOperation createTableOperation)
    {
        SetAnnotatedColumns(createTableOperation.Columns, createTableOperation.Name);
        base.Generate(createTableOperation);
    }

    protected override void Generate(AlterTableOperation alterTableOperation)
    {
        SetAnnotatedColumns(alterTableOperation.Columns, alterTableOperation.Name);
        base.Generate(alterTableOperation);
    }

    private void SetAnnotatedColumn(ColumnModel column, string tableName)
    {
        AnnotationValues values;
        if (column.Annotations.TryGetValue("SqlDefaultValue", out values))
        {
            if (values.NewValue == null)
            {
                column.DefaultValueSql = null;
                using (var writer = Writer())
                {
                    // Drop Constraint
                    writer.WriteLine(GetSqlDropConstraintQuery(tableName, column.Name));
                    Statement(writer);
                }
            }
            else
            {
                column.DefaultValueSql = (string)values.NewValue;
            }
        }
    }

    private void SetAnnotatedColumns(IEnumerable<ColumnModel> columns, string tableName)
    {
        foreach (var column in columns)
        {
            SetAnnotatedColumn(column, tableName);
        }
    }

    private string GetSqlDropConstraintQuery(string tableName, string columnName)
    {
        var tableNameSplittedByDot = tableName.Split('.');
        var tableSchema = tableNameSplittedByDot[0];
        var tablePureName = tableNameSplittedByDot[1];

        var str = $@"DECLARE @var{dropConstraintCount} nvarchar(128)
SELECT @var{dropConstraintCount} = name
FROM sys.default_constraints
WHERE parent_object_id = object_id(N'{tableSchema}.[{tablePureName}]')
AND col_name(parent_object_id, parent_column_id) = '{columnName}';
IF @var{dropConstraintCount} IS NOT NULL
    EXECUTE('ALTER TABLE {tableSchema}.[{tablePureName}] DROP CONSTRAINT [' + @var{dropConstraintCount} + ']')";

        dropConstraintCount = dropConstraintCount + 1;
        return str;
    }
}
Jevgenij Martynenko
quelle
2
Dieser Ansatz hat bei mir perfekt funktioniert. Eine Verbesserung, die ich vorgenommen habe, bestand darin, auch Generieren (CreateTableOperation createTableOperation) und Generieren (AddColumnOperation addColumnOperation) mit derselben Logik zu überschreiben, damit diese Szenarien auch abgefangen werden. Ich überprüfe auch nur Werte. NewValue ist null, da ich wollte, dass meine Standardeinstellung eine leere Zeichenfolge ist.
Delorian
2
@ Delorian Ich habe meine Antwort aktualisiert, danke für Ihre Kommentare
Jevgenij Martynenko
1
Ich habe Ihren Beitrag bearbeitet, um Fälle zu unterstützen, in denen ein Rollback mehr als eine Einschränkung löscht. Ihr Skript würde einen Fehler auslösen, der besagt, dass @con bereits deklariert wurde. Ich habe eine private Variable erstellt, um einen Zähler zu halten und ihn einfach zu erhöhen. Ich habe auch das Format der Drop-Einschränkung geändert, um besser mit dem übereinzustimmen, was EF beim Erstellen der Einschränkung an SQL sendet. Tolle Arbeit daran!
Brad
1
Vielen Dank für die Lösung, aber ich habe zwei Probleme: 1. Tabellennamen benötigen Klammern. 2. Beim Update wird kein neuer Wert gesetzt und stattdessen der Standardwert gesetzt!
Omid-RH
1
Muss ich das [DatabaseGenerated(DatabaseGeneratedOption.Computed)]Attribut festlegen ? Wenn ja warum? In meinen Tests schien es keine Wirkung zu haben, es wegzulassen.
RamNow
26

Ihre Modelleigenschaften müssen keine "automatischen Eigenschaften" sein, auch wenn dies einfacher ist. Und das DefaultValue-Attribut besteht eigentlich nur aus informativen Metadaten. Die hier akzeptierte Antwort ist eine Alternative zum Konstruktoransatz.

public class Track
{

    private const int DEFAULT_LENGTH = 400;
    private int _length = DEFAULT_LENGTH;
    [DefaultValue(DEFAULT_LENGTH)]
    public int LengthInMeters {
        get { return _length; }
        set { _length = value; }
    }
}

vs.

public class Track
{
    public Track()
    {
        LengthInMeters = 400;   
    }

    public int LengthInMeters { get; set; }        
}

Dies funktioniert nur für Anwendungen, die Daten mit dieser bestimmten Klasse erstellen und verarbeiten. Normalerweise ist dies kein Problem, wenn der Datenzugriffscode zentralisiert ist. Um den Wert für alle Anwendungen zu aktualisieren , müssen Sie die Datenquelle so konfigurieren, dass ein Standardwert festgelegt wird. Die Antwort von Devi zeigt, wie dies mithilfe von Migrationen, SQL oder einer anderen Sprache, die Ihre Datenquelle spricht, durchgeführt werden kann.

Calebboyd
quelle
21
Hinweis: Dadurch wird kein Standardwert in der Datenbank festgelegt . Andere Programme, die Ihre Entität nicht verwenden, erhalten diesen Standardwert nicht.
Eric J.
Dieser Teil der Antwort funktioniert jedoch nicht, wenn Sie Datensätze auf andere Weise als über Entity Framework einfügen. Auch wenn Sie eine neue Nicht-Null-Spalte in einer Tabelle erstellen, können Sie den Standardwert für vorhandene Datensätze nicht festlegen. @devi hat eine wertvolle Ergänzung unten.
d512
Warum ist Ihr erster Ansatz der "richtige" Weg? Werden Sie auf unbeabsichtigte Probleme mit dem Konstruktoransatz stoßen?
WiteCastle
eine Ansichtssache, und diese ändern sich :) Und wahrscheinlich nicht.
Calebboyd
2
Unter bestimmten Umständen hatte ich Probleme mit dem Konstruktoransatz. Das Festlegen eines Standardwerts im Hintergrundfeld scheint die am wenigsten invasive Lösung zu sein.
Lucent Fox
11

Was ich getan habe, habe ich Werte im Konstruktor der Entität initialisiert

Hinweis: DefaultValue-Attribute legen die Werte Ihrer Eigenschaften nicht automatisch fest, sondern müssen selbst ausgeführt werden

Sameh Deabes
quelle
4
Das Problem mit dem Konstruktor, der den Wert festlegt, besteht darin, dass EF beim Festschreiben der Transaktion eine Aktualisierung der Datenbank durchführt.
Luka
Das Modell kreta zuerst die Standardwerte auf diese Weise
Lucas
Der DefaultValue ist eine Art, die in weit entfernten, fremden Ländern lebt und zu schüchtern ist, um Ihren Eigenschaften allein zu begegnen. Machen Sie kein Geräusch, es wird leicht verängstigt - sollte es jemals nahe genug kommen, um es zu hören. +1 für die Angabe der überhaupt nicht offensichtlichen.
Risadinha
8

Nach dem Kommentar von @SedatKapanoglu füge ich meinen gesamten Ansatz hinzu, der funktioniert, da er Recht hatte. Nur die Verwendung der fließenden API funktioniert nicht.

1- Erstellen Sie einen benutzerdefinierten Codegenerator und überschreiben Sie Generieren für ein ColumnModel.

   public class ExtendedMigrationCodeGenerator : CSharpMigrationCodeGenerator
{

    protected override void Generate(ColumnModel column, IndentedTextWriter writer, bool emitName = false)
    {

        if (column.Annotations.Keys.Contains("Default"))
        {
            var value = Convert.ChangeType(column.Annotations["Default"].NewValue, column.ClrDefaultValue.GetType());
            column.DefaultValue = value;
        }


        base.Generate(column, writer, emitName);
    }

}

2- Weisen Sie den neuen Codegenerator zu:

public sealed class Configuration : DbMigrationsConfiguration<Data.Context.EfSqlDbContext>
{
    public Configuration()
    {
        CodeGenerator = new ExtendedMigrationCodeGenerator();
        AutomaticMigrationsEnabled = false;
    }
}

3- Verwenden Sie eine fließende API, um die Anmerkung zu erstellen:

public static void Configure(DbModelBuilder builder){    
builder.Entity<Company>().Property(c => c.Status).HasColumnAnnotation("Default", 0);            
}
Denny Puig
quelle
Bitte sehen Sie meine vollständige Lösung, ich habe alle meine Implementierung hinzugefügt, wie es funktioniert, danke.
Denny Puig
5

Es ist einfach! Einfach mit erforderlich kommentieren.

[Required]
public bool MyField { get; set; }

Die resultierende Migration wird sein:

migrationBuilder.AddColumn<bool>(
name: "MyField",
table: "MyTable",
nullable: false,
defaultValue: false);

Wenn Sie true möchten, ändern Sie den Standardwert bei der Migration in true, bevor Sie die Datenbank aktualisieren

Marisol Gutiérrez
quelle
Die automatisch generierte Migration kann dann geändert werden und Sie werden den Standardwert vergessen
Fernando Torres
Einfach und funktionsfähig, hilft das schnelle Hinzufügen einer Spalte zu einer vorhandenen Tabelle mit einer Fremdschlüsseleinschränkung für die neue Spalte. Danke
po10cySA
Und was ist, wenn wir den Standardwert benötigen true?
Christos Lytras
5

Ich gebe zu, dass mein Ansatz dem gesamten "Code First" -Konzept entgeht. Aber wenn Sie die Möglichkeit haben, nur den Standardwert in der Tabelle selbst zu ändern ... ist es viel einfacher als die Längen, die Sie oben durchlaufen müssen ... Ich bin einfach zu faul, um all diese Arbeit zu erledigen!

Es scheint fast so, als würde die ursprüngliche Idee des Plakats funktionieren:

[DefaultValue(true)]
public bool IsAdmin { get; set; }

Ich dachte, sie hätten nur den Fehler gemacht, Zitate hinzuzufügen ... aber leider keine solche Intuitivität. Die anderen Vorschläge waren einfach zu viel für mich (vorausgesetzt, ich habe die erforderlichen Berechtigungen, um in die Tabelle zu gehen und die Änderungen vorzunehmen ... wo nicht jeder Entwickler in jeder Situation wird). Am Ende habe ich es einfach auf die altmodische Weise gemacht. Ich habe den Standardwert in der SQL Server-Tabelle festgelegt ... ich meine wirklich schon genug! HINWEIS: Ich habe die Durchführung einer Add-Migration- und Update-Datenbank weiter getestet und die Änderungen stecken geblieben. Geben Sie hier die Bildbeschreibung ein

Anthony Griggs
quelle
1

Überladen Sie einfach den Standardkonstruktor der Modellklasse und übergeben Sie alle relevanten Parameter, die Sie möglicherweise verwenden oder nicht. Auf diese Weise können Sie problemlos Standardwerte für Attribute angeben. Unten ist ein Beispiel.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Aim.Data.Domain
{
    [MetadataType(typeof(LoginModel))]
    public partial class Login
    {       
        public Login(bool status)
        {
            this.CreatedDate = DateTime.Now;
            this.ModifiedDate = DateTime.Now;
            this.Culture = "EN-US";
            this.IsDefaultPassword = status;
            this.IsActive = status;
            this.LoginLogs = new HashSet<LoginLog>();
            this.LoginLogHistories = new HashSet<LoginLogHistory>();
        }


    }

    public class LoginModel
    {

        [Key]
        [ScaffoldColumn(false)] 
        public int Id { get; set; }
        [Required]
        public string LoginCode { get; set; }
        [Required]
        public string Password { get; set; }
        public string LastPassword { get; set; }     
        public int UserGroupId { get; set; }
        public int FalseAttempt { get; set; }
        public bool IsLocked { get; set; }
        public int CreatedBy { get; set; }       
        public System.DateTime CreatedDate { get; set; }
        public Nullable<int> ModifiedBy { get; set; }      
        public Nullable<System.DateTime> ModifiedDate { get; set; }       
        public string Culture { get; set; }        
        public virtual ICollection<LoginLog> LoginLogs { get; set; }
        public virtual ICollection<LoginLogHistory> LoginLogHistories { get; set; }
    }

}
Bappa Malakar
quelle
Dieser Vorschlag ist vollständig clientseitig. Dies "funktioniert", solange Sie nur mit der Anwendung über die Anwendung mit der Datenbank interagieren. Sobald jemand einen Datensatz manuell oder aus einer anderen Anwendung einfügen möchte, stellen Sie den Nachteil fest, dass das Schema keinen Standardausdruck enthält und dieser nicht auf andere Clients skaliert werden kann. Obwohl dies nicht ausdrücklich angegeben wurde, impliziert dieses legitime Thema die Anforderung, dass EF eine Migration erstellt, die einen Standardausdruck in die Spaltendefinition einfügt.
Tom
0

Nehmen wir an, Sie haben einen Klassennamen mit dem Namen Products und ein IsActive-Feld. Sie benötigen lediglich einen Konstruktor zum Erstellen:

Public class Products
{
    public Products()
    {
       IsActive = true;
    }
 public string Field1 { get; set; }
 public string Field2 { get; set; }
 public bool IsActive { get; set; }
}

Dann ist Ihr IsActive-Standardwert True!

Bearbeiten :

Wenn Sie dies mit SQL tun möchten, verwenden Sie diesen Befehl:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .Property(b => b.IsActive)
        .HasDefaultValueSql("true");
}
Hass.
quelle
Das war einfach nicht die Frage. Es ging um Standardwertbeschränkungen in der Datenbank selbst.
Gábor
4
@Hatef, Ihre Bearbeitung gilt nur für EF Core. Die Frage ist über EF 6.
Michael
3
Diese HasDefaultValueSql ist nicht verfügbar in EF6
tatigo
0

In EF Core, das am 27. Juni 2016 veröffentlicht wurde, können Sie die fließende API zum Festlegen des Standardwerts verwenden. Wechseln Sie zur ApplicationDbContext-Klasse, suchen / erstellen Sie den Methodennamen OnModelCreating und fügen Sie die folgende fließende API hinzu.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<YourTableName>()
        .Property(b => b.Active)
        .HasDefaultValue(true);
}
dE Quelle
quelle
0

In .NET Core 3.1 können Sie in der Modellklasse Folgendes ausführen:

    public bool? Active { get; set; } 

In DbContext OnModelCreating fügen Sie den Standardwert hinzu.

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Foundation>()
            .Property(b => b.Active)
            .HasDefaultValueSql("1");

        base.OnModelCreating(modelBuilder);
    }

Daraus ergibt sich Folgendes in der Datenbank

Geben Sie hier die Bildbeschreibung ein

Hinweis: Wenn Sie für Ihre Eigenschaft keine Nullable (bool?) Haben, wird die folgende Warnung angezeigt

The 'bool' property 'Active' on entity type 'Foundation' is configured with a database-generated default. This default will always be used for inserts when the property has the value 'false', since this is the CLR default for the 'bool' type. Consider using the nullable 'bool?' type instead so that the default will only be used for inserts when the property value is 'null'.
Brüllen Sie Jørstad
quelle
-3

Ich habe festgestellt, dass es ausreicht, nur den Auto-Property Initializer für die Entitätseigenschaft zu verwenden, um die Aufgabe zu erledigen.

Beispielsweise:

public class Thing {
    public bool IsBigThing{ get; set; } = false;
}
Velyo
quelle
2
Sie würden denken, dass dies funktionieren würde, zuerst mit Code. Bei EF 6.2 war das nicht der Fall.
user1040323
-4

Hmm ... ich mache zuerst DB und in diesem Fall ist das tatsächlich viel einfacher. EF6 richtig? Öffnen Sie einfach Ihr Modell, klicken Sie mit der rechten Maustaste auf die Spalte, für die Sie einen Standard festlegen möchten, wählen Sie Eigenschaften aus und Sie sehen ein Feld "DefaultValue". Füllen Sie das einfach aus und speichern Sie es. Es wird den Code für Sie einrichten.

Ihr Kilometerstand kann jedoch je nach Code variieren. Damit habe ich noch nicht gearbeitet.

Das Problem bei vielen anderen Lösungen besteht darin, dass sie zwar anfänglich funktionieren, aber sobald Sie das Modell neu erstellen, den von Ihnen in die maschinengenerierte Datei eingefügten benutzerdefinierten Code ausgeben.

Diese Methode fügt der edmx-Datei eine zusätzliche Eigenschaft hinzu:

<EntityType Name="Thingy">
  <Property Name="Iteration" Type="Int32" Nullable="false" **DefaultValue="1"** />

Und indem Sie dem Konstruktor den erforderlichen Code hinzufügen:

public Thingy()
{
  this.Iteration = 1;
Eichelhund
quelle
-5

Legen Sie den Standardwert für die Spalte in der Tabelle in MSSQL Server und im Klassencode-Attribut add wie folgt fest:

[DatabaseGenerated(DatabaseGeneratedOption.Computed)]

für die gleiche Eigenschaft.

ngochoaitn
quelle