如何仅在DateTime对象中删除C＃中的日期时间部分？


How to remove time portion of date in C# in DateTime object only?

我需要删除日期时间的时间部分，或者可能将日期的格式设置为以下object格式，而不是string格式。

1
06/26/2009 00:00:00:000

我不能使用任何string转换方法，因为我需要object格式的日期。

我首先尝试将DateTime转换成string，从中删除特定时间的日期，但当我再次将其转换回DateTimeobject时，它会添加12:00:00 AM。

相关讨论

使用日期属性：

1
2
var dateAndTime = DateTime.Now;
var date = dateAndTime.Date;

date变量将包含日期，时间部分将为00:00:00。

相关讨论

您可以使用格式字符串为输出字符串指定您喜欢的格式。

1
2
DateTime dateAndTime = DateTime.Now;
Console.WriteLine(dateAndTime.ToString("dd/MM/yyyy")); // Will give you smth like 25/05/2011

在这里阅读更多。

相关讨论

使用toshortdatestring方法。请参阅文档http://msdn.microsoft.com/en-us/library/system.datetime.toshortdatestring.aspx

1
2
var dateTimeNow = DateTime.Now; // Return 00/00/0000 00:00:00
var dateOnlyString = dateTimeNow.ToShortDateString(); //Return 00/00/0000

查看datetime.date属性。

Gets the date component of this instance.

相关讨论

date房地产将于午夜归还日期。

一个选项是单独获取各个值(日/月/年)，并将其存储在所需类型中。

1
2
3
4
5
6
var dateAndTime = DateTime.Now;
int year = dateAndTime.Year;
int month = dateAndTime.Month;
int day = dateAndTime.Day;

string.Format("{0}/{1}/{2}", month, day, year);

以上答案都没有解决我在WinForms上的问题。

最简单的方法是获取日期时间中的简单函数：

1
2
DateTime dt = DateTime.now;
String BirthDate = dt.ToShortDateString();

您的生日字符串中只有日期。

相关讨论

不能。在.NET中的日期时间总是有时间的，默认为00:00:00:000。日期时间的日期属性也是日期时间！！)因此时间也默认为00:00:00:000。

这是.NET框架中的一个缺陷，可以说.NET中的日期时间违反了单一责任原则。

相关讨论

试着做你自己的结构。日期时间对象将同时具有日期和时间

相关讨论

日期时间

相关讨论

这里是另一个方法采用String.Format ＜／P >

1
2
3
4
5
6
7
    DateTime todaysDate = DateTime.UtcNow;

    string dateString = String.Format("{0:dd/MM/yyyy}", todaysDate);

    Console.WriteLine("Date with Time:"+ todaysDate.ToString());

    Console.WriteLine("Date Only :" + dateString);

输出： ＜／P >

1
2
3
Date with Time: 9/4/2016 11:42:16 AM

Date Only : 04/09/2016

本厂也，如果约会时是可存储在数据库中。 ＜／P >

用更多的日期和时间的Formatting检查这些链接： ＜／P >

参考1 ＜／P >

参考2 ＜／P >

希望helps。。。。。。。 ＜／P >

相关讨论

这种只约会而不花时间的方式

1
2
DateTime date = DateTime.Now;
string Strdateonly = date.ToString("d");

产量=5/16/2015

相关讨论

第一封DateOnly结构。这可以用于DateTime下皮肤不接触件时是publically： ＜／P >

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
using System;

public struct DateOnly : IComparable, IFormattable, IComparable<DateOnly>, IEquatable<DateOnly>
{

    private DateTime _dateValue;

    public int CompareTo(object obj)
    {
        if (obj == null)
        {
            return 1;
        }

        DateOnly otherDateOnly = (DateOnly)obj;
        if (otherDateOnly != null)
        {
            return ToDateTime().CompareTo(otherDateOnly.ToDateTime());
        }
        else
        {
            throw new ArgumentException("Object is not a DateOnly");
        }
    }

    int IComparable<DateOnly>.CompareTo(DateOnly other)
    {
        return this.CompareToOfT(other);
    }
    public int CompareToOfT(DateOnly other)
    {
        // If other is not a valid object reference, this instance is greater.
        if (other == new DateOnly())
        {
            return 1;
        }
        return this.ToDateTime().CompareTo(other.ToDateTime());
    }

    bool IEquatable<DateOnly>.Equals(DateOnly other)
    {
        return this.EqualsOfT(other);
    }
    public bool EqualsOfT(DateOnly other)
    {
        if (other == new DateOnly())
        {
            return false;
        }

        if (this.Year == other.Year && this.Month == other.Month && this.Day == other.Day)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public static DateOnly Now()
    {
        return new DateOnly(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day);
    }

    public static bool TryParse(string s, ref DateOnly result)
    {
        DateTime dateValue = default(DateTime);
        if (DateTime.TryParse(s, out dateValue))
        {
            result = new DateOnly(dateValue.Year, dateValue.Month, dateValue.Day);
            return true;
        }
        else
        {
            return false;
        }
    }

    public static DateOnly Parse(string s)
    {
        DateTime dateValue = default(DateTime);
        dateValue = DateTime.Parse(s);
        return new DateOnly(dateValue.Year, dateValue.Month, dateValue.Day);
    }

    public static DateOnly ParseExact(string s, string format)
    {
        CultureInfo provider = CultureInfo.InvariantCulture;
        DateTime dateValue = default(DateTime);
        dateValue = DateTime.ParseExact(s, format, provider);
        return new DateOnly(dateValue.Year, dateValue.Month, dateValue.Day);
    }

    public DateOnly(int yearValue, int monthValue, int dayValue) : this()
    {
        Year = yearValue;
        Month = monthValue;
        Day = dayValue;
    }

    public DateOnly AddDays(double value)
    {
        DateTime d = new DateTime(this.Year, this.Month, this.Day);
        d = d.AddDays(value);
        return new DateOnly(d.Year, d.Month, d.Day);
    }

    public DateOnly AddMonths(int months)
    {
        DateTime d = new DateTime(this.Year, this.Month, this.Day);
        d = d.AddMonths(months);
        return new DateOnly(d.Year, d.Month, d.Day);
    }

    public DateOnly AddYears(int years)
    {
        DateTime d = new DateTime(this.Year, this.Month, this.Day);
        d = d.AddYears(years);
        return new DateOnly(d.Year, d.Month, d.Day);
    }

    public DayOfWeek DayOfWeek
    {
        get
        {
            return _dateValue.DayOfWeek;
        }
    }

    public DateTime ToDateTime()
    {
        return _dateValue;
    }

    public int Year
    {
        get
        {
            return _dateValue.Year;
        }
        set
        {
            _dateValue = new DateTime(value, Month, Day);
        }
    }

    public int Month
    {
        get
        {
            return _dateValue.Month;
        }
        set
        {
            _dateValue = new DateTime(Year, value, Day);
        }
    }

    public int Day
    {
        get
        {
            return _dateValue.Day;
        }
        set
        {
            _dateValue = new DateTime(Year, Month, value);
        }
    }

    public static bool operator == (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() == aDateOnly2.ToDateTime());
    }

    public static bool operator != (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() != aDateOnly2.ToDateTime());
    }

    public static bool operator > (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() > aDateOnly2.ToDateTime());
    }

    public static bool operator < (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() < aDateOnly2.ToDateTime());
    }

    public static bool operator >= (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() >= aDateOnly2.ToDateTime());
    }

    public static bool operator <= (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() <= aDateOnly2.ToDateTime());
    }

    public static TimeSpan operator - (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() - aDateOnly2.ToDateTime());
    }


    public override string ToString()
    {
        return _dateValue.ToShortDateString();
    }

    public string ToString(string format)
    {
        return _dateValue.ToString(format);
    }

    public string ToString(string fmt, IFormatProvider provider)
    {
        return string.Format("{0:" + fmt +"}", _dateValue);
    }

    public string ToShortDateString()
    {
        return _dateValue.ToShortDateString();
    }

    public string ToDbFormat()
    {
        return string.Format("{0:yyyy-MM-dd}", _dateValue);
    }
}

这是换算为VB.NET，SO apologies if some conversions都没有100% ＜／P >

我很惊讶没有人提到日期时间。今天

1
2
var date = DateTime.Today;
// {7/1/2014 12:00:00 AM}

参见MSDN

相关讨论

使用date.toshortdatestring to get()的日期无时组分 ＜／P >

1
2
var date = DateTime.Now
var shortDate = date.ToShortDateString() //will give you 16/01/2019

使用date.tostring(OP)的自定义格式的日期 ＜／P >

1
2
var date = DateTime.Now
var shortDate = date.ToString('dd-MMM-yyyy') //will give you 16-Jan-2019

使用

1
DateTime.Now.ToString("dd-MM-yyyy");

在试图解决原始问题时遇到了这个帖子。

我正在使用ASP.NET，经过一些研究，我发现当您绑定到代码隐藏中日期的值时，您可以减少时间，这样它就不会显示在屏幕上。

C：

1
DateTime Today = DateTime.Now;

ASPX：

1
<%: this.Today.ToShortDateString() %>

您可以在datetime中的唯一日期尝试此操作

1
String.Format("{0:d/M/YYYY}",dt);

其中dt为DateTime。

1
2
3
string dt = myCalender.SelectedDate.ToString();
string date = dt.Remove(10);
displayDate.Content = date;

如果你从日历上记下日期，我们也有时间。这不是所有时间都需要的。利用这个，我们可以从日期中删除时间。

我知道这是一篇有很多答案的老文章，但我没有看到这种删除时间部分的方法。假设您有一个名为myDate的DateTime变量，日期和时间部分。您可以使用此构造函数从中创建一个新的DateTime对象，而不需要时间部分：

1
public DateTime(int year, int month, int day);

这样地：

1
myDate = new DateTime(myDate.Year, myDate.Month, myDate.Day);

这样，您就可以基于旧对象创建一个新的DateTime对象，其中00:00:00是时间部分。

将变量声明为字符串。

例子：

1
public string dateOfBirth ;

然后指定如下值：

1
dateOfBirth = ((DateTime)(datetimevaluefromDB)).ToShortDateString();
相关讨论

如果要将其转换为字符串，可以这样轻松地进行转换。

我将日期作为日期时间对象。

1
date.ToString("d");

这只会给你日期。

根据我的经验，上述解决方案都不起作用，可能是因为我想从数据库中删除提取日期的时间，但下面的代码工作得很好：

1
var date = target_date.Value.ToString("dd/MM/yyyy");
相关讨论

创建只包含所需属性的结构。然后是一个扩展方法，可以轻松地从datetime实例中获取该结构。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public struct DateOnly
{
    public int Day { get; set; }
    public int Month { get; set; }
    public int Year { get; set; }
}

public static class DateOnlyExtensions
{
    public static DateOnly GetDateOnly(this DateTime dt)
    {
        return new DateOnly
        {
            Day = dt.Day,
            Month = dt.Month,
            Year = dt.Year
        };
    }
}

用法

1
2
DateTime dt = DateTime.Now;
DateOnly result = dt.GetDateOnly();

日期时间对象的日期将忽略时间部分。

下面是代码：

1
2
3
4
5
6
7
DateTime dateA = DateTime.Now;
DateTime dateB = DateTime.Now.AddHours(1).AddMinutes(10).AddSeconds(14);
Console.WriteLine("Date A: {0}",dateA.ToString("o"));
Console.WriteLine("Date B: {0}", dateB.ToString("o"));
Console.WriteLine(String.Format("Comparing objects A==B? {0}", dateA.Equals(dateB)));
Console.WriteLine(String.Format("Comparing ONLY Date property A==B? {0}", dateA.Date.Equals(dateB.Date)));
Console.ReadLine();

输出：

1
2
3
4
>Date A: 2014-09-04T07:53:14.6404013+02:00
>Date B: 2014-09-04T09:03:28.6414014+02:00
>Comparing objects A==B? False
>Comparing ONLY Date property A==B? True

供数据列表、转发器使用。在ASPX页中：<%eval("YourdateString").ToString()。删除(10)%>

1
2
3
4
5
6
7
8
9
10
11
static void Main(string[] args)
{
    string dateStrings = "2014-09-01T03:00:00+00:00" ;

    DateTime convertedDate = DateTime.Parse(dateStrings);
    Console.WriteLine("  {0} ----------------- {1}",

    convertedDate,DateTime.Parse(convertedDate.ToString()).ToString("dd/MM/yyyy"));

    Console.Read();
}

这可以简单地通过以下方式实现：

1
var dateOnly = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day)

此代码使您清楚地了解如何分别编写date和Time。

1
2
3
4
string time = DateTime.Now.Hour.ToString("00") +":" + DateTime.Now.Minute.ToString("00") +":" + DateTime.Now.Second.ToString("00");
        string date = DateTime.Now.ToString("M-dd-yyyy");
        MessageBox.Show(date +"
" + time);

希望这有帮助。

谈判中的一部分，DateA DateTime面向不workout我们，因为我的工作是在客户端和Web服务的returned值有一些null日期。作为一个结果，它tries to get日期部分的空值和它的throws A运行时例外。下面的实例是如何我solved我的问题： ＜／P >

1
2
3
string dt = employer.BirthDay.ToString();
if(dt ==""){ dt ="N/A";}
else dt = dt.Substring(0,10);
  • get的DateTime值为字符串的热情的一个字符串变量。
  • 如果检查它的零。如果assign零，一个字符串的变量。
  • 如果非零，得到的第一个十字符的字符串的值的和DateTimeassign它的字符串变量。

    • I’m共享未来的参考。 ＜／P >

    使用一点regex：

    1
    Regex.Match(Date.Now.ToString(), @"^.*?(?= )");

    生成格式为：dd/mm/yyyy的日期

    1
    2
    DateTime dd=DateTiem.Now;
    string date=dd.toString("dd/MM/YYYY");

    在案例的你会想要使用结合与表演时没有portion只读。 ＜／P >

    工具提示"结合transactionmodel.transactiondate = {，} StringFormat = D" ＜／P >

    如果你想remove的部分时，从DateTime，尝试使用这样的代码： ＜／P >

    1
    2
    3
    4
    5
    6
    7
    8
    DateTime dt = new DateTime();

    dt = DateTime.Now; //ex: 31/1/2017 6:30:20 PM

    TimeSpan remainingTime = new TimeSpan(0, dt.Hour - 5, dt.Minute - 29, dt.Second - 19);
    dt=dt.Add(remainingTime);

    label1.Text = dt.ToString("HH:mm:ss"); // must be HH not hh

    在01:01:01输出： ＜／P >

    相关讨论

    这样吧，如果你使用一个DateTimeOffset，它也将采取照顾的时区 ＜／P >

    1
    date1 = date1.LocalDateTime.Date;

    如果你需要添加一小时，使用这个： ＜／P >

    1
    2
    date1 = date1.LocalDateTime.Date;
    date1 = date1.AddHours(23).AddMinutes(59).AddSeconds(59);

    我想你会这样：datetime onlydate = datetime.today.date； 或' s的同一时间onlydate yourdatetime date =。。。。。。。；；；；；；； 即使用性质的日期。 ＜／P >

    to get只读的日期portion使用toString()方法， ＜／P >

    实例： datetime.now.date.tostring("日/月/年) ＜／P >

    注： MM的日/月/年"的格式必须capitalized ＜／P >

    是使用一行代码：大学 ＜／P >

    1
    var dateAndTime = DateTime.Now.Date;