Question

我已将[Required]数据注释添加到ASP.NET MVC application中的某个模型中。创建迁移后，运行Update-Database命令会导致以下错误：

无法将值NULL插入“Director”表中 'MOVIES_cf7bad808fa94f89afa2e5dae1161e78.dbo.Movies';专栏没有允许空值。更新失败。声明已经终止。

这是由于某些记录在Director列中有NULL。如何自动将这些值更改为某些默认值（比如“John Doe”）导演？

这是我的模特：

  public class Movie
    {
        public int ID { get; set; }
        [Required]
        public string Title { get; set; }

        [DataType(DataType.Date)]
        public DateTime ReleaseDate { get; set; }

        [Required]
        public string Genre { get; set; }

        [Range(1,100)]
        [DataType(DataType.Currency)]
        public decimal Price { get; set; }

        [StringLength(5)]
        public string Rating { get; set; }

        [Required]     /// <--- NEW
        public string Director { get; set; }
    }

这是我最近的迁移：

public partial class AddDataAnnotationsMig : DbMigration
{
    public override void Up()
    {
        AlterColumn("dbo.Movies", "Title", c => c.String(nullable: false));
        AlterColumn("dbo.Movies", "Genre", c => c.String(nullable: false));
        AlterColumn("dbo.Movies", "Rating", c => c.String(maxLength: 5));
        AlterColumn("dbo.Movies", "Director", c => c.String(nullable: false));
    }

    public override void Down()
    {
        AlterColumn("dbo.Movies", "Director", c => c.String());
        AlterColumn("dbo.Movies", "Rating", c => c.String());
        AlterColumn("dbo.Movies", "Genre", c => c.String());
        AlterColumn("dbo.Movies", "Title", c => c.String());
    }
}

Answer 1

除了@webdeveloper和@Pushpendra的答案之外，您还需要手动向迁移添加更新以更新现有行。例如：

public override void Up()
{
    Sql("UPDATE [dbo].[Movies] SET Title = 'No Title' WHERE Title IS NULL");
    AlterColumn("dbo.Movies", "Title", c => c.String(nullable: false,defaultValue:"MyTitle"));
}

这是因为AlterColumn生成DDL以将列的默认值设置为表规范中的某个特定值。 DDL不会影响数据库中的现有行。

你实际上是在同一时间进行了两次更改（设置默认值并使列为NOT NULL），并且每个更改都是单独有效的，但由于你是同时进行两次更改，你可以期待系统“智能地”实现您的意图并将所有NULL值设置为默认值，但这不是所期望的。

假设您只设置列的默认值，而不是使其为NOT NULL。您显然不希望使用您提供的默认值更新所有NULL记录。

因此，在我看来，这不是一个错误，我不希望EF以我没有明确告诉它的方式更新我的数据。开发人员负责指示系统如何处理数据。

Answer 2

如果我没记错的话，这样的事情应该有效：

AlterColumn("dbo.Movies", "Director", c => c.String(nullable: false, defaultValueSql: "John Doe"));

Answer 3

public partial class AddDataAnnotationsMig : DbMigration
{
    public override void Up()
    {
        AlterColumn("dbo.Movies", "Title", c => c.String(nullable: false,defaultValue:"MyTitle"));
        AlterColumn("dbo.Movies", "Genre", c => c.String(nullable: false,defaultValue:"Genre"));
        AlterColumn("dbo.Movies", "Rating", c => c.String(maxLength: 5));
        AlterColumn("dbo.Movies", "Director", c => c.String(nullable: false,defaultValue:"Director"));

    }

    public override void Down()
    {       
        AlterColumn("dbo.Movies", "Director", c => c.String());
        AlterColumn("dbo.Movies", "Rating", c => c.String());
        AlterColumn("dbo.Movies", "Genre", c => c.String());
        AlterColumn("dbo.Movies", "Title", c => c.String());       
    }
}

Answer 4

不确定此选项是否始终存在，但只是遇到了类似的问题，发现我能够设置默认值而不使用以下任何手动更新

defaultValueSql: "'NY'"

当提供的值为"NY"时，我收到错误，然后我意识到他们期望像"GETDATE()"这样的SQL值，所以我尝试了"'NY'"，这就是诀窍

整行看起来像这样

AddColumn("TABLE_NAME", "State", c => c.String(maxLength: 2, nullable: false, defaultValueSql: "'NY'"));

感谢this answer，让我走上正轨

Answer 5

我发现只在实体属性上使用Auto-Property Initializer就足以完成工作。

例如：

public class Thing {
    public bool IsBigThing { get; set; } = false;
}

Answer 6

出于某种原因，我无法解释自己批准的答案对我来说不再适用。

它适用于另一个应用程序，就我正在工作的应用程序而言。

因此，另一种方法是非常低效，解决方法是覆盖SaveChanges（）方法，如下所示。此方法应该在Context类上。

    public override int SaveChanges()
    {
        foreach (var entry in ChangeTracker.Entries().Where(entry => entry.Entity.GetType().GetProperty("ColumnName") != null))
        {
            if (entry.State == EntityState.Added)
            {
                entry.Property("ColumnName").CurrentValue = "DefaultValue";
            }
        }

Answer 7

许多其他答复集中在发生这些问题时如何进行手动干预。

生成迁移后，对迁移执行以下任一更改：



修改列定义以包含defaultValue或defaultSql语句：
  AlterColumn("dbo.Movies", "Director", c => c.String(nullable: false, default: ""));



在AlterColumn之前插入一条SQL语句以预填充现有列：
  Sql("UPDATE dbo.Movies SET Director = '' WHERE Director IS NULL");

请记住，如果重新设置迁移支架，则应用于迁移脚本的手动更改将被覆盖。对于第一种解决方案，很容易扩展EF以在迁移生成过程中自动在字段上定义默认值。

注意：EF不会自动为您执行此操作，因为每个RDBMS提供程序的默认值实现会有所不同，而且因为在纯EF运行时中默认值的意义较小，因为每个行插入都将为每个属性，即使它为null，也不会评估默认值约束。
该AlterColumn语句是默认约束唯一起作用的时间，我想这对于设计SQL Server迁移实现的团队来说将成为较低的优先级。

以下解决方案结合了属性符号，模型配置约定和列注释，以将元数据传递到自定义的迁移代码生成器。如果不使用属性表示法，则可以对每个受影响的字段使用流利的表示法替换步骤1和2。
这里有很多技巧，可以随意使用其中的一些或全部，我希望这里的每个人都有价值

声明默认值
创建或重新定义现有属性以定义要使用的默认值，在本示例中，我们将创建一个新的名为DefaultValue的属性，该属性继承自ComponentModel.DefaultValueAttribute，因为用法很直观，并且现有代码库可能已经实现此属性。通过此实现，您只需使用此特定属性即可访问DefaultValueSql，该属性对日期和其他自定义方案很有用。

实施

[DefaultValue("Insert DefaultValue Here")]
[Required]     /// <--- NEW
public string Director { get; set; }

// Example of default value sql
[DefaultValue(DefaultValueSql: "GetDate()")]
[Required]
public string LastModified { get; set; }

属性定义

namespace EFExtensions
{
    /// <summary>
    /// Specifies the default value for a property but allows a custom SQL statement to be provided as well. <see cref="MiniTuber.Database.Conventions.DefaultValueConvention"/>
    /// </summary>
    public class DefaultValueAttribute : System.ComponentModel.DefaultValueAttribute
    {
        /// <summary>
        /// Specifies the default value for a property but allows a custom SQL statement to be provided as well. <see cref="MiniTuber.Database.Conventions.DefaultValueConvention"/>
        /// </summary>
        public DefaultValueAttribute() : base("")
        {
        }

        /// <i
        /// <summary>
        /// Optional SQL to use to specify the default value.
        /// </summary>
        public string DefaultSql { get; set; }

        /// <summary>
        /// Initializes a new instance of the System.ComponentModel.DefaultValueAttribute
        /// class using a Unicode character.
        /// </summary>
        /// <param name="value">
        /// A Unicode character that is the default value.
        /// </param>
        public DefaultValueAttribute(char value) : base(value) { }

        /// <summary>
        /// Initializes a new instance of the System.ComponentModel.DefaultValueAttribute
        /// class using an 8-bit unsigned integer.
        /// </summary>
        /// <param name="value">
        /// An 8-bit unsigned integer that is the default value.
        /// </param>
        public DefaultValueAttribute(byte value) : base(value) { }

        /// <summary>
        /// Initializes a new instance of the System.ComponentModel.DefaultValueAttribute
        /// class using a 16-bit signed integer.
        /// </summary>
        /// <param name="value">
        /// A 16-bit signed integer that is the default value.
        /// </param>
        public DefaultValueAttribute(short value) : base(value) { }

        /// <summary>
        /// Initializes a new instance of the System.ComponentModel.DefaultValueAttribute
        /// class using a 32-bit signed integer.
        /// </summary>
        /// <param name="value">
        /// A 32-bit signed integer that is the default value.
        /// </param>
        public DefaultValueAttribute(int value) : base(value) { }

        /// <summary>
        /// Initializes a new instance of the System.ComponentModel.DefaultValueAttribute
        /// class using a 64-bit signed integer.
        /// </summary>
        /// <param name="value">
        /// A 64-bit signed integer that is the default value.
        /// </param>
        public DefaultValueAttribute(long value) : base(value) { }

        /// <summary>
        /// Initializes a new instance of the System.ComponentModel.DefaultValueAttribute
        /// class using a single-precision floating point number.
        /// </summary>
        /// <param name="value">
        /// A single-precision floating point number that is the default value.
        /// </param>
        public DefaultValueAttribute(float value) : base(value) { }

        /// <summary>
        /// Initializes a new instance of the System.ComponentModel.DefaultValueAttribute
        /// class using a double-precision floating point number.
        /// </summary>
        /// <param name="value">
        /// A double-precision floating point number that is the default value.
        /// </param>
        public DefaultValueAttribute(double value) : base(value) { }

        /// <summary>
        /// Initializes a new instance of the System.ComponentModel.DefaultValueAttribute
        /// class using a System.Boolean value.
        /// </summary>
        /// <param name="value">
        /// A System.Boolean that is the default value.
        /// </param>
        public DefaultValueAttribute(bool value) : base(value) { }

        /// <summary>
        /// Initializes a new instance of the System.ComponentModel.DefaultValueAttribute
        /// class using a System.String.
        /// </summary>
        /// <param name="value">
        /// A System.String that is the default value.
        /// </param>
        public DefaultValueAttribute(string value) : base(value) { }

        /// <summary>
        /// Initializes a new instance of the System.ComponentModel.DefaultValueAttribute
        /// class.
        /// </summary>
        /// <param name="value">
        /// An System.Object that represents the default value.
        /// </param>
        public DefaultValueAttribute(object value) : base(value) { }

        /// /// <inheritdoc/>
        /// Initializes a new instance of the System.ComponentModel.DefaultValueAttribute
        /// class, converting the specified value to the specified type, and using an invariant
        /// culture as the translation context.
        /// </summary>
        /// <param name="type">
        /// A System.Type that represents the type to convert the value to.
        /// </param>
        /// <param name="value">
        /// A System.String that can be converted to the type using the System.ComponentModel.TypeConverter
        /// for the type and the U.S. English culture.
        /// </param>
        public DefaultValueAttribute(Type type, string value) : base(value) { }
    }
}

创建约定以将默认值注入列批注
列批注用于将有关列的自定义元数据传递到迁移脚本生成器。
使用约定来执行此操作演示了属性符号背后的强大功能，该属性符号简化了如何为许多属性定义和操作流利的元数据，而不是为每个字段单独指定它。

namespace EFExtensions
{

    /// <summary>
    /// Implement SQL Default Values from System.ComponentModel.DefaultValueAttribute
    /// </summary>
    public class DefaultValueConvention : Convention
    {
        /// <summary>
        /// Annotation Key to use for Default Values specified directly as an object
        /// </summary>
        public const string DirectValueAnnotationKey = "DefaultValue";
        /// <summary>
        /// Annotation Key to use for Default Values specified as SQL Strings
        /// </summary>
        public const string SqlValueAnnotationKey = "DefaultSql";

        /// <summary>
        /// Implement SQL Default Values from System.ComponentModel.DefaultValueAttribute
        /// </summary>
        public DefaultValueConvention()
        {
            // Implement SO Default Value Attributes first
            this.Properties()
                    .Where(x => x.HasAttribute<EFExtensions.DefaultValueAttribute>())
                    .Configure(c => c.HasColumnAnnotation(
                        c.GetAttribute<EFExtensions.DefaultValueAttribute>().GetDefaultValueAttributeKey(),
                        c.GetAttribute<EFExtensions.DefaultValueAttribute>().GetDefaultValueAttributeValue()
                        ));

            // Implement Component Model Default Value Attributes, but only if it is not the SO implementation
            this.Properties()
                    .Where(x => x.HasAttribute<System.ComponentModel.DefaultValueAttribute>())
                    .Where(x => !x.HasAttribute<MiniTuber.DataAnnotations.DefaultValueAttribute>())
                    .Configure(c => c.HasColumnAnnotation(
                        DefaultValueConvention.DirectValueAnnotationKey, 
                        c.GetAttribute<System.ComponentModel.DefaultValueAttribute>().Value
                        ));
        }
    }

    /// <summary>
    /// Extension Methods to simplify the logic for building column annotations for Default Value processing
    /// </summary>
    public static partial class PropertyInfoAttributeExtensions
    {
        /// <summary>
        /// Wrapper to simplify the lookup for a specific attribute on a property info.
        /// </summary>
        /// <typeparam name="T">Type of attribute to lookup</typeparam>
        /// <param name="self">PropertyInfo to inspect</param>
        /// <returns>True if an attribute of the requested type exists</returns>
        public static bool HasAttribute<T>(this PropertyInfo self) where T : Attribute
        {
            return self.GetCustomAttributes(false).OfType<T>().Any();
        }

        /// <summary>
        /// Wrapper to return the first attribute of the specified type
        /// </summary>
        /// <typeparam name="T">Type of attribute to return</typeparam>
        /// <param name="self">PropertyInfo to inspect</param>
        /// <returns>First attribuite that matches the requested type</returns>
        public static T GetAttribute<T>(this System.Data.Entity.ModelConfiguration.Configuration.ConventionPrimitivePropertyConfiguration self) where T : Attribute
        {
            return self.ClrPropertyInfo.GetCustomAttributes(false).OfType<T>().First();
        }

        /// <summary>
        /// Helper to select the correct DefaultValue annotation key based on the attribute values
        /// </summary>
        /// <param name="self"></param>
        /// <returns></returns>
        public static string GetDefaultValueAttributeKey(this EFExtensions.DefaultValueAttribute self)
        {
            return String.IsNullOrWhiteSpace(self.DefaultSql) ? DefaultValueConvention.DirectValueAnnotationKey : DefaultValueConvention.SqlValueAnnotationKey;
        }

        /// <summary>
        /// Helper to select the correct attribute property to send as a DefaultValue annotation value
        /// </summary>
        /// <param name="self"></param>
        /// <returns></returns>
        public static object GetDefaultValueAttributeValue(this EFExtensions.DefaultValueAttribute self)
        {
            return String.IsNullOrWhiteSpace(self.DefaultSql) ? self.Value : self.DefaultSql;
        }
    }

}

将约定添加到DbContext
实现此目的的方法有很多，我想将约定声明为ModelCreation逻辑中的第一个自定义步骤，这将在您的DbContext类中。

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    base.OnModelCreating(modelBuilder);
    // Use our new DefaultValueConvention
    modelBuilder.Conventions.Add<EFExtensions.DefaultValueConvention>();

    // My personal favourites ;)
    modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
    modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();

}

覆盖MigrationCodeGenerator
现在，这些注释已应用于模型中的列定义，我们需要修改迁移脚本生成器以使用这些注释。为此，我们将从System.Data.Entity.Migrations.Design.CSharpMigrationCodeGenerator继承，因为我们只需要注入最小的更改。
处理完自定义注释后，需要将其从列定义中删除，以防止将其序列化为最终输出。

请参阅基类代码以探索其他用法：http://entityframework.codeplex.com/sourcecontrol/latest#src/EntityFramework/Migrations/Design/CSharpMigrationCodeGenerator.cs

namespace EFExtensions
{
    /// <summary>
    /// Implement DefaultValue constraint definition in Migration Scripts.
    /// </summary>
    /// <remarks>
    /// Original guide that provided inspiration for this https://romiller.com/2012/11/30/code-first-migrations-customizing-scaffolded-code/
    /// </remarks>
    public class CustomCodeGenerator : System.Data.Entity.Migrations.Design.CSharpMigrationCodeGenerator
    {
        /// <summary>
        /// Inject Default values from the DefaultValue attribute, if the DefaultValueConvention has been enabled.
        /// </summary>
        /// <seealso cref="DefaultValueConvention"/>
        /// <param name="column"></param>
        /// <param name="writer"></param>
        /// <param name="emitName"></param>
        protected override void Generate(ColumnModel column, IndentedTextWriter writer, bool emitName = false)
        {
            var annotations = column.Annotations?.ToList();
            if (annotations != null && annotations.Any())
            {
                for (int index = 0; index < annotations.Count; index ++)
                {
                    var annotation = annotations[index];
                    bool handled = true;

                    try
                    {
                        switch (annotation.Key)
                        {
                            case DefaultValueConvention.SqlValueAnnotationKey:
                                if (annotation.Value?.NewValue != null)
                                {
                                    column.DefaultValueSql = $"{annotation.Value.NewValue}";
                                }
                                break;
                            case DefaultValueConvention.DirectValueAnnotationKey:
                                if (annotation.Value?.NewValue != null)
                                {
                                    column.DefaultValue = Convert.ChangeType(annotation.Value.NewValue, column.ClrType);
                                }
                                break;
                            default:
                                handled = false;
                                break;
                        }
                    }
                    catch(Exception ex)
                    {
                        // re-throw with specific debug information
                        throw new ApplicationException($"Failed to Implement Column Annotation for column: {column.Name} with key: {annotation.Key} and new value: {annotation.Value.NewValue}", ex);
                    }

                    if(handled)
                    {
                        // remove the annotation, it has been applied
                        column.Annotations.Remove(annotation.Key);
                    }
                }
            }
            base.Generate(column, writer, emitName);
        }

        /// <summary>
        /// Generates class summary comments and default attributes
        /// </summary>
        /// <param name="writer"> Text writer to add the generated code to. </param>
        /// <param name="designer"> A value indicating if this class is being generated for a code-behind file. </param>
        protected override void WriteClassAttributes(IndentedTextWriter writer, bool designer)
        {
            writer.WriteLine("/// <summary>");
            writer.WriteLine("/// Definition of the Migration: {0}", this.ClassName);
            writer.WriteLine("/// </summary>");
            writer.WriteLine("/// <remarks>");
            writer.WriteLine("/// Generated Time: {0}", DateTime.Now);
            writer.WriteLine("/// Generated By: {0}", Environment.UserName);
            writer.WriteLine("/// </remarks>");
            base.WriteClassAttributes(writer, designer);
        }


    }
}

注册CustomCodeGenerator
第一步，在DbMigration配置文件中，我们需要指定要使用的代码生成器，默认情况下，在“迁移”文件夹中查找Configuration.cs ...

internal sealed class Configuration : DbMigrationsConfiguration<YourApplication.Database.Context>
{
    public Configuration()
    {
        // I recommend that auto-migrations be disabled so that we control
        // the migrations explicitly 
        AutomaticMigrationsEnabled = false;
        CodeGenerator = new EFExtensions.CustomCodeGenerator();
    }

    protected override void Seed(YourApplication.Database.Context context)
    {
        //   Your custom seed logic here
    }
}

Entity Framework迁移中必填字段的默认值？

7 个答案: