DateTime 构造函数

参考

定义

命名空间:: System

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

初始化 DateTime 结构的新实例。

重载

DateTime(Int64)	将 DateTime 结构的新实例初始化为指定的刻度数。
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)	将 DateTime 结构的新实例初始化为指定日历的指定年、月、日、小时、分钟、秒、毫秒和协调世界时 (UTC) 或本地时间。
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)	将 DateTime 结构的新实例初始化为指定日历的指定年、月、日、小时、分钟、秒、毫秒和协调世界时 (UTC) 或本地时间。
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)	将 DateTime 结构的新实例初始化为指定日历的指定年、月、日、小时、分钟、秒、毫秒和协调世界时 (UTC) 或本地时间。
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)	将 DateTime 结构的新实例初始化为指定日历的指定年、月、日、小时、分钟、秒、毫秒和协调世界时 (UTC) 或本地时间。
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)	将 DateTime 结构的新实例初始化为指定日历的指定年、月、日、小时、分钟、秒和毫秒。
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)	将 DateTime 结构的新实例初始化为指定年、月、日、小时、分钟、秒、毫秒和协调世界时 (UTC) 或本地时间。
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)	将 DateTime 结构的新实例初始化为指定的年、月、日、小时、分钟、秒和毫秒。
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)	将 DateTime 结构的新实例初始化为指定日历的指定年、月、日、小时、分钟、秒、毫秒和协调世界时 (UTC) 或本地时间。
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)	将 DateTime 结构的新实例初始化为指定年、月、日、小时、分钟、秒和协调世界时 (UTC) 或本地时间。
DateTime(Int32, Int32, Int32, Int32, Int32, Int32)	将 DateTime 结构的新实例初始化为指定的年、月、日、小时、分钟和秒。
DateTime(Int32, Int32, Int32, Calendar)	将 DateTime 结构的新实例初始化为指定日历的指定年、月和日。
DateTime(Int32, Int32, Int32)	将 DateTime 结构的新实例初始化为指定的年、月和日。
DateTime(DateOnly, TimeOnly, DateTimeKind)	将结构的新实例 DateTime 初始化为指定的 DateOnly 和 TimeOnly ，并遵循指定的 DateTimeKind。
DateTime(Int64, DateTimeKind)	将 DateTime 结构的新实例初始化为指定的计时周期数以及协调世界时 (UTC) 或本地时间。
DateTime(DateOnly, TimeOnly)	将结构的新实例 DateTime 初始化为指定的 DateOnly 和 TimeOnly。新实例将具有类型 Unspecified 。
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)	将 DateTime 结构的新实例初始化为指定日历的年、月、日、小时、分钟和秒。

DateTime(Int64)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定的刻度数。

public:
 DateTime(long ticks);

public DateTime (long ticks);

new DateTime : int64 -> DateTime

Public Sub New (ticks As Long)

参数

ticks: Int64

一个日期和时间，以公历 0001 年 1 月 1 日 00:00:00.000 以来所经历的以 100 纳秒为间隔的间隔数来表示。

例外

ArgumentOutOfRangeException

ticks 小于 DateTime.MinValue 或大于 DateTime.MaxValue。

示例

以下示例演示了其中 DateTime 一个构造函数。

// This example demonstrates the DateTime(Int64) constructor.
using namespace System;
using namespace System::Globalization;
int main()
{
   
   // Instead of using the implicit, default "G" date and time format string, we 
   // use a custom format string that aligns the results and inserts leading zeroes.
   String^ format = "{0}) The {1} date and time is {2:MM/dd/yyyy hh:mm:ss tt}";
   
   // Create a DateTime for the maximum date and time using ticks.
   DateTime dt1 = DateTime(DateTime::MaxValue.Ticks);
   
   // Create a DateTime for the minimum date and time using ticks.
   DateTime dt2 = DateTime(DateTime::MinValue.Ticks);
   
   // Create a custom DateTime for 7/28/1979 at 10:35:05 PM using a 
   // calendar based on the "en-US" culture, and ticks. 
   Int64 ticks = DateTime(1979,07,28,22,35,5,(gcnew CultureInfo( "en-US",false ))->Calendar).Ticks;
   DateTime dt3 = DateTime(ticks);
   Console::WriteLine( format, 1, "maximum", dt1 );
   Console::WriteLine( format, 2, "minimum", dt2 );
   Console::WriteLine( format, 3, "custom ", dt3 );
   Console::WriteLine( "\nThe custom date and time is created from {0:N0} ticks.", ticks );
}

/*
This example produces the following results:

1) The maximum date and time is 12/31/9999 11:59:59 PM
2) The minimum date and time is 01/01/0001 12:00:00 AM
3) The custom  date and time is 07/28/1979 10:35:05 PM

The custom date and time is created from 624,376,461,050,000,000 ticks.

*/

// This example demonstrates the DateTime(Int64) constructor.
open System
open System.Globalization

// Create a DateTime for the maximum date and time using ticks.
let dt1 = DateTime DateTime.MaxValue.Ticks

// Create a DateTime for the minimum date and time using ticks.
let dt2 = DateTime DateTime.MinValue.Ticks

// Create a custom DateTime for 7/28/1979 at 10:35:05 PM using a
// calendar based on the "en-US" culture, and ticks.
let ticks = DateTime(1979, 07, 28, 22, 35, 5, CultureInfo("en-US", false).Calendar).Ticks
let dt3 = DateTime ticks

printfn $"""1) The maximum date and time is {dt1.ToString "MM-dd/yyyy hh:mm:ss tt"}"""
printfn $"""2) The minimum date and time is {dt2.ToString "MM/dd/yyyy hh:mm:ss tt"}"""
printfn $"""3) The custom  date and time is {dt3.ToString "MM/dd/yyyy hh:mm:ss tt"}"""

printfn $"\nThe custom date and time is created from {ticks:N0} ticks."

// This example produces the following results:
//
// 1) The maximum date and time is 12/31/9999 11:59:59 PM
// 2) The minimum date and time is 01/01/0001 12:00:00 AM
// 3) The custom  date and time is 07/28/1979 10:35:05 PM
//
// The custom date and time is created from 624,376,461,050,000,000 ticks.

// This example demonstrates the DateTime(Int64) constructor.
using System;
using System.Globalization;

class Sample
{
    public static void Main()
    {
// Instead of using the implicit, default "G" date and time format string, we
// use a custom format string that aligns the results and inserts leading zeroes.
    string format = "{0}) The {1} date and time is {2:MM/dd/yyyy hh:mm:ss tt}";

// Create a DateTime for the maximum date and time using ticks.
    DateTime dt1 = new DateTime(DateTime.MaxValue.Ticks);

// Create a DateTime for the minimum date and time using ticks.
    DateTime dt2 = new DateTime(DateTime.MinValue.Ticks);

// Create a custom DateTime for 7/28/1979 at 10:35:05 PM using a
// calendar based on the "en-US" culture, and ticks.
    long ticks = new DateTime(1979, 07, 28, 22, 35, 5,
    new CultureInfo("en-US", false).Calendar).Ticks;
    DateTime dt3 = new DateTime(ticks);

    Console.WriteLine(format, 1, "maximum", dt1);
    Console.WriteLine(format, 2, "minimum", dt2);
    Console.WriteLine(format, 3, "custom ", dt3);
    Console.WriteLine("\nThe custom date and time is created from {0:N0} ticks.", ticks);
    }
}
/*
This example produces the following results:

1) The maximum date and time is 12/31/9999 11:59:59 PM
2) The minimum date and time is 01/01/0001 12:00:00 AM
3) The custom  date and time is 07/28/1979 10:35:05 PM

The custom date and time is created from 624,376,461,050,000,000 ticks.

*/

' This example demonstrates the DateTime(Int64) constructor.
Imports System.Globalization

Class Sample
   Public Shared Sub Main()
      ' Instead of using the implicit, default "G" date and time format string, we 
      ' use a custom format string that aligns the results and inserts leading zeroes.
      Dim format As String = "{0}) The {1} date and time is {2:MM/dd/yyyy hh:mm:ss tt}"
      
      ' Create a DateTime for the maximum date and time using ticks.
      Dim dt1 As New DateTime(DateTime.MaxValue.Ticks)
      
      ' Create a DateTime for the minimum date and time using ticks.
      Dim dt2 As New DateTime(DateTime.MinValue.Ticks)
      
      ' Create a custom DateTime for 7/28/1979 at 10:35:05 PM using a 
      ' calendar based on the "en-US" culture, and ticks. 
      Dim ticks As Long = New DateTime(1979, 7, 28, 22, 35, 5, _
                                       New CultureInfo("en-US", False).Calendar).Ticks
      Dim dt3 As New DateTime(ticks)
      
      Console.WriteLine(format, 1, "maximum", dt1)
      Console.WriteLine(format, 2, "minimum", dt2)
      Console.WriteLine(format, 3, "custom ", dt3)
      Console.WriteLine(vbCrLf & "The custom date and time is created from {0:N0} ticks.", ticks)
   End Sub
End Class
'
'This example produces the following results:
'
'1) The maximum date and time is 12/31/9999 11:59:59 PM
'2) The minimum date and time is 01/01/0001 12:00:00 AM
'3) The custom  date and time is 07/28/1979 10:35:05 PM
'
'The custom date and time is created from 624,376,461,050,000,000 ticks.
'

注解

将 Kind 属性初始化为 Unspecified。

对于日期和时间数据的可移植性或有限时区感知非常重要的应用程序，可以使用相应的 DateTimeOffset 构造函数。

适用于

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定日历的指定年、月、日、小时、分钟、秒、毫秒和协调世界时 (UTC) 或本地时间。

public:
 DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond, System::Globalization::Calendar ^ calendar);

public DateTime (int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond, System.Globalization.Calendar calendar);

new DateTime : int * int * int * int * int * int * int * int * System.Globalization.Calendar -> DateTime

Public Sub New (year As Integer, month As Integer, day As Integer, hour As Integer, minute As Integer, second As Integer, millisecond As Integer, microsecond As Integer, calendar As Calendar)

参数

year: Int32

年（1 到 calendar 中的年数）。

month: Int32

月（1 到 calendar 中的月数）。

day: Int32

日（1 到 month 中的天数）。

hour: Int32

小时（0 到 23）。

minute: Int32

分（0 到 59）。

second: Int32

秒（0 到 59）。

millisecond: Int32

毫秒（0 到 999）。

microsecond: Int32

微秒 (0 到 999) 。

calendar: Calendar

用于解释 year、month 和 day 的日历。

例外

ArgumentNullException

calendar 是 null

ArgumentOutOfRangeException

year 不在 calendar 支持的范围内。

或

month 小于 1 或大于 calendar 中的月数。

或

day 小于 1 或大于 month中的天数。

或

hour 小于 0 或大于 23。

或

minute 小于 0 或大于 59。

或

second 小于 0 或大于 59。

或

millisecond 小于 0 或大于 999。

- 或 -

microsecond 小于 0 或大于 999。

注解

、 month和 day 参数的year允许值取决于 calendar 参数。如果无法使用表示 calendar指定的日期和时间，则会引发异常。

对于日期和时间数据的可移植性或有限时区感知非常重要的应用程序，可以使用相应的 DateTimeOffset 构造函数。

适用于

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定日历的指定年、月、日、小时、分钟、秒、毫秒和协调世界时 (UTC) 或本地时间。

public:
 DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond, DateTimeKind kind);

public DateTime (int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond, DateTimeKind kind);

new DateTime : int * int * int * int * int * int * int * int * DateTimeKind -> DateTime

Public Sub New (year As Integer, month As Integer, day As Integer, hour As Integer, minute As Integer, second As Integer, millisecond As Integer, microsecond As Integer, kind As DateTimeKind)

参数

year: Int32

年（1 到 9999）。

month: Int32

月（1 到 12）。

day: Int32

日（1 到 month 中的天数）。

hour: Int32

小时（0 到 23）。

minute: Int32

分（0 到 59）。

second: Int32

秒（0 到 59）。

millisecond: Int32

毫秒（0 到 999）。

microsecond: Int32

微秒 (0 到 999) 。

kind: DateTimeKind

枚举值之一，该值指示 year、month、day, hour、minute、second 和 millisecond 指定了本地时间、协调世界时 (UTC)，还是两者皆未指定。

例外

ArgumentOutOfRangeException

year 小于 1 或大于 9999。

或

month 小于 1 或大于 12。

或

day 小于 1 或大于 month中的天数。

或

hour 小于 0 或大于 23。

或

minute 小于 0 或大于 59。

或

second 小于 0 或大于 59。

或

millisecond 小于 0 或大于 999。

- 或 -

microsecond 小于 0 或大于 999。

ArgumentException

kind 不是 DateTimeKind 值之一。

注解

此构造函数将 year和 monthday 解释为公历中的年、月和日。若要在另一个 DateTime 日历中使用年、月和日来实例化值，请 DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind) 调用构造函数。

对于日期和时间数据的可移植性或有限程度的时区感知非常重要的应用程序，可以使用相应的 DateTimeOffset 构造函数。

适用于

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定日历的指定年、月、日、小时、分钟、秒、毫秒和协调世界时 (UTC) 或本地时间。

public:
 DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, System::Globalization::Calendar ^ calendar, DateTimeKind kind);

public DateTime (int year, int month, int day, int hour, int minute, int second, int millisecond, System.Globalization.Calendar calendar, DateTimeKind kind);

new DateTime : int * int * int * int * int * int * int * System.Globalization.Calendar * DateTimeKind -> DateTime

Public Sub New (year As Integer, month As Integer, day As Integer, hour As Integer, minute As Integer, second As Integer, millisecond As Integer, calendar As Calendar, kind As DateTimeKind)

参数

year: Int32

年（1 到 calendar 中的年数）。

month: Int32

月（1 到 calendar 中的月数）。

day: Int32

日（1 到 month 中的天数）。

hour: Int32

小时（0 到 23）。

minute: Int32

分（0 到 59）。

second: Int32

秒（0 到 59）。

millisecond: Int32

毫秒（0 到 999）。

calendar: Calendar

用于解释 year、month 和 day 的日历。

kind: DateTimeKind

枚举值之一，该值指示 year、month、day, hour、minute、second 和 millisecond 指定了本地时间、协调世界时 (UTC)，还是两者皆未指定。

例外

ArgumentNullException

calendar 上声明的默认值为 null。

ArgumentOutOfRangeException

year 不在 calendar 支持的范围内。

或

month 小于 1 或大于 calendar 中的月数。

或

day 小于 1 或大于 month中的天数。

或

hour 小于 0 或大于 23。

或

minute 小于 0 或大于 59。

或

second 小于 0 或大于 59。

或

millisecond 小于 0 或大于 999。

ArgumentException

kind 不是 DateTimeKind 值之一。

示例

以下示例调用 DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind) 构造函数两次以实例化两个 DateTime 值。第一个 DateTime 调用通过使用 PersianCalendar 对象实例化值。由于无法将波斯历指定为区域性的默认日历，因此在波斯日历中显示日期需要单独调用其 PersianCalendar.GetMonth、 PersianCalendar.GetDayOfMonth和 PersianCalendar.GetYear 方法。对构造函数的第二次DateTime HijriCalendar调用通过使用对象实例化值。该示例将当前区域性更改为阿拉伯语 (叙利亚) ，并将当前区域性的默认日历更改为回历。由于 Hijri 是当前区域性的默认日历，因此该方法 Console.WriteLine 使用它来设置日期格式。当上一个当前区域性 (（在本例中为英语 (美国) ) ）还原时，Console.WriteLine该方法使用当前区域性的默认公历来设置日期格式。

using System;
using System.Globalization;
using System.Text.RegularExpressions;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("Using the Persian Calendar:");
      PersianCalendar persian = new PersianCalendar();
      DateTime date1 = new DateTime(1389, 5, 27, 16, 32, 18, 500,
                                    persian, DateTimeKind.Local);
      Console.WriteLine("{0:M/dd/yyyy h:mm:ss.fff tt} {1}", date1, date1.Kind);
      Console.WriteLine("{0}/{1}/{2} {3}{8}{4:D2}{8}{5:D2}.{6:G3} {7}\n",
                                       persian.GetMonth(date1),
                                       persian.GetDayOfMonth(date1),
                                       persian.GetYear(date1),
                                       persian.GetHour(date1),
                                       persian.GetMinute(date1),
                                       persian.GetSecond(date1),
                                       persian.GetMilliseconds(date1),
                                       date1.Kind,
                                       DateTimeFormatInfo.CurrentInfo.TimeSeparator);

      Console.WriteLine("Using the Hijri Calendar:");
      // Get current culture so it can later be restored.
      CultureInfo dftCulture = Thread.CurrentThread.CurrentCulture;

      // Define strings for use in composite formatting.
      string dFormat;
      string fmtString;
      // Define Hijri calendar.
      HijriCalendar hijri = new HijriCalendar();
      // Make ar-SY the current culture and Hijri the current calendar.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("ar-SY");
      CultureInfo current = CultureInfo.CurrentCulture;
      current.DateTimeFormat.Calendar = hijri;
      dFormat = current.DateTimeFormat.ShortDatePattern;
      // Ensure year is displayed as four digits.
      dFormat = Regex.Replace(dFormat, "/yy$", "/yyyy") + " H:mm:ss.fff";
      fmtString = "{0} culture using the {1} calendar: {2:" + dFormat + "} {3}";
      DateTime date2 = new DateTime(1431, 9, 9, 16, 32, 18, 500,
                                    hijri, DateTimeKind.Local);
      Console.WriteLine(fmtString, current, GetCalendarName(hijri),
                        date2, date2.Kind);

      // Restore previous culture.
      Thread.CurrentThread.CurrentCulture = dftCulture;
      dFormat = DateTimeFormatInfo.CurrentInfo.ShortDatePattern +" H:mm:ss.fff";
      fmtString = "{0} culture using the {1} calendar: {2:" + dFormat + "} {3}";
      Console.WriteLine(fmtString,
                        CultureInfo.CurrentCulture,
                        GetCalendarName(CultureInfo.CurrentCulture.Calendar),
                        date2, date2.Kind);
   }

   private static string GetCalendarName(Calendar cal)
   {
      return Regex.Match(cal.ToString(), "\\.(\\w+)Calendar").Groups[1].Value;
   }
}
// The example displays the following output:
//    Using the Persian Calendar:
//    8/18/2010 4:32:18.500 PM Local
//    5/27/1389 16:32:18.500 Local
//
//    Using the Hijri Calendar:
//    ar-SY culture using the Hijri calendar: 09/09/1431 16:32:18.500 Local
//    en-US culture using the Gregorian calendar: 8/18/2010 16:32:18.500 Local

open System
open System.Globalization
open System.Text.RegularExpressions
open System.Threading

let getCalendarName (cal: Calendar) =
      Regex.Match(string cal, "\\.(\\w+)Calendar").Groups[1].Value

printfn "Using the Persian Calendar:"
let persian = PersianCalendar()
let date1 = DateTime(1389, 5, 27, 16, 32, 18, 500, persian, DateTimeKind.Local)
printfn $"""{date1.ToString "M/dd/yyyy h:mm:ss.fff tt"} {date1.Kind}"""
let sep = DateTimeFormatInfo.CurrentInfo.TimeSeparator
printfn $"{persian.GetMonth date1}/{persian.GetDayOfMonth date1}/{persian.GetYear date1} {persian.GetHour date1}{sep}{persian.GetMinute date1:D2}{sep}{persian.GetSecond date1:D2}.{persian.GetMilliseconds date1:G3} {date1.Kind}\n"

printfn "Using the Hijri Calendar:"
// Get current culture so it can later be restored.
let dftCulture = Thread.CurrentThread.CurrentCulture

// Define Hijri calendar.
let hijri = HijriCalendar()
// Make ar-SY the current culture and Hijri the current calendar.
Thread.CurrentThread.CurrentCulture <- CultureInfo "ar-SY"
let current = CultureInfo.CurrentCulture
current.DateTimeFormat.Calendar <- hijri

let dFormat = 
    let dFormat = current.DateTimeFormat.ShortDatePattern
    // Ensure year is displayed as four digits.
    Regex.Replace(dFormat, "/yy$", "/yyyy") + " H:mm:ss.fff"

let fmtString = "{0} culture using the {1} calendar: {2:" + dFormat + "} {3}"
let date2 = DateTime(1431, 9, 9, 16, 32, 18, 500, hijri, DateTimeKind.Local)
Console.WriteLine(fmtString, current, getCalendarName hijri, date2, date2.Kind)

// Restore previous culture.
Thread.CurrentThread.CurrentCulture <- dftCulture
let dFormat2 = DateTimeFormatInfo.CurrentInfo.ShortDatePattern + " H:mm:ss.fff"
let fmtString2 = "{0} culture using the {1} calendar: {2:" + dFormat2 + "} {3}"
Console.WriteLine(fmtString2, CultureInfo.CurrentCulture, getCalendarName CultureInfo.CurrentCulture.Calendar, date2, date2.Kind)


// The example displays the following output:
//    Using the Persian Calendar:
//    8/18/2010 4:32:18.500 PM Local
//    5/27/1389 16:32:18.500 Local
//
//    Using the Hijri Calendar:
//    ar-SY culture using the Hijri calendar: 09/09/1431 16:32:18.500 Local
//    en-US culture using the Gregorian calendar: 8/18/2010 16:32:18.500 Local

Imports System.Globalization
Imports System.Text.RegularExpressions
Imports System.Threading

Module Example
   Public Sub Main()
      Console.WriteLine("Using the Persian Calendar:")
      Dim persian As New PersianCalendar()
      Dim date1 As New Date(1389, 5, 27, 16, 32, 18, 500, _
                            persian, DateTimeKind.Local)
      Console.WriteLine("{0:M/dd/yyyy h:mm:ss.fff tt} {1}", date1, date1.Kind)
      Console.WriteLine("{0}/{1}/{2} {3}{8}{4:D2}{8}{5:D2}.{6:G3} {7}", _
                                       persian.GetMonth(date1), _
                                       persian.GetDayOfMonth(date1), _
                                       persian.GetYear(date1), _
                                       persian.GetHour(date1), _
                                       persian.GetMinute(date1), _
                                       persian.GetSecond(date1), _
                                       persian.GetMilliseconds(date1), _
                                       date1.Kind, _
                                       DateTimeFormatInfo.CurrentInfo.TimeSeparator)
      Console.WriteLine()
      
      Console.WriteLine("Using the Hijri Calendar:")
      ' Get current culture so it can later be restored.
      Dim dftCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
      
      ' Define strings for use in composite formatting.
      Dim dFormat As String 
      Dim fmtString As String 
      ' Define Hijri calendar.
      Dim hijri As New HijriCalendar()
      ' Make ar-SY the current culture and Hijri the current calendar.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("ar-SY")
      Dim current As CultureInfo = CultureInfo.CurrentCulture
      current.DateTimeFormat.Calendar = hijri
      dFormat = current.DateTimeFormat.ShortDatePattern
      ' Ensure year is displayed as four digits.
      dFormat = Regex.Replace(dFormat, "/yy$", "/yyyy") + " H:mm:ss.fff"
      fmtString = "{0} culture using the {1} calendar: {2:" + dFormat + "} {3}"
      Dim date2 As New Date(1431, 9, 9, 16, 32, 18, 500, _
                            hijri, DateTimeKind.Local)
      Console.WriteLine(fmtString, current, GetCalendarName(hijri), _
                        date2, date2.Kind) 

      ' Restore previous culture.
      Thread.CurrentThread.CurrentCulture = dftCulture
      dFormat = DateTimeFormatInfo.CurrentInfo.ShortDatePattern +" H:mm:ss.fff"
      fmtString = "{0} culture using the {1} calendar: {2:" + dFormat + "} {3}"
      Console.WriteLine(fmtString, CultureInfo.CurrentCulture, _
                        GetCalendarName(CultureInfo.CurrentCulture.Calendar), _
                        date2, date2.Kind) 
   End Sub
   
   Private Function GetCalendarName(cal As Calendar) As String
      Return Regex.Match(cal.ToString(), "\.(\w+)Calendar").Groups(1).Value
   End Function
End Module
' The example displays the following output:
'       Using the Persian Calendar:
'       8/18/2010 4:32:18.500 PM
'       5/27/1389 16:32:18.500
'       
'       Using the Hijri Calendar:
'       ar-SY culture using the Hijri calendar: 09/09/1431 16:32:18.500
'       en-US culture using the Gregorian calendar: 8/18/2010 16:32:18.500

注解

、 month和 day 参数的year允许值取决于 calendar 参数。如果无法使用来表示 calendar指定的日期和时间，则会引发异常。

对于日期和时间数据的可移植性或有限程度的时区感知非常重要的应用程序，可以使用相应的 DateTimeOffset 构造函数。

重要

日本历法中的年号是根据天皇统治来命名的，因此预计会发生变化。例如，2019 年 5 月 1 日在 JapaneseCalendar 和 JapaneseLunisolarCalendar 中标志着令和年号的开始。这种年号的变化会影响使用这些日历的所有应用程序。有关详细信息并确定应用程序是否受到影响，请参阅在 .NET 中处理日语日历中的新纪元。有关在 Windows 系统上测试应用程序以确保其准备好进行纪元更改的信息，请参阅准备应用程序应对日本纪元更改。有关 .NET 中支持具有多个纪元的日历的功能以及使用支持多个纪元的日历时的最佳做法，请参阅使用纪元。

命名空间 System.Globalization 提供多个日历，包括 GregorianCalendar 和 JulianCalendar。

适用于

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定日历的指定年、月、日、小时、分钟、秒、毫秒和协调世界时 (UTC) 或本地时间。

public:
 DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond);

public DateTime (int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond);

new DateTime : int * int * int * int * int * int * int * int -> DateTime

Public Sub New (year As Integer, month As Integer, day As Integer, hour As Integer, minute As Integer, second As Integer, millisecond As Integer, microsecond As Integer)

参数

year: Int32

年（1 到 9999）。

month: Int32

月（1 到 12）。

day: Int32

日（1 到 month 中的天数）。

hour: Int32

小时（0 到 23）。

minute: Int32

分（0 到 59）。

second: Int32

秒（0 到 59）。

millisecond: Int32

毫秒（0 到 999）。

microsecond: Int32

微秒 (0 到 999) 。

例外

ArgumentOutOfRangeException

year 小于 1 或大于 9999。

或

month 小于 1 或大于 12。

或

day 小于 1 或大于 month中的天数。

或

hour 小于 0 或大于 23。

或

minute 小于 0 或大于 59。

或

second 小于 0 或大于 59。

或

millisecond 小于 0 或大于 999。

- 或 -

microsecond 小于 0 或大于 999。

注解

此构造函数将 year、 month 和 day 解释为公历中的年、月和日。若要在另一个 DateTime 日历中使用年、月和日来实例化值，请 DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar) 调用构造函数。

将 Kind 属性初始化为 Unspecified。

对于日期和时间数据的可移植性或有限程度的时区感知非常重要的应用程序，可以使用相应的 DateTimeOffset 构造函数。

适用于

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定日历的指定年、月、日、小时、分钟、秒和毫秒。

public:
 DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, System::Globalization::Calendar ^ calendar);

public DateTime (int year, int month, int day, int hour, int minute, int second, int millisecond, System.Globalization.Calendar calendar);

new DateTime : int * int * int * int * int * int * int * System.Globalization.Calendar -> DateTime

Public Sub New (year As Integer, month As Integer, day As Integer, hour As Integer, minute As Integer, second As Integer, millisecond As Integer, calendar As Calendar)

参数

year: Int32

年（1 到 calendar 中的年数）。

month: Int32

月（1 到 calendar 中的月数）。

day: Int32

日（1 到 month 中的天数）。

hour: Int32

小时（0 到 23）。

minute: Int32

分（0 到 59）。

second: Int32

秒（0 到 59）。

millisecond: Int32

毫秒（0 到 999）。

calendar: Calendar

用于解释 year、month 和 day 的日历。

例外

ArgumentNullException

calendar 上声明的默认值为 null。

ArgumentOutOfRangeException

year 不在 calendar 支持的范围内。

或

month 小于 1 或大于 calendar 中的月数。

或

day 小于 1 或大于 month中的天数。

或

hour 小于 0 或大于 23。

或

minute 小于 0 或大于 59。

或

second 小于 0 或大于 59。

或

millisecond 小于 0 或大于 999。

示例

以下示例调用 DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar) 构造函数两次以实例化两个 DateTime 值。第一个 DateTime 调用通过使用 PersianCalendar 对象实例化值。由于无法将波斯历指定为区域性的默认日历，因此在波斯日历中显示日期需要单独调用其 PersianCalendar.GetMonth、 PersianCalendar.GetDayOfMonth和 PersianCalendar.GetYear 方法。对构造函数的第二次DateTime HijriCalendar调用通过使用对象实例化值。该示例将当前区域性更改为阿拉伯语 (叙利亚) ，并将当前区域性的默认日历更改为回历。由于 Hijri 是当前区域性的默认日历，因此该方法 Console.WriteLine 使用它来设置日期格式。当上一个当前区域性 (（在本例中为英语 (美国) ) ）还原时，Console.WriteLine该方法使用当前区域性的默认公历来设置日期格式。

using System;
using System.Globalization;
using System.Text.RegularExpressions;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("Using the Persian Calendar:");
      PersianCalendar persian = new PersianCalendar();
      DateTime date1 = new DateTime(1389, 5, 27, 16, 32, 18, 500, persian);
      Console.WriteLine(date1.ToString("M/dd/yyyy h:mm:ss.fff tt"));
      Console.WriteLine("{0}/{1}/{2} {3}{7}{4:D2}{7}{5:D2}.{6:G3}\n",
                                       persian.GetMonth(date1),
                                       persian.GetDayOfMonth(date1),
                                       persian.GetYear(date1),
                                       persian.GetHour(date1),
                                       persian.GetMinute(date1),
                                       persian.GetSecond(date1),
                                       persian.GetMilliseconds(date1),
                                       DateTimeFormatInfo.CurrentInfo.TimeSeparator);

      Console.WriteLine("Using the Hijri Calendar:");
      // Get current culture so it can later be restored.
      CultureInfo dftCulture = Thread.CurrentThread.CurrentCulture;

      // Define strings for use in composite formatting.
      string dFormat;
      string fmtString;
      // Define Hijri calendar.
      HijriCalendar hijri = new HijriCalendar();
      // Make ar-SY the current culture and Hijri the current calendar.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("ar-SY");
      CultureInfo current = CultureInfo.CurrentCulture;
      current.DateTimeFormat.Calendar = hijri;
      dFormat = current.DateTimeFormat.ShortDatePattern;
      // Ensure year is displayed as four digits.
      dFormat = Regex.Replace(dFormat, "/yy$", "/yyyy") + " H:mm:ss.fff";
      fmtString = "{0} culture using the {1} calendar: {2:" + dFormat + "}";
      DateTime date2 = new DateTime(1431, 9, 9, 16, 32, 18, 500, hijri);
      Console.WriteLine(fmtString, current, GetCalendarName(hijri), date2);

      // Restore previous culture.
      Thread.CurrentThread.CurrentCulture = dftCulture;
      dFormat = DateTimeFormatInfo.CurrentInfo.ShortDatePattern +" H:mm:ss.fff";
      fmtString = "{0} culture using the {1} calendar: {2:" + dFormat + "}";
      Console.WriteLine(fmtString,
                        CultureInfo.CurrentCulture,
                        GetCalendarName(CultureInfo.CurrentCulture.Calendar),
                        date2);
   }

   private static string GetCalendarName(Calendar cal)
   {
      return Regex.Match(cal.ToString(), "\\.(\\w+)Calendar").Groups[1].Value;
   }
}
// The example displays the following output:
//       8/18/2010 4:32:18.500 PM
//       5/27/1389 16:32:18.500
//
//       Using the Hijri Calendar:
//       ar-SY culture using the Hijri calendar: 09/09/1431 16:32:18.500
//       en-US culture using the Gregorian calendar: 8/18/2010 16:32:18.500

open System
open System.Globalization
open System.Text.RegularExpressions
open System.Threading

let getCalendarName (cal: Calendar) =
      Regex.Match(string cal, "\\.(\\w+)Calendar").Groups[1].Value

printfn "Using the Persian Calendar:"
let persian = PersianCalendar()
let date1 = DateTime(1389, 5, 27, 16, 32, 18, 500, persian)
printfn $"""{date1.ToString("M/dd/yyyy h:mm:ss.fff tt")}"""
let sep = DateTimeFormatInfo.CurrentInfo.TimeSeparator
printfn $"{persian.GetMonth date1}/{persian.GetDayOfMonth date1}/{persian.GetYear date1} {persian.GetHour date1}{sep}%02i{persian.GetMinute date1}{sep}%02i{persian.GetSecond date1}.%.3f{persian.GetMilliseconds date1}\n"

printfn "Using the Hijri Calendar:"
// Get current culture so it can later be restored.
let dftCulture = Thread.CurrentThread.CurrentCulture

// Define Hijri calendar.
let hijri = HijriCalendar()
// Make ar-SY the current culture and Hijri the current calendar.
Thread.CurrentThread.CurrentCulture <- CultureInfo "ar-SY"
let current = CultureInfo.CurrentCulture
current.DateTimeFormat.Calendar <- hijri

let dFormat = 
    let dFormat = current.DateTimeFormat.ShortDatePattern
    // Ensure year is displayed as four digits.
    Regex.Replace(dFormat, "/yy$", "/yyyy") + " H:mm:ss.fff"

let fmtString = "{0} culture using the {1} calendar: {2:" + dFormat + "}"
let date2 = DateTime(1431, 9, 9, 16, 32, 18, 500, hijri)
Console.WriteLine(fmtString, current, getCalendarName hijri, date2)

// Restore previous culture.
Thread.CurrentThread.CurrentCulture <- dftCulture
let dFormat2 = DateTimeFormatInfo.CurrentInfo.ShortDatePattern + " H:mm:ss.fff"
let fmtString2 = "{0} culture using the {1} calendar: {2:" + dFormat + "}"
Console.WriteLine(fmtString2, CultureInfo.CurrentCulture, getCalendarName CultureInfo.CurrentCulture.Calendar, date2)


// The example displays the following output:
//       8/18/2010 4:32:18.500 PM
//       5/27/1389 16:32:18.500
//
//       Using the Hijri Calendar:
//       ar-SY culture using the Hijri calendar: 09/09/1431 16:32:18.500
//       en-US culture using the Gregorian calendar: 8/18/2010 16:32:18.500

Imports System.Globalization
Imports System.Text.RegularExpressions
Imports System.Threading

Module Example
   Public Sub Main()
      Console.WriteLine("Using the Persian Calendar:")
      Dim persian As New PersianCalendar()
      Dim date1 As New Date(1389, 5, 27, 16, 32, 18, 500, persian)
      Console.WriteLine(date1.ToString("M/dd/yyyy h:mm:ss.fff tt"))
      Console.WriteLine("{0}/{1}/{2} {3}{7}{4:D2}{7}{5:D2}.{6:G3}", _
                                       persian.GetMonth(date1), _
                                       persian.GetDayOfMonth(date1), _
                                       persian.GetYear(date1), _
                                       persian.GetHour(date1), _
                                       persian.GetMinute(date1), _
                                       persian.GetSecond(date1), _
                                       persian.GetMilliseconds(date1), _
                                       DateTimeFormatInfo.CurrentInfo.TimeSeparator)
      Console.WriteLine()
      
      Console.WriteLine("Using the Hijri Calendar:")
      ' Get current culture so it can later be restored.
      Dim dftCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
      
      ' Define strings for use in composite formatting.
      Dim dFormat As String 
      Dim fmtString As String 
      ' Define Hijri calendar.
      Dim hijri As New HijriCalendar()
      ' Make ar-SY the current culture and Hijri the current calendar.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("ar-SY")
      Dim current As CultureInfo = CultureInfo.CurrentCulture
      current.DateTimeFormat.Calendar = hijri
      dFormat = current.DateTimeFormat.ShortDatePattern
      ' Ensure year is displayed as four digits.
      dFormat = Regex.Replace(dFormat, "/yy$", "/yyyy") + " H:mm:ss.fff"
      fmtString = "{0} culture using the {1} calendar: {2:" + dFormat + "}"
      Dim date2 As New Date(1431, 9, 9, 16, 32, 18, 500, hijri)
      Console.WriteLine(fmtString, current, GetCalendarName(hijri), date2) 

      ' Restore previous culture.
      Thread.CurrentThread.CurrentCulture = dftCulture
      dFormat = DateTimeFormatInfo.CurrentInfo.ShortDatePattern +" H:mm:ss.fff"
      fmtString = "{0} culture using the {1} calendar: {2:" + dFormat + "}"
      Console.WriteLine(fmtString, CultureInfo.CurrentCulture, _
                        GetCalendarName(CultureInfo.CurrentCulture.Calendar), _
                        date2) 
   End Sub
   
   Private Function GetCalendarName(cal As Calendar) As String
      Return Regex.Match(cal.ToString(), "\.(\w+)Calendar").Groups(1).Value
   End Function
End Module
' The example displays the following output:
'       Using the Persian Calendar:
'       8/18/2010 4:32:18.500 PM
'       5/27/1389 16:32:18.500
'       
'       Using the Hijri Calendar:
'       ar-SY culture using the Hijri calendar: 09/09/1431 16:32:18.500
'       en-US culture using the Gregorian calendar: 8/18/2010 16:32:18.500

注解

将 Kind 属性初始化为 Unspecified。

、和的year允许值取决于 calendar。daymonth 如果无法使用来表示 calendar指定的日期和时间，则会引发异常。

对于日期和时间数据的可移植性或有限程度的时区感知非常重要的应用程序，可以使用相应的 DateTimeOffset 构造函数。

重要

命名空间 System.Globalization 提供多个日历，包括 GregorianCalendar 和 JulianCalendar。

另请参阅

适用于

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定年、月、日、小时、分钟、秒、毫秒和协调世界时 (UTC) 或本地时间。

public:
 DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, DateTimeKind kind);

public DateTime (int year, int month, int day, int hour, int minute, int second, int millisecond, DateTimeKind kind);

new DateTime : int * int * int * int * int * int * int * DateTimeKind -> DateTime

Public Sub New (year As Integer, month As Integer, day As Integer, hour As Integer, minute As Integer, second As Integer, millisecond As Integer, kind As DateTimeKind)

参数

year: Int32

年（1 到 9999）。

month: Int32

月（1 到 12）。

day: Int32

日（1 到 month 中的天数）。

hour: Int32

小时（0 到 23）。

minute: Int32

分（0 到 59）。

second: Int32

秒（0 到 59）。

millisecond: Int32

毫秒（0 到 999）。

kind: DateTimeKind

枚举值之一，该值指示 year、month、day, hour、minute、second 和 millisecond 指定了本地时间、协调世界时 (UTC)，还是两者皆未指定。

例外

ArgumentOutOfRangeException

year 小于 1 或大于 9999。

或

month 小于 1 或大于 12。

或

day 小于 1 或大于 month中的天数。

或

hour 小于 0 或大于 23。

或

minute 小于 0 或大于 59。

或

second 小于 0 或大于 59。

或

millisecond 小于 0 或大于 999。

ArgumentException

kind 不是 DateTimeKind 值之一。

示例

下面的示例使用 DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind) 构造函数来实例化 DateTime 值。

DateTime date1 = new DateTime(2010, 8, 18, 16, 32, 18, 500,
                              DateTimeKind.Local);
Console.WriteLine("{0:M/dd/yyyy h:mm:ss.fff tt} {1}", date1, date1.Kind);
// The example displays the following output, in this case for en-us culture:
//      8/18/2010 4:32:18.500 PM Local

let date1 = DateTime(2010, 8, 18, 16, 32, 18, 500, DateTimeKind.Local)
printfn $"""{date1.ToString "M/dd/yyyy h:mm:ss.fff tt"} {date1.Kind}"""

// The example displays the following output, in this case for en-us culture:
//      8/18/2010 4:32:18.500 PM Local

Dim date1 As New Date(2010, 8, 18, 16, 32, 18, 500, DateTimeKind.Local)
Console.WriteLine("{0:M/dd/yyyy h:mm:ss.fff tt} {1}", date1, date1.Kind)
' The example displays the following output:
'      8/18/2010 4:32:18.500 PM Local

注解

此构造函数将yearmonth 、和 day 解释为公历中的年、月和日。若要在另一个 DateTime 日历中使用年、月和日来实例化值，请 DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind) 调用构造函数。

对于日期和时间数据的可移植性或有限程度的时区感知非常重要的应用程序，可以使用相应的 DateTimeOffset 构造函数。

适用于

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定的年、月、日、小时、分钟、秒和毫秒。

public:
 DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond);

public DateTime (int year, int month, int day, int hour, int minute, int second, int millisecond);

new DateTime : int * int * int * int * int * int * int -> DateTime

Public Sub New (year As Integer, month As Integer, day As Integer, hour As Integer, minute As Integer, second As Integer, millisecond As Integer)

参数

year: Int32

年（1 到 9999）。

month: Int32

月（1 到 12）。

day: Int32

日（1 到 month 中的天数）。

hour: Int32

小时（0 到 23）。

minute: Int32

分（0 到 59）。

second: Int32

秒（0 到 59）。

millisecond: Int32

毫秒（0 到 999）。

例外

ArgumentOutOfRangeException

year 小于 1 或大于 9999。

或

month 小于 1 或大于 12。

或

day 小于 1 或大于 month中的天数。

或

hour 小于 0 或大于 23。

或

minute 小于 0 或大于 59。

或

second 小于 0 或大于 59。

或

millisecond 小于 0 或大于 999。

示例

下面的示例使用 DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32) 构造函数来实例化 DateTime 值。

DateTime date1 = new DateTime(2010, 8, 18, 16, 32, 18, 500);
Console.WriteLine(date1.ToString("M/dd/yyyy h:mm:ss.fff tt"));
// The example displays the following output, in this case for en-us culture:
//      8/18/2010 4:32:18.500 PM

let date1 = DateTime(2010, 8, 18, 16, 32, 18, 500)

date1.ToString "M/dd/yyyy h:mm:ss.fff tt"
|> printfn "%s"

// The example displays the following output, in this case for en-us culture:
//      8/18/2010 4:32:18.500 PM

Dim date1 As New Date(2010, 8, 18, 16, 32, 18, 500)
Console.WriteLine(date1.ToString("M/dd/yyyy h:mm:ss.fff tt"))
' The example displays the following output:
'      8/18/2010 4:32:18.500 PM

注解

此构造函数将yearmonth 、和 day 解释为公历中的年、月和日。若要在另一个 DateTime 日历中使用年、月和日来实例化值，请 DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar) 调用构造函数。

将 Kind 属性初始化为 Unspecified。

对于日期和时间数据的可移植性或有限程度的时区感知非常重要的应用程序，可以使用相应的 DateTimeOffset 构造函数。

另请参阅

Int32

适用于

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定日历的指定年、月、日、小时、分钟、秒、毫秒和协调世界时 (UTC) 或本地时间。

public:
 DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond, System::Globalization::Calendar ^ calendar, DateTimeKind kind);

public DateTime (int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond, System.Globalization.Calendar calendar, DateTimeKind kind);

new DateTime : int * int * int * int * int * int * int * int * System.Globalization.Calendar * DateTimeKind -> DateTime

Public Sub New (year As Integer, month As Integer, day As Integer, hour As Integer, minute As Integer, second As Integer, millisecond As Integer, microsecond As Integer, calendar As Calendar, kind As DateTimeKind)

参数

year: Int32

年（1 到 calendar 中的年数）。

month: Int32

月（1 到 calendar 中的月数）。

day: Int32

日（1 到 month 中的天数）。

hour: Int32

小时（0 到 23）。

minute: Int32

分（0 到 59）。

second: Int32

秒（0 到 59）。

millisecond: Int32

毫秒（0 到 999）。

microsecond: Int32

微秒 (0 到 999) 。

calendar: Calendar

用于解释 year、month 和 day 的日历。

kind: DateTimeKind

枚举值之一，该值指示 year、month、day, hour、minute、second 和 millisecond 指定了本地时间、协调世界时 (UTC)，还是两者皆未指定。

例外

ArgumentNullException

calendar 是 null

ArgumentOutOfRangeException

year 不在 calendar 支持的范围内。

或

month 小于 1 或大于 calendar 中的月数。

或

day 小于 1 或大于 month中的天数。

或

hour 小于 0 或大于 23。

或

minute 小于 0 或大于 59。

或

second 小于 0 或大于 59。

或

millisecond 小于 0 或大于 999。

- 或 -

microsecond 小于 0 或大于 999。

ArgumentException

kind 不是 DateTimeKind 值之一。

注解

、 month和 day 参数的year允许值取决于 calendar 参数。如果无法使用来表示 calendar指定的日期和时间，则会引发异常。

对于日期和时间数据的可移植性或有限程度的时区感知非常重要的应用程序，可以使用相应的 DateTimeOffset 构造函数。

适用于

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定年、月、日、小时、分钟、秒和协调世界时 (UTC) 或本地时间。

public:
 DateTime(int year, int month, int day, int hour, int minute, int second, DateTimeKind kind);

public DateTime (int year, int month, int day, int hour, int minute, int second, DateTimeKind kind);

new DateTime : int * int * int * int * int * int * DateTimeKind -> DateTime

Public Sub New (year As Integer, month As Integer, day As Integer, hour As Integer, minute As Integer, second As Integer, kind As DateTimeKind)

参数

year: Int32

年（1 到 9999）。

month: Int32

月（1 到 12）。

day: Int32

日（1 到 month 中的天数）。

hour: Int32

小时（0 到 23）。

minute: Int32

分（0 到 59）。

second: Int32

秒（0 到 59）。

kind: DateTimeKind

枚举值之一，该值指示 year、month、day、hour、minute 和 second 指定了本地时间、协调世界时 (UTC)，还是两者皆未指定。

例外

ArgumentOutOfRangeException

year 小于 1 或大于 9999。

或

month 小于 1 或大于 12。

或

day 小于 1 或大于 month中的天数。

或

hour 小于 0 或大于 23。

或

minute 小于 0 或大于 59。

或

second 小于 0 或大于 59。

ArgumentException

kind 不是 DateTimeKind 值之一。

示例

以下示例使用 DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind) 构造函数来实例化 DateTime 值。

DateTime date1 = new DateTime(2010, 8, 18, 16, 32, 0, DateTimeKind.Local);
Console.WriteLine("{0} {1}", date1, date1.Kind);
// The example displays the following output, in this case for en-us culture:
//      8/18/2010 4:32:00 PM Local

let date1 = DateTime(2010, 8, 18, 16, 32, 0, DateTimeKind.Local)
printfn $"{date1} {date1.Kind}"

// The example displays the following output, in this case for en-us culture:
//      8/18/2010 4:32:00 PM Local

Dim date1 As New Date(2010, 8, 18, 16, 32, 0, DateTimeKind.Local)
Console.WriteLine("{0} {1}", date1, date1.Kind)
' The example displays the following output:
'      8/18/2010 4:32:00 PM Local

注解

此构造函数将yearmonth 、和 day 解释为公历中的年、月和日。若要在另一个 DateTime 日历中使用年、月和日实例化值，请调用 DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind) 构造函数。

对于日期和时间数据的可移植性或有限时区感知非常重要的应用程序，可以使用相应的 DateTimeOffset 构造函数。

适用于

DateTime(Int32, Int32, Int32, Int32, Int32, Int32)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定的年、月、日、小时、分钟和秒。

public:
 DateTime(int year, int month, int day, int hour, int minute, int second);

public DateTime (int year, int month, int day, int hour, int minute, int second);

new DateTime : int * int * int * int * int * int -> DateTime

Public Sub New (year As Integer, month As Integer, day As Integer, hour As Integer, minute As Integer, second As Integer)

参数

year: Int32

年（1 到 9999）。

month: Int32

月（1 到 12）。

day: Int32

日（1 到 month 中的天数）。

hour: Int32

小时（0 到 23）。

minute: Int32

分（0 到 59）。

second: Int32

秒（0 到 59）。

例外

ArgumentOutOfRangeException

year 小于 1 或大于 9999。

或

month 小于 1 或大于 12。

或

day 小于 1 或大于 month中的天数。

或

hour 小于 0 或大于 23。

或

minute 小于 0 或大于 59。

或

second 小于 0 或大于 59。

示例

以下示例使用 DateTime 构造函数来实例化 DateTime 值。

DateTime date1 = new DateTime(2010, 8, 18, 16, 32, 0);
Console.WriteLine(date1.ToString());
// The example displays the following output, in this case for en-us culture:
//      8/18/2010 4:32:00 PM

let date1 = DateTime(2010, 8, 18, 16, 32, 0)
printfn $"{date1}"

// The example displays the following output, in this case for en-us culture:
//      8/18/2010 4:32:00 PM

Dim date1 As New Date(2010, 8, 18, 16, 32, 0)
Console.WriteLine(date1.ToString())
' The example displays the following output:
'      8/18/2010 4:32:00 PM

注解

将 Kind 属性初始化为 Unspecified。

此构造函数将yearmonth 、和 day 解释为公历中的年、月和日。若要在另一个 DateTime 日历中使用年、月和日实例化值，请调用 DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar) 构造函数。

对于日期和时间数据的可移植性或有限时区感知非常重要的应用程序，可以使用相应的 DateTimeOffset 构造函数。

适用于

DateTime(Int32, Int32, Int32, Calendar)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定日历的指定年、月和日。

public:
 DateTime(int year, int month, int day, System::Globalization::Calendar ^ calendar);

public DateTime (int year, int month, int day, System.Globalization.Calendar calendar);

new DateTime : int * int * int * System.Globalization.Calendar -> DateTime

Public Sub New (year As Integer, month As Integer, day As Integer, calendar As Calendar)

参数

year: Int32

年（1 到 calendar 中的年数）。

month: Int32

月（1 到 calendar 中的月数）。

day: Int32

日（1 到 month 中的天数）。

calendar: Calendar

用于解释 year、month 和 day 的日历。

例外

ArgumentNullException

calendar 上声明的默认值为 null。

ArgumentOutOfRangeException

year 不在 calendar 支持的范围内。

或

month 小于 1 或大于 calendar 中的月数。

或

day 小于 1 或大于 month中的天数。

示例

以下示例调用 DateTime(Int32, Int32, Int32, Calendar) 构造函数两次以实例化两个 DateTime 值。第一个 DateTime 调用通过使用对象实例化值 PersianCalendar 。由于无法将波斯历指定为区域性的默认日历，因此在波斯日历中显示日期需要单独调用其 PersianCalendar.GetMonth、 PersianCalendar.GetDayOfMonth和 PersianCalendar.GetYear 方法。对构造函数的第二次HijriCalendar调用通过使用对象实例化DateTime值。该示例将当前区域性更改为阿拉伯语 (叙利亚) ，并将当前区域性的默认日历更改为 Hijri 日历。由于 Hijri 是当前区域性的默认日历，因此该方法 Console.WriteLine 使用它来设置日期的格式。当还原上一个当前区域性 (（在本例中为英语 (美国) ) ）时，Console.WriteLine方法使用当前区域性的默认公历来设置日期格式。

using System;
using System.Globalization;
using System.Text.RegularExpressions;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("Using the Persian Calendar:");
      PersianCalendar persian = new PersianCalendar();
      DateTime date1 = new DateTime(1389, 5, 27, persian);
      Console.WriteLine(date1.ToString());
      Console.WriteLine("{0}/{1}/{2}\n", persian.GetMonth(date1),
                                       persian.GetDayOfMonth(date1),
                                       persian.GetYear(date1));

      Console.WriteLine("Using the Hijri Calendar:");
      // Get current culture so it can later be restored.
      CultureInfo dftCulture = Thread.CurrentThread.CurrentCulture;

      // Define Hijri calendar.
      HijriCalendar hijri = new HijriCalendar();
      // Make ar-SY the current culture and Hijri the current calendar.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("ar-SY");
      CultureInfo current = CultureInfo.CurrentCulture;
      current.DateTimeFormat.Calendar = hijri;
      string dFormat = current.DateTimeFormat.ShortDatePattern;
      // Ensure year is displayed as four digits.
      dFormat = Regex.Replace(dFormat, "/yy$", "/yyyy");
      current.DateTimeFormat.ShortDatePattern = dFormat;
      DateTime date2 = new DateTime(1431, 9, 9, hijri);
      Console.WriteLine("{0} culture using the {1} calendar: {2:d}", current,
                        GetCalendarName(hijri), date2);

      // Restore previous culture.
      Thread.CurrentThread.CurrentCulture = dftCulture;
      Console.WriteLine("{0} culture using the {1} calendar: {2:d}",
                        CultureInfo.CurrentCulture,
                        GetCalendarName(CultureInfo.CurrentCulture.Calendar),
                        date2);
   }

   private static string GetCalendarName(Calendar cal)
   {
      return Regex.Match(cal.ToString(), "\\.(\\w+)Calendar").Groups[1].Value;
   }
}
// The example displays the following output:
//       Using the Persian Calendar:
//       8/18/2010 12:00:00 AM
//       5/27/1389
//
//       Using the Hijri Calendar:
//       ar-SY culture using the Hijri calendar: 09/09/1431
//       en-US culture using the Gregorian calendar: 8/18/2010

open System
open System.Globalization
open System.Text.RegularExpressions
open System.Threading

let getCalendarName (cal: Calendar) =
    Regex.Match(string cal, "\\.(\\w+)Calendar").Groups[1].Value

printfn "Using the Persian Calendar:"
let persian = PersianCalendar()
let date1 = DateTime(1389, 5, 27, persian)
printfn $"{date1}"
printfn $"{persian.GetMonth date1}/{persian.GetDayOfMonth date1}/{persian.GetYear date1}\n"

printfn "Using the Hijri Calendar:"
// Get current culture so it can later be restored.
let dftCulture = Thread.CurrentThread.CurrentCulture

// Define Hijri calendar.
let hijri = HijriCalendar()
// Make ar-SY the current culture and Hijri the current calendar.
Thread.CurrentThread.CurrentCulture <- CultureInfo "ar-SY"
let current = CultureInfo.CurrentCulture
current.DateTimeFormat.Calendar <- hijri

let dFormat =
    let dFormat = current.DateTimeFormat.ShortDatePattern
    // Ensure year is displayed as four digits.
    Regex.Replace(dFormat, "/yy$", "/yyyy")

current.DateTimeFormat.ShortDatePattern <- dFormat
let date2 = DateTime(1431, 9, 9, hijri)
printfn $"{current} culture using the {getCalendarName hijri} calendar: {date2:d}"

// Restore previous culture.
Thread.CurrentThread.CurrentCulture <- dftCulture
printfn $"{CultureInfo.CurrentCulture} culture using the {getCalendarName CultureInfo.CurrentCulture.Calendar} calendar: {date2:d}"


// The example displays the following output:
//       Using the Persian Calendar:
//       8/18/2010 12:00:00 AM
//       5/27/1389
//
//       Using the Hijri Calendar:
//       ar-SY culture using the Hijri calendar: 09/09/1431
//       en-US culture using the Gregorian calendar: 8/18/2010

Imports System.Globalization
Imports System.Text.RegularExpressions
Imports System.Threading

Module Example
   Public Sub Main()
      Console.WriteLine("Using the Persian Calendar:")
      Dim persian As New PersianCalendar()
      Dim date1 As New Date(1389, 5, 27, persian)
      Console.WriteLine(date1.ToString())
      Console.WriteLine("{0}/{1}/{2}", persian.GetMonth(date1), _
                                       persian.GetDayOfMonth(date1), _
                                       persian.GetYear(date1))
      Console.WriteLine()
      
      Console.WriteLine("Using the Hijri Calendar:")
      ' Get current culture so it can later be restored.
      Dim dftCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
      
      ' Define Hijri calendar.
      Dim hijri As New HijriCalendar()
      ' Make ar-SY the current culture and Hijri the current calendar.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("ar-SY")
      Dim current As CultureInfo = CultureInfo.CurrentCulture
      current.DateTimeFormat.Calendar = hijri
      Dim dFormat As String = current.DateTimeFormat.ShortDatePattern
      ' Ensure year is displayed as four digits.
      dFormat = Regex.Replace(dFormat, "/yy$", "/yyyy")
      current.DateTimeFormat.ShortDatePattern = dFormat
      Dim date2 As New Date(1431, 9, 9, hijri)
      Console.WriteLine("{0} culture using the {1} calendar: {2:d}", current, _
                        GetCalendarName(hijri), date2) 
      
      ' Restore previous culture.
      Thread.CurrentThread.CurrentCulture = dftCulture
      Console.WriteLine("{0} culture using the {1} calendar: {2:d}", _
                        CultureInfo.CurrentCulture, _
                        GetCalendarName(CultureInfo.CurrentCulture.Calendar), _
                        date2) 
   End Sub
   
   Private Function GetCalendarName(cal As Calendar) As String
      Return Regex.Match(cal.ToString(), "\.(\w+)Calendar").Groups(1).Value
   End Function
End Module
' The example displays the following output:
'       Using the Persian Calendar:
'       8/18/2010 12:00:00 AM
'       5/27/1389
'       
'       Using the Hijri Calendar:
'       ar-SY culture using the Hijri calendar: 09/09/1431
'       en-US culture using the Gregorian calendar: 8/18/2010

注解

生成的 DateTime 一天中的时间为午夜 (00：00：00) 。将 Kind 属性初始化为 Unspecified。

、和的year允许值取决于 calendar。daymonth 如果无法使用表示 calendar指定的日期和时间，则会引发异常。

重要

日本历法中的年号是根据天皇统治来命名的，因此预计会发生变化。例如，2019 年 5 月 1 日在 JapaneseCalendar 和 JapaneseLunisolarCalendar 中标志着令和年号的开始。这种年号的变化会影响使用这些日历的所有应用程序。有关详细信息并确定应用程序是否受到影响，请参阅在 .NET 中处理日语日历中的新纪元。有关在 Windows 系统上测试应用程序以确保其为时代更改做好准备的信息，请参阅为日本时代更改准备应用程序。有关 .NET 中支持具有多个纪元的日历的功能以及使用支持多个纪元的日历时的最佳做法，请参阅使用纪元。

命名空间 System.Globalization 提供多个日历，包括 GregorianCalendar 和 JulianCalendar。

另请参阅

适用于

DateTime(Int32, Int32, Int32)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定的年、月和日。

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

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

new DateTime : int * int * int -> DateTime

Public Sub New (year As Integer, month As Integer, day As Integer)

参数

year: Int32

年（1 到 9999）。

month: Int32

月（1 到 12）。

day: Int32

日（1 到 month 中的天数）。

例外

ArgumentOutOfRangeException

year 小于 1 或大于 9999。

或

month 小于 1 或大于 12。

或

day 小于 1 或大于 month中的天数。

示例

以下示例使用 DateTime(Int32, Int32, Int32) 构造函数来实例化 DateTime 值。该示例还演示了此重载创建一个 DateTime 值，其时间组件等于午夜 (或 0：00) 。

DateTime date1 = new DateTime(2010, 8, 18);
Console.WriteLine(date1.ToString());
// The example displays the following output:
//      8/18/2010 12:00:00 AM

let date1 = DateTime(2010, 8, 18)
printfn $"{date1}"

// The example displays the following output:
//      8/18/2010 12:00:00 AM

Dim date1 As New Date(2010, 8, 18)
Console.WriteLine(date1.ToString())
' The example displays the following output:
'      8/18/2010 12:00:00 AM

注解

此构造函数将 year、 month和 day 解释为公历中的年、月和日。若要在另一个 DateTime 日历中使用年、月和日实例化值，请调用 DateTime(Int32, Int32, Int32, Calendar) 构造函数。

生成的 DateTime 一天中的时间为午夜 (00：00：00) 。将 Kind 属性初始化为 DateTimeKind.Unspecified。

适用于

DateTime(DateOnly, TimeOnly, DateTimeKind)

Source:: DateTime.cs

Source:: DateTime.cs

将结构的新实例 DateTime 初始化为指定的 DateOnly 和 TimeOnly ，并遵循指定的 DateTimeKind。

public:
 DateTime(DateOnly date, TimeOnly time, DateTimeKind kind);

public DateTime (DateOnly date, TimeOnly time, DateTimeKind kind);

new DateTime : DateOnly * TimeOnly * DateTimeKind -> DateTime

Public Sub New (date As DateOnly, time As TimeOnly, kind As DateTimeKind)

参数

date: DateOnly

日期部分。

time: TimeOnly

时间部分。

kind: DateTimeKind

枚举值之一，指示 date 和 time 指定本地时间、协调世界时 (UTC) ，或者两者都不指定。

适用于

DateTime(Int64, DateTimeKind)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定的计时周期数以及协调世界时 (UTC) 或本地时间。

public:
 DateTime(long ticks, DateTimeKind kind);

public DateTime (long ticks, DateTimeKind kind);

new DateTime : int64 * DateTimeKind -> DateTime

Public Sub New (ticks As Long, kind As DateTimeKind)

参数

ticks: Int64

一个日期和时间，以公历 0001 年 1 月 1 日 00:00:00.000 以来所经历的以 100 纳秒为间隔的间隔数来表示。

kind: DateTimeKind

枚举值之一，该值指示 ticks 是指定了本地时间、协调世界时 (UTC)，还是两者皆未指定。

例外

ArgumentOutOfRangeException

ticks 小于 DateTime.MinValue 或大于 DateTime.MaxValue。

ArgumentException

kind 不是 DateTimeKind 值之一。

注解

对于日期和时间数据的可移植性或有限程度的时区感知非常重要的应用程序，可以使用相应的 DateTimeOffset 构造函数。

适用于

DateTime(DateOnly, TimeOnly)

Source:: DateTime.cs

Source:: DateTime.cs

将结构的新实例 DateTime 初始化为指定的 DateOnly 和 TimeOnly。新实例将具有类型 Unspecified 。

public:
 DateTime(DateOnly date, TimeOnly time);

public DateTime (DateOnly date, TimeOnly time);

new DateTime : DateOnly * TimeOnly -> DateTime

Public Sub New (date As DateOnly, time As TimeOnly)

参数

date: DateOnly

日期部分。

time: TimeOnly

时间部分。

适用于

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将 DateTime 结构的新实例初始化为指定日历的年、月、日、小时、分钟和秒。

public:
 DateTime(int year, int month, int day, int hour, int minute, int second, System::Globalization::Calendar ^ calendar);

public DateTime (int year, int month, int day, int hour, int minute, int second, System.Globalization.Calendar calendar);

new DateTime : int * int * int * int * int * int * System.Globalization.Calendar -> DateTime

Public Sub New (year As Integer, month As Integer, day As Integer, hour As Integer, minute As Integer, second As Integer, calendar As Calendar)

参数

year: Int32

年（1 到 calendar 中的年数）。

month: Int32

月（1 到 calendar 中的月数）。

day: Int32

日（1 到 month 中的天数）。

hour: Int32

小时（0 到 23）。

minute: Int32

分（0 到 59）。

second: Int32

秒（0 到 59）。

calendar: Calendar

用于解释 year、month 和 day 的日历。

例外

ArgumentNullException

calendar 上声明的默认值为 null。

ArgumentOutOfRangeException

year 不在 calendar 支持的范围内。

或

month 小于 1 或大于 calendar 中的月数。

或

day 小于 1 或大于 month中的天数。

或

hour 小于 0 或大于 23

或

minute 小于 0 或大于 59。

或

second 小于 0 或大于 59。

示例

以下示例调用 DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar) 构造函数两次以实例化两个 DateTime 值。第一个 DateTime 调用通过使用 PersianCalendar 对象实例化值。由于无法将波斯历指定为区域性的默认日历，因此在波斯日历中显示日期需要单独调用其 PersianCalendar.GetMonth、 PersianCalendar.GetDayOfMonth和 PersianCalendar.GetYear 方法。对构造函数的第二次DateTime HijriCalendar调用通过使用对象实例化值。该示例将当前区域性更改为阿拉伯语 (叙利亚) ，并将当前区域性的默认日历更改为回历。由于 Hijri 是当前区域性的默认日历，因此该方法 Console.WriteLine 使用它来设置日期格式。当上一个当前区域性 (（在本例中为英语 (美国) ) ）还原时，Console.WriteLine该方法使用当前区域性的默认公历来设置日期格式。

using System;
using System.Globalization;
using System.Text.RegularExpressions;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("Using the Persian Calendar:");
      PersianCalendar persian = new PersianCalendar();
      DateTime date1 = new DateTime(1389, 5, 27, 16, 32, 0, persian);
      Console.WriteLine(date1.ToString());
      Console.WriteLine("{0}/{1}/{2} {3}{6}{4:D2}{6}{5:D2}\n",
                                       persian.GetMonth(date1),
                                       persian.GetDayOfMonth(date1),
                                       persian.GetYear(date1),
                                       persian.GetHour(date1),
                                       persian.GetMinute(date1),
                                       persian.GetSecond(date1),
                                       DateTimeFormatInfo.CurrentInfo.TimeSeparator);

      Console.WriteLine("Using the Hijri Calendar:");
      // Get current culture so it can later be restored.
      CultureInfo dftCulture = Thread.CurrentThread.CurrentCulture;

      // Define Hijri calendar.
      HijriCalendar hijri = new HijriCalendar();
      // Make ar-SY the current culture and Hijri the current calendar.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("ar-SY");
      CultureInfo current = CultureInfo.CurrentCulture;
      current.DateTimeFormat.Calendar = hijri;
      string dFormat = current.DateTimeFormat.ShortDatePattern;
      // Ensure year is displayed as four digits.
      dFormat = Regex.Replace(dFormat, "/yy$", "/yyyy");
      current.DateTimeFormat.ShortDatePattern = dFormat;
      DateTime date2 = new DateTime(1431, 9, 9, 16, 32, 18, hijri);
      Console.WriteLine("{0} culture using the {1} calendar: {2:g}", current,
                        GetCalendarName(hijri), date2);

      // Restore previous culture.
      Thread.CurrentThread.CurrentCulture = dftCulture;
      Console.WriteLine("{0} culture using the {1} calendar: {2:g}",
                        CultureInfo.CurrentCulture,
                        GetCalendarName(CultureInfo.CurrentCulture.Calendar),
                        date2);
   }

   private static string GetCalendarName(Calendar cal)
   {
      return Regex.Match(cal.ToString(), "\\.(\\w+)Calendar").Groups[1].Value;
   }
}
// The example displays the following output:
//       Using the Persian Calendar:
//       8/18/2010 4:32:00 PM
//       5/27/1389 16:32:00
//
//       Using the Hijri Calendar:
//       ar-SY culture using the Hijri calendar: 09/09/1431 04:32 م
//       en-US culture using the Gregorian calendar: 8/18/2010 4:32 PM

open System
open System.Globalization
open System.Text.RegularExpressions
open System.Threading

let getCalendarName (cal: Calendar) =
    Regex.Match(string cal, "\\.(\\w+)Calendar").Groups[1].Value

printfn "Using the Persian Calendar:"
let persian = PersianCalendar()
let date1 = DateTime(1389, 5, 27, 16, 32, 0, persian)
printfn $"{date1}"
let sep = DateTimeFormatInfo.CurrentInfo.TimeSeparator
printfn $"{persian.GetMonth date1}/{persian.GetDayOfMonth date1}/{persian.GetYear date1} {persian.GetHour date1}{sep}%02i{persian.GetMinute date1}{sep}%02i{persian.GetSecond date1}\n"

printfn "Using the Hijri Calendar:"

// Get current culture so it can later be restored.
let dftCulture = Thread.CurrentThread.CurrentCulture

// Define Hijri calendar.
let hijri = HijriCalendar()

// Make ar-SY the current culture and Hijri the current calendar.
Thread.CurrentThread.CurrentCulture <- CultureInfo "ar-SY"
let current = CultureInfo.CurrentCulture
current.DateTimeFormat.Calendar <- hijri
let dFormat = 
    let dFormat = current.DateTimeFormat.ShortDatePattern
    // Ensure year is displayed as four digits.
    Regex.Replace(dFormat, "/yy$", "/yyyy")

current.DateTimeFormat.ShortDatePattern <- dFormat
let date2 = DateTime(1431, 9, 9, 16, 32, 18, hijri)
printfn $"{current} culture using the {getCalendarName hijri} calendar: {date2:g}"

// Restore previous culture.
Thread.CurrentThread.CurrentCulture <- dftCulture
printfn $"{CultureInfo.CurrentCulture} culture using the {getCalendarName CultureInfo.CurrentCulture.Calendar} calendar: {date2:g}"


// The example displays the following output:
//       Using the Persian Calendar:
//       8/18/2010 4:32:00 PM
//       5/27/1389 16:32:00
//
//       Using the Hijri Calendar:
//       ar-SY culture using the Hijri calendar: 09/09/1431 04:32 م
//       en-US culture using the Gregorian calendar: 8/18/2010 4:32 PM

Imports System.Globalization
Imports System.Text.RegularExpressions
Imports System.Threading

Module Example
   Public Sub Main()
      Console.WriteLine("Using the Persian Calendar:")
      Dim persian As New PersianCalendar()
      Dim date1 As New Date(1389, 5, 27, 16, 32, 0, persian)
      Console.WriteLine(date1.ToString())
      Console.WriteLine("{0}/{1}/{2} {3}{6}{4:D2}{6}{5:D2}", persian.GetMonth(date1), _
                                       persian.GetDayOfMonth(date1), _
                                       persian.GetYear(date1), _
                                       persian.GetHour(date1), _
                                       persian.GetMinute(date1), _
                                       persian.GetSecond(date1), _
                                       DateTimeFormatInfo.CurrentInfo.TimeSeparator)
      Console.WriteLine()
      
      Console.WriteLine("Using the Hijri Calendar:")
      ' Get current culture so it can later be restored.
      Dim dftCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
      
      ' Define Hijri calendar.
      Dim hijri As New HijriCalendar()
      ' Make ar-SY the current culture and Hijri the current calendar.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("ar-SY")
      Dim current As CultureInfo = CultureInfo.CurrentCulture
      current.DateTimeFormat.Calendar = hijri
      Dim dFormat As String = current.DateTimeFormat.ShortDatePattern
      ' Ensure year is displayed as four digits.
      dFormat = Regex.Replace(dFormat, "/yy$", "/yyyy")
      current.DateTimeFormat.ShortDatePattern = dFormat
      Dim date2 As New Date(1431, 9, 9, 16, 32, 0, hijri)
      Console.WriteLine("{0} culture using the {1} calendar: {2:g}", current, _
                        GetCalendarName(hijri), date2) 

      ' Restore previous culture.
      Thread.CurrentThread.CurrentCulture = dftCulture
      Console.WriteLine("{0} culture using the {1} calendar: {2:g}", _
                        CultureInfo.CurrentCulture, _
                        GetCalendarName(CultureInfo.CurrentCulture.Calendar), _
                        date2) 
   End Sub
   
   Private Function GetCalendarName(cal As Calendar) As String
      Return Regex.Match(cal.ToString(), "\.(\w+)Calendar").Groups(1).Value
   End Function
End Module
' The example displays the following output:
'       Using the Persian Calendar:
'       8/18/2010 4:32:00 PM
'       5/27/1389 16:32:00
'       
'       Using the Hijri Calendar:
'       ar-SY culture using the Hijri calendar: 09/09/1431 04:32 م
'       en-US culture using the Gregorian calendar: 8/18/2010 4:32 PM

注解

将 Kind 属性初始化为 Unspecified。

、和的year允许值取决于 calendar。daymonth 如果无法使用来表示 calendar指定的日期和时间，则会引发异常。

重要

命名空间 System.Globalization 提供多个日历，包括 GregorianCalendar 和 JulianCalendar。

另请参阅

适用于