在 System.ComponentModel 默认值属性中将 DateTime 属性的默认值设置为 DateTime.Now

您不能对属性执行此操作，因为它们只是在编译时生成的元信息。如果需要，只需将代码添加到构造函数以初始化日期，创建触发器并处理数据库中的缺失值，或者以返回 DateTime.Now 的方式实现 getter（如果支持字段未初始化）。

public DateTime DateCreated
{
   get
   {
      return this.dateCreated.HasValue
         ? this.dateCreated.Value
         : DateTime.Now;
   }

   set { this.dateCreated = value; }
}

private DateTime? dateCreated = null;

---

在 DateTime 属性中添加以下内容

[DatabaseGenerated(DatabaseGeneratedOption.Computed)]

---

我已经在 EF core 2.1 上测试过了

在这里，您不能使用约定或数据注释。您必须使用 Fluent API。

class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>()
            .Property(b => b.Created)
            .HasDefaultValueSql("getdate()");
    }
}

Official doc

---

我没有理由想出它不应该通过属性来完成。它可能在微软的积压中。谁知道。

我找到的最佳解决方案是在代码先迁移中使用 defaultValueSql 参数。

CreateTable(
    "dbo.SomeTable",
    c => new
        {
            TheDateField = c.DateTime(defaultValueSql: "GETDATE()")
        });

我不喜欢在实体类构造函数中设置它的经常参考解决方案，因为如果实体框架以外的任何东西在该表中粘贴记录，则日期字段将不会获得默认值。使用触发器来处理这种情况的想法对我来说似乎是错误的。

---

这是可能的并且非常简单：

DateTime.MinValue

[System.ComponentModel.DefaultValue(typeof(DateTime), "")]

对于作为 DefaultValueAttribute 的最后一个参数的任何其他值，请指定表示所需 DateTime 值的字符串。

此值必须是常量表达式，并且是使用 TypeConverter 创建对象 (DateTime) 所必需的。

---

刚刚发现这个正在寻找不同的东西，但在新的 C# 版本中，您可以使用更短的版本：

public DateTime DateCreated { get; set; } = DateTime.Now;

---

如果您使用实体框架，一个简单的解决方案是添加一个部分类并为实体定义一个构造函数，因为框架没有定义一个。例如，如果您有一个名为 Example 的实体，您可以将以下代码放在单独的文件中。

namespace EntityExample
{
    public partial class Example : EntityObject
    {
        public Example()
        {
            // Initialize certain default values here.
            this._DateCreated = DateTime.Now;
        }
    }
}

---

我认为最简单的解决方案是设置

Created DATETIME2 NOT NULL DEFAULT GETDATE()

在列声明和 VS2010 EntityModel 设计器中设置相应的列属性 StoreGeneratedPattern = Computed。

---

创建一个新的属性类是一个很好的建议。就我而言，我想指定 'default(DateTime)' 或 'DateTime.MinValue' 以便 Newtonsoft.Json 序列化程序会忽略没有实际值的 DateTime 成员。

[JsonProperty( DefaultValueHandling = DefaultValueHandling.Ignore )]
[DefaultDateTime]
public DateTime EndTime;

public class DefaultDateTimeAttribute : DefaultValueAttribute
{
    public DefaultDateTimeAttribute()
        : base( default( DateTime ) ) { }

    public DefaultDateTimeAttribute( string dateTime )
        : base( DateTime.Parse( dateTime ) ) { }
}

如果没有 DefaultValue 属性，即使设置了 DefaultValueHandling.Ignore 选项，JSON 序列化程序也会输出“1/1/0001 12:00:00 AM”。

---

只需考虑在实体类的构造函数中设置其值

public class Foo
{
       public DateTime DateCreated { get; set; }
       public Foo()
       {
           DateCreated = DateTime.Now;
       }

}

---

使用 System.ComponentModel.DataAnnotations.Schema；

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

---

我需要一个 UTC Timestamp 作为默认值，因此修改了 Daniel 的解决方案，如下所示：

    [Column(TypeName = "datetime2")]
    [XmlAttribute]
    [DisplayFormat(ApplyFormatInEditMode = true, DataFormatString = "{0:yyyy-MM-dd}")]
    [Display(Name = "Date Modified")]
    [DateRange(Min = "1900-01-01", Max = "2999-12-31")]
    public DateTime DateModified {
        get { return dateModified; }
        set { dateModified = value; } 
    }
    private DateTime dateModified = DateTime.Now.ToUniversalTime();

有关 DateRangeAttribute 教程，请参阅 this awesome blog post

---

有一种方法。添加这些类：

DefaultDateTimeValueAttribute.cs

using System;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using Custom.Extensions;

namespace Custom.DefaultValueAttributes
{
    /// <summary>
    /// This class's DefaultValue attribute allows the programmer to use DateTime.Now as a default value for a property.
    /// Inspired from https://code.msdn.microsoft.com/A-flexible-Default-Value-11c2db19. 
    /// </summary>
    [AttributeUsage(AttributeTargets.Property)]
    public sealed class DefaultDateTimeValueAttribute : DefaultValueAttribute
    {
        public string DefaultValue { get; set; }
        private object _value;

        public override object Value
        {
            get
            {
                if (_value == null)
                    return _value = GetDefaultValue();

                return _value;
            }
        }

        /// <summary>
        /// Initialized a new instance of this class using the desired DateTime value. A string is expected, because the value must be generated at runtime.
        /// Example of value to pass: Now. This will return the current date and time as a default value. 
        /// Programmer tip: Even if the parameter is passed to the base class, it is not used at all. The property Value is overridden.
        /// </summary>
        /// <param name="defaultValue">Default value to render from an instance of <see cref="DateTime"/></param>
        public DefaultDateTimeValueAttribute(string defaultValue) : base(defaultValue)
        {
            DefaultValue = defaultValue;
        }

        public static DateTime GetDefaultValue(Type objectType, string propertyName)
        {
            var property = objectType.GetProperty(propertyName);
            var attribute = property.GetCustomAttributes(typeof(DefaultDateTimeValueAttribute), false)
                ?.Cast<DefaultDateTimeValueAttribute>()
                ?.FirstOrDefault();

            return attribute.GetDefaultValue();
        }

        private DateTime GetDefaultValue()
        {
            // Resolve a named property of DateTime, like "Now"
            if (this.IsProperty)
            {
                return GetPropertyValue();
            }

            // Resolve a named extension method of DateTime, like "LastOfMonth"
            if (this.IsExtensionMethod)
            {
                return GetExtensionMethodValue();
            }

            // Parse a relative date
            if (this.IsRelativeValue)
            {
                return GetRelativeValue();
            }

            // Parse an absolute date
            return GetAbsoluteValue();
        }

        private bool IsProperty
            => typeof(DateTime).GetProperties()
                .Select(p => p.Name).Contains(this.DefaultValue);

        private bool IsExtensionMethod
            => typeof(DefaultDateTimeValueAttribute).Assembly
                .GetType(typeof(DefaultDateTimeExtensions).FullName)
                .GetMethods()
                .Where(m => m.IsDefined(typeof(ExtensionAttribute), false))
                .Select(p => p.Name).Contains(this.DefaultValue);

        private bool IsRelativeValue
            => this.DefaultValue.Contains(":");

        private DateTime GetPropertyValue()
        {
            var instance = Activator.CreateInstance<DateTime>();
            var value = (DateTime)instance.GetType()
                .GetProperty(this.DefaultValue)
                .GetValue(instance);

            return value;
        }

        private DateTime GetExtensionMethodValue()
        {
            var instance = Activator.CreateInstance<DateTime>();
            var value = (DateTime)typeof(DefaultDateTimeValueAttribute).Assembly
                .GetType(typeof(DefaultDateTimeExtensions).FullName)
                .GetMethod(this.DefaultValue)
                .Invoke(instance, new object[] { DateTime.Now });

            return value;
        }

        private DateTime GetRelativeValue()
        {
            TimeSpan timeSpan;
            if (!TimeSpan.TryParse(this.DefaultValue, out timeSpan))
            {
                return default(DateTime);
            }

            return DateTime.Now.Add(timeSpan);
        }

        private DateTime GetAbsoluteValue()
        {
            DateTime value;
            if (!DateTime.TryParse(this.DefaultValue, out value))
            {
                return default(DateTime);
            }

            return value;
        }
    }
}

DefaultDateTimeExtensions.cs

using System;

namespace Custom.Extensions
{
    /// <summary>
    /// Inspired from https://code.msdn.microsoft.com/A-flexible-Default-Value-11c2db19. See usage for more information.
    /// </summary>
    public static class DefaultDateTimeExtensions
    {
        public static DateTime FirstOfYear(this DateTime dateTime)
            => new DateTime(dateTime.Year, 1, 1, dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond);

        public static DateTime LastOfYear(this DateTime dateTime)
            => new DateTime(dateTime.Year, 12, 31, dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond);

        public static DateTime FirstOfMonth(this DateTime dateTime)
            => new DateTime(dateTime.Year, dateTime.Month, 1, dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond);

        public static DateTime LastOfMonth(this DateTime dateTime)
            => new DateTime(dateTime.Year, dateTime.Month, DateTime.DaysInMonth(dateTime.Year, dateTime.Month), dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond);
    }
}

并使用 DefaultDateTimeValue 作为属性的属性。输入到验证属性的值类似于“Now”，它将在运行时从使用 Activator 创建的 DateTime 实例呈现。源代码的灵感来自此线程：https://code.msdn.microsoft.com/A-flexible-Default-Value-11c2db19。我对其进行了更改，以使我的类使用 DefaultValueAttribute 而不是 ValidationAttribute 继承。

---

我遇到了同样的问题，但最适合我的问题如下：

public DateTime CreatedOn { get; set; } = DateTime.Now;

---

在 C# 版本 6 中，可以提供默认值

public DateTime fieldname { get; set; } = DateTime.Now;

---

使用 EntityTypeConfiguration，我得到这样的结果：

public class UserMap : IEntityTypeConfiguration<User>
{
    public void Configure(EntityTypeBuilder<User> builder)
    {
        //throw new NotImplementedException();
        builder.Property(u => u.Id).ValueGeneratedOnAdd();
        builder.Property(u => u.Name).IsRequired().HasMaxLength(100);
        builder.HasIndex(u => u.Email).IsUnique();
        builder.Property(u => u.Status).IsRequired();
        builder.Property(u => u.Password).IsRequired();
        builder.Property(u => u.Registration).HasDefaultValueSql("getdate()");

        builder.HasMany(u => u.DrawUser).WithOne(u => u.User);

        builder.ToTable("User");
    }
}

---

public DateTime DateCreated
{
   get
   {
      return (this.dateCreated == default(DateTime))
         ? this.dateCreated = DateTime.Now
         : this.dateCreated;
   }

   set { this.dateCreated = value; }
}
private DateTime dateCreated = default(DateTime);

---

您目前如何处理这取决于您使用的是什么模型 Linq to SQL 或 EntityFramework？

在 L2S 中，您可以添加

public partial class NWDataContext
{
    partial void InsertCategory(Category instance)
    {
        if(Instance.Date == null)
            Instance.Data = DateTime.Now;

        ExecuteDynamicInsert(instance);
    }
}

EF 稍微复杂一些，有关 EF 业务逻辑的更多信息，请参阅 http://msdn.microsoft.com/en-us/library/cc716714.aspx。

---

我知道这篇文章有点旧，但有一个建议可能会对一些人有所帮助。

我使用 Enum 来确定在属性构造函数中设置什么。

财产声明：

[DbProperty(initialValue: EInitialValue.DateTime_Now)]
public DateTime CreationDate { get; set; }

属性构造函数：

Public Class DbProperty Inherits System.Attribute

    Public Property InitialValue As Object

    Public Sub New(ByVal initialValue As EInitialValue)
       Select Case initialValue
          Case EInitialValue.DateTime_Now
             Me.InitialValue = System.DateTime.Now

          Case EInitialValue.DateTime_Min
             Me.InitialValue = System.DateTime.MinValue

          Case EInitialValue.DateTime_Max
             Me.InitialValue = System.DateTime.MaxValue

       End Select

    End Sub
End Class

枚举：

Public Enum EInitialValue
   DateTime_Now
   DateTime_Min
   DateTime_Max
End Enum

---

我认为您可以使用 StoreGeneratedPattern = Identity（在模型设计器属性窗口中设置）来执行此操作。

我不会猜到该怎么做，但是在试图弄清楚时，我注意到我的一些日期列已经默认为 CURRENT_TIMESTAMP() 而有些则不是。检查模型，我发现除了名称之外，两列之间的唯一区别是获得默认值的那一列将 StoreGeneratedPattern 设置为 Identity。

我没想到会这样，但阅读描述，这有点道理：

确定在插入和更新操作期间是否将自动生成数据库中的相应列。

此外，虽然这确实使数据库列具有“现在”的默认值，但我猜它实际上并没有在 POCO 中将属性设置为 DateTime.Now。这对我来说不是问题，因为我有一个自定义的 .tt 文件，它已经自动将我的所有日期列设置为 DateTime.Now （实际上自己修改 .tt 文件并不难，特别是如果你有 ReSharper 并获得语法高亮插件。（较新版本的 VS 可能已经语法高亮 .tt 文件，不确定。））

对我来说问题是：如何让数据库列具有默认值，以便省略该列的现有查询仍然有效？上述设置适用于此。

我尚未对其进行测试，但设置它也可能会干扰设置您自己的显式值。 （我最初只是偶然发现了这一点，因为 EF6 Database First 以这种方式为我编写了模型。）

---

以下适用于 .NET 5.0

        private DateTime _DateCreated= DateTime.Now;
        public DateTime DateCreated
        {
            get
            {
                return this._DateCreated;
            }

            set { this._DateCreated = value; }
        }

---

您还可以考虑使用 DatabaseGenerated 属性，例如

[DatabaseGenerated(DatabaseGeneratedOption.Identity)]
public DateTime DateCreated { get; set; }

https://docs.microsoft.com/en-us/ef/core/modeling/generated-properties?tabs=data-annotations

---

使用 Fluent API，在 Context 类的 OnModelCreating 函数中添加以下内容。

 builder.Property(u => u.CreatedAt).ValueGeneratedOnAdd();
 builder.Property(u => u.UpdatedAt).ValueGeneratedOnAddOrUpdate();

注意我使用的是单独的类型配置类。如果你在函数中做得对，就像：

builder.Enitity<User>().Property(u => u.CreatedAt).ValueGeneratedOnAdd();

---

我也想要这个并想出了这个解决方案（我只使用日期部分 - 默认时间作为 PropertyGrid 默认值没有意义）：

public class DefaultDateAttribute : DefaultValueAttribute {
  public DefaultDateAttribute(short yearoffset)
    : base(DateTime.Now.AddYears(yearoffset).Date) {
  }
}

这只会创建一个新属性，您可以将其添加到 DateTime 属性中。例如，如果它默认为 DateTime.Now.Date：

[DefaultDate(0)]

---