DateTimeOffset.ParseExact Метод

Ссылка

Определение

Пространство имен:: System

Сборка:: System.Runtime.dll

Сборка:: mscorlib.dll

Сборка:: netstandard.dll

Важно!

Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.

Преобразует заданное строковое представление даты и времени в его эквивалент DateTimeOffset. Формат строкового представления должен полностью соответствовать заданному формату.

Перегрузки

ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Преобразует заданное строковое представление даты и времени в его эквивалент DateTimeOffset, используя заданные форматы, сведения о форматировании, связанные с языком и региональными параметрами, а также стиль. Формат строкового представления должен полностью соответствовать одному из заданных форматов.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Преобразует заданное строковое представление даты и времени в его эквивалент DateTimeOffset, используя заданный формат, указанные сведения о форматировании, связанные с языком и региональными параметрами, а также стиль. Формат строкового представления должен полностью соответствовать заданному формату.
ParseExact(String, String, IFormatProvider)	Преобразует заданное строковое представление даты и времени в его эквивалент DateTimeOffset, используя указанные сведения о форматировании, связанные с языком и региональными параметрами. Формат строкового представления должен полностью соответствовать заданному формату.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Преобразует диапазон символов, отображающий дату и время, в его эквивалент DateTimeOffset, используя заданный формат, сведения о форматировании, связанные с языком и региональными параметрами, а также стиль. Формат отображения даты и времени должен полностью соответствовать заданному формату.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Преобразует диапазон символов, содержащий строковое представление даты и времени, в его эквивалент DateTimeOffset, используя заданные форматы, сведения о форматировании, связанные с языком и региональными параметрами, а также стиль. Формат представления даты и времени должен полностью соответствовать одному из заданных форматов.

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Преобразует заданное строковое представление даты и времени в его эквивалент DateTimeOffset, используя заданные форматы, сведения о форматировании, связанные с языком и региональными параметрами, а также стиль. Формат строкового представления должен полностью соответствовать одному из заданных форматов.

public:
 static DateTimeOffset ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string[] formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles);

static member ParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Параметры

input: String

Строка, содержащая дату и время, которые нужно преобразовать.

formats: String[]

Массив спецификаторов формата, в котором заданы требуемые форматы input.

formatProvider: IFormatProvider

Объект, который предоставляет сведения о форматировании параметра input в зависимости от языка и региональных параметров.

styles: DateTimeStyles

Побитовая комбинация значений перечисления, которая показывает разрешенный формат параметра input.

Возвращаемое значение

DateTimeOffset

Объект, эквивалентный дате и времени, содержащимся в параметре input, в соответствии со значениями параметров formats, formatProvider и styles.

Исключения

ArgumentException

Смещение больше 14 часов или меньше -14 часов.

-или-

styles содержит неподдерживаемое значение.

-или-

Параметр styles содержит значения DateTimeStyles, которые нельзя использовать вместе.

ArgumentNullException

input имеет значение null.

FormatException

Параметр input является пустой строкой ("").

-или-

Параметр input не содержит допустимое строковое представление даты и времени.

-или-

В formats нет элементов, содержащих допустимые спецификаторы формата.

-или-

Компонент часов и обозначение AM/PM в input не соответствуют друг другу.

Примеры

В следующем примере определяется несколько входных форматов для строкового представления значения даты и времени и смещения, а затем передается строка, введенная пользователем в DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) метод.

TextReader conIn = Console.In;
TextWriter conOut = Console.Out;
int tries = 0;
string input = String.Empty;
string[] formats = new string[] {@"@M/dd/yyyy HH:m zzz", @"MM/dd/yyyy HH:m zzz",
                                 @"M/d/yyyy HH:m zzz", @"MM/d/yyyy HH:m zzz",
                                 @"M/dd/yy HH:m zzz", @"MM/dd/yy HH:m zzz",
                                 @"M/d/yy HH:m zzz", @"MM/d/yy HH:m zzz",
                                 @"M/dd/yyyy H:m zzz", @"MM/dd/yyyy H:m zzz",
                                 @"M/d/yyyy H:m zzz", @"MM/d/yyyy H:m zzz",
                                 @"M/dd/yy H:m zzz", @"MM/dd/yy H:m zzz",
                                 @"M/d/yy H:m zzz", @"MM/d/yy H:m zzz",
                                 @"M/dd/yyyy HH:mm zzz", @"MM/dd/yyyy HH:mm zzz",
                                 @"M/d/yyyy HH:mm zzz", @"MM/d/yyyy HH:mm zzz",
                                 @"M/dd/yy HH:mm zzz", @"MM/dd/yy HH:mm zzz",
                                 @"M/d/yy HH:mm zzz", @"MM/d/yy HH:mm zzz",
                                 @"M/dd/yyyy H:mm zzz", @"MM/dd/yyyy H:mm zzz",
                                 @"M/d/yyyy H:mm zzz", @"MM/d/yyyy H:mm zzz",
                                 @"M/dd/yy H:mm zzz", @"MM/dd/yy H:mm zzz",
                                 @"M/d/yy H:mm zzz", @"MM/d/yy H:mm zzz"};
IFormatProvider provider = CultureInfo.InvariantCulture.DateTimeFormat;
DateTimeOffset result = new DateTimeOffset();

do {
   conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),");
   conOut.Write("Then press Enter: ");
   input = conIn.ReadLine();
   conOut.WriteLine();
   try
   {
      result = DateTimeOffset.ParseExact(input, formats, provider,
                                         DateTimeStyles.AllowWhiteSpaces);
      break;
   }
   catch (FormatException)
   {
      Console.WriteLine("Unable to parse {0}.", input);
      tries++;
   }
} while (tries < 3);
if (tries >= 3)
   Console.WriteLine("Exiting application without parsing {0}", input);
else
   Console.WriteLine("{0} was converted to {1}", input, result.ToString());
// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

let input = String.Empty
let formats = 
    [| @"@M/dd/yyyy HH:m zzz"; @"MM/dd/yyyy HH:m zzz";
       @"M/d/yyyy HH:m zzz"; @"MM/d/yyyy HH:m zzz"
       @"M/dd/yy HH:m zzz"; @"MM/dd/yy HH:m zzz"
       @"M/d/yy HH:m zzz"; @"MM/d/yy HH:m zzz"
       @"M/dd/yyyy H:m zzz"; @"MM/dd/yyyy H:m zzz"
       @"M/d/yyyy H:m zzz"; @"MM/d/yyyy H:m zzz"
       @"M/dd/yy H:m zzz"; @"MM/dd/yy H:m zzz"
       @"M/d/yy H:m zzz"; @"MM/d/yy H:m zzz"
       @"M/dd/yyyy HH:mm zzz"; @"MM/dd/yyyy HH:mm zzz"
       @"M/d/yyyy HH:mm zzz"; @"MM/d/yyyy HH:mm zzz"
       @"M/dd/yy HH:mm zzz"; @"MM/dd/yy HH:mm zzz"
       @"M/d/yy HH:mm zzz"; @"MM/d/yy HH:mm zzz"
       @"M/dd/yyyy H:mm zzz"; @"MM/dd/yyyy H:mm zzz"
       @"M/d/yyyy H:mm zzz"; @"MM/d/yyyy H:mm zzz"
       @"M/dd/yy H:mm zzz"; @"MM/dd/yy H:mm zzz"
       @"M/d/yy H:mm zzz"; @"MM/d/yy H:mm zzz" |]
let provider = CultureInfo.InvariantCulture.DateTimeFormat

let mutable result = None
let mutable tries = 0
while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    let input = stdin.ReadLine()
    printfn ""
    try
        result <- 
            DateTimeOffset.ParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) 
            |> Some
    with :? FormatException ->
        printfn $"Unable to parse {input}."
        tries <- tries + 1

match result with
| Some result ->
    printfn $"{input} was converted to {result}"
| None ->
    printfn $"Exiting application without parsing {input}"

// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

 Dim conIn As TextReader = Console.In
 Dim conOut As TextWriter = Console.Out
 Dim tries As Integer = 0
 Dim input As String = String.Empty
 Dim formats() As String = {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz", _
                            "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz", _
                            "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz", _
                            "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz", _                                 
                            "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz", _
                            "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz", _
                            "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz", _
                            "M/d/yy H:m zzz", "MM/d/yy H:m zzz", _                               
                            "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz", _
                            "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz", _
                            "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz", _
                            "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz", _                                 
                            "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz", _
                            "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz", _
                            "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz", _
                            "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"}   
 Dim provider As IFormatProvider = CultureInfo.InvariantCulture.DateTimeFormat
 Dim result As DateTimeOffset

 Do 
    conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),")
    conOut.Write("Then press Enter: ")
    input = conIn.ReadLine()
    conOut.WriteLine() 
    Try
       result = DateTimeOffset.ParseExact(input, formats, provider, _
                                          DateTimeStyles.AllowWhiteSpaces)
       Exit Do
    Catch e As FormatException
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End Try
 Loop While tries < 3
 If tries >= 3 Then
    Console.WriteLine("Exiting application without parsing {0}", input)
 Else
    Console.WriteLine("{0} was converted to {1}", input, result.ToString())                                                     
 End If 
 ' Some successful sample interactions with the user might appear as follows:
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/08/2007 6:54 -6:00
 '    
 '    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00         
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/8/2007 06:54 -06:00
 '    
 '    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/5/07 6:54 -6:00
 '    
 '    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

Метод DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) анализирует строковое представление даты, которая соответствует любому из шаблонов, назначенных параметру formats . input Если строка не соответствует ни одному из этих шаблонов ни с одним из вариантов, определенных параметромstyles, метод вызывает исключение FormatException. Помимо сравнения с input несколькими шаблонами форматирования, эта перегрузка ведет себя одинаково с методом DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) .

Параметр formats представляет собой массив строк, элементы которого содержат один описатель стандартного формата или один или несколько настраиваемых описателей формата, определяющих возможный input шаблон параметра. При вызове input метода должен соответствовать одному из этих шаблонов. Дополнительные сведения о допустимых кодах форматирования см. в статье "Строки стандартного формата даты и времени " и "Настраиваемые строки формата даты и времени". Если соответствующий элемент включает описатели formats формата , zzили zzz настраиваемые описатели формата, указывающие, что смещение должно присутствовать, inputэто смещение должно включать либо отрицательный знак, либо положительный знак.z Если знак отсутствует, метод вызывает исключение FormatException.

Важно!

formats Использование параметра этой перегрузки для указания нескольких форматов может помочь уменьшить разочарование многих пользователей при вводе дат и времени. В частности, возможность определения нескольких шаблонов ввода позволяет приложению обрабатывать представления даты и времени, которые могут включать или отсутствовать начальные нули в месяцах, днях, часах, минутах и секундах. В этом примере представлена иллюстрация этого примера.

Если соответствующий элемент требует formats , чтобы input он содержал дату, но не время, результирующий DateTimeOffset объект назначается время полуночи (0:00:00). Если соответствующий элемент требует formats наличия input времени, но не даты, результирующий DateTimeOffset объект назначает текущую дату в локальной системе. Если соответствующий элемент не formats требует, чтобы input он содержал смещение, смещение результирующего DateTimeOffset объекта зависит от значения styles параметра. При styles включении AssumeLocalобъекту назначается смещение местного часового пояса DateTimeOffset . При styles включении AssumeUniversalсмещение в формате UTC или +00:00 назначается объекту DateTimeOffset . Если ни значение не указано, используется смещение местного часового пояса.

Определенные символы даты и времени, используемые в input них, определяются параметром formatProvider . То же самое справедливо для точного inputформата, если соответствующий элемент является строкой описателя стандартного formats формата. Параметр formatProvider может иметь одно из следующих значений:

Объект CultureInfo , представляющий язык и региональные параметры, основанные на интерпретации input . Объект DateTimeFormatInfo , CultureInfo.DateTimeFormat возвращаемый свойством, определяет символы и форматирование в input.
DateTimeFormatInfo Объект, определяющий формат данных даты и времени.

В противном случае formatprovider nullCultureInfo используется объект, соответствующий текущему языку и региональным параметрам.

Параметр styles определяет, разрешено ли пустое пространство во входной строке, указывает, как строки без явного компонента смещения анализируются, и поддерживает преобразование в формате UTC в рамках операции синтаксического анализа. Поддерживаются все члены DateTimeStyles перечисления, кроме NoCurrentDateDefault. В следующей таблице перечислены результаты каждого поддерживаемого элемента.

Член`DateTimeStyles`	Поведение
AdjustToUniversal	`input` Анализирует и при необходимости преобразует его в формат UTC. Он эквивалентен синтаксическому анализу строки и последующему вызову DateTimeOffset.ToUniversalTime метода возвращаемого DateTimeOffset объекта.
AssumeLocal	Если соответствующий элемент не `formats` требует, чтобы `input` оно содержало значение смещения, возвращенный DateTimeOffset объект получает смещение местного часового пояса. Это значение по умолчанию.
AssumeUniversal	Если соответствующий элемент `formats` не требует, чтобы `input` оно содержало значение смещения, возвращенный DateTimeOffset объект получает смещение UTC (+00:00).
AllowInnerWhite	Позволяет `input` включать внутреннее пробелы, не указанные в параметре `format`. Дополнительное пустое пространство может отображаться между компонентами даты и времени и отдельными компонентами (за исключением смещения) и игнорируется при анализе строки.
AllowLeadingWhite	Позволяет `input` включать ведущие пробелы, не указанные в параметре `formats`. Они игнорируются при синтаксическом анализе строки.
AllowTrailingWhite	Позволяет `input` включать конечные пробелы, не указанные в параметре `formats`. Они игнорируются при синтаксическом анализе строки.
AllowWhiteSpaces	Позволяет `input` включать начальные, конечные и внутренние пространства, не указанные в параметре `formats`. Все лишние пробелы, не указанные в сопоставленном элементе, `formats` игнорируются при синтаксическом анализе строки.
None	Указывает, что дополнительное пробел не разрешено в `input`. Пробел должен отображаться точно так же, как указано в определенном элементе совпадения `formats` . Это поведение по умолчанию.
RoundtripKind	Не влияет, так как DateTimeOffset структура не включает `Kind` свойство.

Примечания для тех, кто вызывает этот метод

В платформа .NET Framework 4 метод создает FormatException исключение, ParseExact если анализируемая строка содержит компонент часа и конструктор AM/PM, которые не находятся в согласии. В платформа .NET Framework 3.5 и более ранних версиях конструктор AM/PM игнорируется.

См. также раздел

Применяется к

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Преобразует заданное строковое представление даты и времени в его эквивалент DateTimeOffset, используя заданный формат, указанные сведения о форматировании, связанные с языком и региональными параметрами, а также стиль. Формат строкового представления должен полностью соответствовать заданному формату.

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles);

static member ParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Параметры

input: String

Строка, содержащая дату и время, которые нужно преобразовать.

format: String

Описатель формата, задающий ожидаемый формат input.

formatProvider: IFormatProvider

styles: DateTimeStyles

Побитовая комбинация значений перечисления, которая показывает разрешенный формат параметра input.

Возвращаемое значение

DateTimeOffset

Объект, эквивалентный дате и времени, содержащимся в параметре input, в соответствии со значениями параметров format, formatProvider и styles.

Исключения

ArgumentException

Смещение больше 14 часов или меньше -14 часов.

-или-

Параметр styles содержит неподдерживаемое значение.

-или-

Параметр styles содержит значения DateTimeStyles, которые нельзя использовать вместе.

ArgumentNullException

input имеет значение null.

-или-

format имеет значение null.

FormatException

Параметр input является пустой строкой ("").

-или-

Параметр input не содержит допустимое строковое представление даты и времени.

-или-

Параметр format равен пустой строке.

-или-

Компонент часов и обозначение AM/PM в input не соответствуют друг другу.

Примеры

В следующем примере метод используется DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) с описателями стандартного и настраиваемого формата, инвариантными языком и региональными параметрами и различными DateTimeStyles значениями для анализа нескольких строк даты и времени.

string dateString, format;
DateTimeOffset result;
CultureInfo provider = CultureInfo.InvariantCulture;

// Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008";
format = "d";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AssumeUniversal);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("'{0}' is not in the correct format.", dateString);
}

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowTrailingWhite);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("'{0}' is not in the correct format.", dateString);
}

// Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00";
format = "MM/dd/yyyy H:mm zzz";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("'{0}' is not in the correct format.", dateString);
}

// Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00";
format = "MM/dd/yyyy H:mm:ss zzz";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces |
                                      DateTimeStyles.AdjustToUniversal);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("'{0}' is not in the correct format.", dateString);
}
// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture and assume time is UTC.
let dateString = "06/15/2008"
let format = "d"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time value, and allow all white space.
let dateString = " 06/15/   2008  15:15    -05:00"
let format = "MM/dd/yyyy H:mm zzz"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time and convert to UTC.
let dateString = "  06/15/2008 15:15:30 -05:00"
let format = "MM/dd/yyyy H:mm:ss zzz"
try
    let result = 
        DateTimeOffset.ParseExact(dateString, format, provider,
                                  DateTimeStyles.AllowWhiteSpaces |||
                                  DateTimeStyles.AdjustToUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    printfn $"'{dateString}' is not in the correct format."

// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

Dim dateString, format As String  
Dim result As DateTimeOffset
Dim provider As CultureInfo = CultureInfo.InvariantCulture

' Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008"
format = "d"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AssumeUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' Parse date-only value with leading white space.
' Should throw a FormatException because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowTrailingWhite)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00"
format = "MM/dd/yyyy H:mm zzz"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00"   
format = "MM/dd/yyyy H:mm:ss zzz"       
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces Or _
                                      DateTimeStyles.AdjustToUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 
' The example displays the following output:
'    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
'    ' 06/15/2008' is not in the correct format.
'    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
'    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

В следующем примере для синтаксического анализа массива DateTimeStyles строк, которые должны соответствовать стандарту ISO 8601, используется множество значений. Как показано в выходных данных примера, строки, которые находятся в правильном формате, не могут анализироваться, если:

Они содержат пробелы и соответствующий DateTimeStyles флаг (например DateTimeStyles.AllowWhiteSpaces , не был указан в вызове метода.
Они содержат элементы даты и времени, которые находятся вне диапазона.

Предполагается, что строки, не указывающие смещение в формате UTC, имеют смещение местного часового пояса (в данном случае –07:00), если DateTimeStyles.AssumeUniversal флаг не указан в вызове метода. В этом случае предполагается, что они являются универсальным скоординированным временем.

module parseexact_iso8601_2

open System
open System.Globalization

let dateStrings = 
    [| "2018-08-18T12:45:16.0000000Z"
       "2018/08/18T12:45:16.0000000Z"
       "2018-18-08T12:45:16.0000000Z"
       "2018-08-18T12:45:16.0000000"                               
       " 2018-08-18T12:45:16.0000000Z "
       "2018-08-18T12:45:16.0000000+02:00"
       "2018-08-18T12:45:16.0000000-07:00" |] 

let parseWithISO8601 dateStrings styles =
    printfn $"Parsing with {styles}:"
    for dateString in dateStrings do
        try
            let date = DateTimeOffset.ParseExact(dateString, "O", null, styles)
            printfn $"""   {dateString,-35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
        with :? FormatException ->
            printfn $"   FormatException: Unable to convert '{dateString}'"

parseWithISO8601 dateStrings DateTimeStyles.None
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AllowWhiteSpaces
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AdjustToUniversal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeLocal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeUniversal


// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = { "2018-08-18T12:45:16.0000000Z",
                               "2018/08/18T12:45:16.0000000Z",
                               "2018-18-08T12:45:16.0000000Z",
                               "2018-08-18T12:45:16.0000000",                               
                               " 2018-08-18T12:45:16.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal);   }

   private static void ParseWithISO8601(string[] dateStrings, DateTimeStyles styles)
   {   
      Console.WriteLine($"Parsing with {styles}:");
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null, styles);
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"   FormatException: Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim dateStrings() = { "2018-08-18T12:45:16.0000000Z",
                            "2018/08/18T12:45:16.0000000Z",
                            "2018-18-08T12:45:16.0000000Z",
                            "2018-08-18T12:45:16.0000000",                               
                            " 2018-08-18T12:45:16.0000000Z ",
                            "2018-08-18T12:45:16.0000000+02:00",
                            "2018-08-18T12:45:16.0000000-07:00" } 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal)   
   End Sub

   Private Sub ParseWithISO8601(dateStrings() As String, styles As DateTimeStyles)
      Console.WriteLine($"Parsing with {styles}:")
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateString, "O", Nothing, styles)
            Console.WriteLine($"   {dateString,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         catch e As FormatException
            Console.WriteLine($"   FormatException: Unable to convert '{dateString}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeLocal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'

Метод DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) анализирует строковое представление даты, которая должна быть в формате, определенном параметром format . Кроме того, требуется, чтобы <Date><Time>элементы строкового <Offset> представления даты и времени отображались в порядке, указанном в параметре format. input Если строка не соответствует шаблону format параметра, с любыми вариациями, определенными параметромstyles, метод вызывает исключение FormatException. Напротив, метод анализирует строковое представление даты в любом из форматов, DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) распознаваемых объектом поставщика DateTimeFormatInfo формата. Parseтакже позволяет <Date><Time>отображать значения даты и времени в любом порядке и <Offset> элементы строкового представления даты и времени.

Параметр format — это строка, содержащая либо один описатель стандартного формата, либо один или несколько настраиваемых описателей формата, определяющих требуемый input шаблон параметра. Дополнительные сведения о допустимых кодах форматирования см. в статье "Строки стандартного формата даты и времени " и "Настраиваемые строки формата даты и времени". Если format включены zописатели формата , zzили zzz настраиваемые описатели формата, указывающие, что смещение должно присутствовать, inputэто смещение должно включать либо отрицательный знак, либо положительный знак. Если знак отсутствует, метод вызывает исключение FormatException.

Если format требуется, чтобы input она содержала дату, но не время, результирующий DateTimeOffset объект назначается время полуночи (0:00:00). Если format требуется, чтобы input она содержала время, но не дату, результирующий DateTimeOffset объект назначается текущей дате в локальной системе. Если format не требуется, чтобы input оно содержало смещение, смещение результирующего DateTimeOffset объекта зависит от значения styles параметра. При styles включении AssumeLocalобъекту назначается смещение местного часового пояса DateTimeOffset . При styles включении AssumeUniversalсмещение в формате UTC или +00:00 назначается объекту DateTimeOffset . Если ни значение не указано, используется смещение местного часового пояса.

Определенные символы даты и времени, используемые в input них, определяются параметром formatProvider . То же самое справедливо для точного формата , если format является строкой описателя стандартного inputформата. Параметр formatProvider может иметь одно из следующих значений:

Объект CultureInfo , представляющий язык и региональные параметры, основанные на интерпретации input . Объект DateTimeFormatInfo , CultureInfo.DateTimeFormat возвращаемый свойством, определяет символы и форматирование в input.
DateTimeFormatInfo Объект, определяющий формат данных даты и времени.

Параметр styles определяет, разрешено ли пробелы во входной строке, указывает, как строки без явного компонента смещения анализируются, и поддерживает преобразование в формате UTC в рамках операции синтаксического анализа. Поддерживаются все члены DateTimeStyles перечисления, кроме NoCurrentDateDefault. В следующей таблице перечислены результаты каждого поддерживаемого элемента.

Член`DateTimeStyles`	Поведение
AdjustToUniversal	`input` Анализирует и при необходимости преобразует его в формат UTC. Он эквивалентен синтаксическому анализу строки и последующему вызову DateTimeOffset.ToUniversalTime метода возвращаемого DateTimeOffset объекта.
AssumeLocal	Если `format` значение смещения не требуется `input` , возвращенный DateTimeOffset объект получает смещение местного часового пояса. Это значение по умолчанию.
AssumeUniversal	Если `format` не требуется, что `input` содержит значение смещения, возвращенный DateTimeOffset объект получает смещение UTC (+00:00).
AllowInnerWhite	Позволяет `input` включать внутреннее пробелы, не указанные в параметре `format`. Дополнительное пробелы могут отображаться между компонентами даты и времени и внутри отдельных компонентов и игнорируются при анализе строки.
AllowLeadingWhite	Позволяет `input` включать ведущие пробелы, не указанные в параметре `format`. Они игнорируются при синтаксическом анализе строки.
AllowTrailingWhite	Позволяет `input` включать конечные пробелы, не указанные в параметре `format`. Они игнорируются при синтаксическом анализе строки.
AllowWhiteSpaces	Позволяет `input` включать начальные, конечные и внутренние пространства, не указанные в параметре `format`. При синтаксическом анализе строки игнорируются все лишние символы пробелов, не указанные в `format` ней.
None	Указывает, что дополнительное пробел не разрешено в `input`. Пробел должен отображаться точно так же, как указано в .`format` Это поведение по умолчанию.
RoundtripKind	Не влияет, так как DateTimeOffset структура не включает `Kind` свойство.

Примечания для тех, кто вызывает этот метод

См. также раздел

Применяется к

ParseExact(String, String, IFormatProvider)

Преобразует заданное строковое представление даты и времени в его эквивалент DateTimeOffset, используя указанные сведения о форматировании, связанные с языком и региональными параметрами. Формат строкового представления должен полностью соответствовать заданному формату.

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider formatProvider);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider? formatProvider);

static member ParseExact : string * string * IFormatProvider -> DateTimeOffset

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider) As DateTimeOffset

Параметры

input: String

Строка, содержащая дату и время, которые нужно преобразовать.

format: String

Описатель формата, задающий ожидаемый формат input.

formatProvider: IFormatProvider

Возвращаемое значение

DateTimeOffset

Объект, эквивалентный дате и времени, содержащимся в параметре input, в соответствии со значениями параметров format и formatProvider.

Исключения

ArgumentException

Смещение больше 14 часов или меньше -14 часов.

ArgumentNullException

input имеет значение null.

-или-

format имеет значение null.

FormatException

Параметр input является пустой строкой ("").

-или-

Параметр input не содержит допустимое строковое представление даты и времени.

-или-

Параметр format равен пустой строке.

-или-

Компонент часов и обозначение AM/PM в input не соответствуют друг другу.

Примеры

В следующем примере метод используется DateTimeOffset.ParseExact(String, String, IFormatProvider) с описателями стандартного и настраиваемого формата и инвариантным языком и региональными параметрами для анализа нескольких строк даты и времени.

string dateString, format;
DateTimeOffset result;
CultureInfo provider = CultureInfo.InvariantCulture;

// Parse date-only value with invariant culture.
dateString = "06/15/2008";
format = "d";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
dateString = "6/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
format = "ddd dd MMM yyyy h:mm tt zzz";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}
// The example displays the following output:
//    06/15/2008 converts to 6/15/2008 12:00:00 AM -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture.
let dateString = "06/15/2008"
let format = "d"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
let dateString = "6/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with custom specifier.
let dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
let format = "ddd dd MMM yyyy h:mm tt zzz"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
let dateString = "Sun 15 Jun 2008 8:30 AM -06"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// The example displays the following output:
//    06/15/2008 converts to 6/15/2008 12:00:00 AM -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

Dim dateString, format As String  
Dim result As DateTimeOffset
Dim provider As CultureInfo = CultureInfo.InvariantCulture

' Parse date-only value with invariant culture.
dateString = "06/15/2008"
format = "d"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date-only value without leading zero in month using "d" format.
' Should throw a FormatException because standard short date pattern of 
' invariant culture requires two-digit month.
dateString = "6/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
format = "ddd dd MMM yyyy h:mm tt zzz"        
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with offset without offset's minutes.
' Should throw a FormatException because "zzz" specifier requires leading  
' zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 
' The example displays the following output:
'    06/15/2008 converts to 6/15/2008 12:00:00 AM -07:00.
'    6/15/2008 is not in the correct format.
'    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
'    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

В следующем примере анализируется массив строк, которые должны соответствовать стандарту ISO 8601. Как показано в выходных данных примера, строки с начальными или конечными пробелами не удалось успешно проанализировать, как и строки с элементами даты и времени, которые находятся вне диапазона.

module parseexact_iso8601

open System

let dateStrings =
    [ "2018-08-18T12:45:16.0000000Z"
      "2018/08/18T12:45:16.0000000Z"
      "2018-18-08T12:45:16.0000000Z"
      " 2018-08-18T12:45:16.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

for dateString in dateStrings do
    try
        let date =
            DateTimeOffset.ParseExact(dateString, "O", null)

        printfn $"""{dateString, -35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
    with :? FormatException -> printfn $"FormatException: Unable to convert '{dateString}'"


// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//      2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//      2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

using System;

public class Example2
{
   public static void Main()
   {
      string[] dateStrings = { "2018-08-18T12:45:16.0000000Z",
                               "2018/08/18T12:45:16.0000000Z",
                               "2018-18-08T12:45:16.0000000Z",
                               " 2018-08-18T12:45:16.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null);
            Console.WriteLine($"{dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"FormatException: Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//      2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//      2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Public Module Example
   Public Sub Main()
      Dim dateStrings() As String = { "2018-08-18T12:45:16.0000000Z",
                                      "2018/08/18T12:45:16.0000000Z",
                                      "2018-18-08T12:45:16.0000000Z",
                                      " 2018-08-18T12:45:16.0000000Z ",
                                      "2018-08-18T12:45:16.0000000+02:00",
                                      "2018-08-18T12:45:16.0000000-07:00" } 
      
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateStr, "O", Nothing)
            Console.WriteLine($"{dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Catch  e As FormatException
            Console.WriteLine($"FormatException: Unable to convert '{dateStr}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
'      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
'      FormatException: Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'      2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'      2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Метод ParseExact(String, String, IFormatProvider) анализирует строковое представление даты, которая должна быть в формате, определенном параметром format . Кроме того, требуется, чтобы <Date><Time>элементы строкового <Offset> представления даты и времени отображались в порядке, указанном в параметре format. input Если строка не соответствует этому format параметру, метод вызывает исключение FormatException. Напротив, метод анализирует строковое представление даты в любом из форматов, DateTimeOffset.Parse(String, IFormatProvider) распознаваемых объектом поставщика DateTimeFormatInfo формата. Parseтакже позволяет <Date><Time>элементам строкового <Offset> представления даты и времени отображаться в любом порядке.

Параметр format представляет собой строку, содержащую один описатель стандартного input формата или один или несколько настраиваемых описателей формата, которые определяют требуемый формат параметра. Дополнительные сведения о допустимых кодах форматирования см. в разделе " Стандартные строки формата даты и времени " и "Настраиваемые строки формата даты и времени". Если format включает zописатели формата , zzили настраиваемые описатели формата, указывающие, что смещение должно присутствовать в input, это смещение должно включать либо отрицательный знак, либо zzz положительный знак. Если знак отсутствует, метод вызывает исключение FormatException.

Определенные символы даты и времени и строки, используемые в input параметре, определяются точным formatProvider форматом, если format является строкой описателя стандартного input формата. Параметр formatProvider может иметь один из следующих значений:

Объект CultureInfo , представляющий язык и региональные параметры, основанные на интерпретации input . Объект, DateTimeFormatInfo возвращаемый его DateTimeFormat свойством, определяет символы и форматирование в input.
Объект DateTimeFormatInfo , определяющий формат данных даты и времени.

Если formatprovider это nullтак, используется объект, CultureInfo соответствующий текущему языку и региональным параметрам.

Примечания для тех, кто вызывает этот метод

В платформа .NET Framework 4 метод создает исключениеFormatException, если строка для ParseExact синтаксического анализа содержит компонент часа и конструктор AM/PM, которые не находятся в согласии. В платформа .NET Framework 3.5 и более ранних версиях конструктор AM/PM игнорируется.

См. также раздел

Применяется к

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Преобразует диапазон символов, отображающий дату и время, в его эквивалент DateTimeOffset, используя заданный формат, сведения о форматировании, связанные с языком и региональными параметрами, а также стиль. Формат отображения даты и времени должен полностью соответствовать заданному формату.

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Параметры

input: ReadOnlySpan<Char>

Диапазон символов, отображающий дату и время.

format: ReadOnlySpan<Char>

Диапазон символов, содержащий спецификатор формата, который задает ожидаемый формат параметра input.

formatProvider: IFormatProvider

Объект, предоставляющий сведения о форматировании параметра input в зависимости от языка и региональных параметров.

styles: DateTimeStyles

Побитовая комбинация значений перечисления, которая показывает разрешенный формат параметра input.

Возвращаемое значение

DateTimeOffset

Исключения

ArgumentException

Смещение больше 14 часов или меньше -14 часов. -или- Параметр styles содержит неподдерживаемое значение. -или- Параметр styles содержит DateTimeStyles значения, которые нельзя использовать вместе.

FormatException

Параметр input — это пустой диапазон символов. -или- Параметр input не содержит допустимое строковое представление даты и времени. -или- Параметрformat — это пустой диапазон символов. -или- Компонент часа и конструктор input AM/PM не согласуются.

Этот метод анализирует диапазон символов, представляющий дату, которая должна быть в формате, определенном параметром format . Для этого также требуется, чтобы <Date><Time><Offset> элементы строкового представления даты и времени отображались в порядке, указанном в параметре format. Если input шаблон не соответствует format , метод вызывает исключение FormatException. Напротив, метод анализирует строковое представление даты в любом из форматов, DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) распознаваемых объектом поставщика DateTimeFormatInfo формата. Parseтакже позволяет <Date><Time>элементам строкового <Offset> представления даты и времени отображаться в любом порядке.

Параметр format представляет собой диапазон символов, содержащий описатель стандартного формата с одним символом или один или несколько настраиваемых описателей формата, которые определяют требуемый формат input параметра. Дополнительные сведения о допустимых кодах форматирования см. в разделе " Стандартные строки формата даты и времени " и "Настраиваемые строки формата даты и времени". Если format включает zописатели формата , zzили настраиваемые описатели формата, указывающие, что смещение должно присутствовать в input, это смещение должно включать либо отрицательный знак, либо zzz положительный знак. Если знак отсутствует, метод вызывает исключение FormatException.

Определенные символы даты и времени и строки, используемые в input параметре, определяются formatProvider точным форматом, если format является описательом стандартного input формата. Параметр formatProvider может иметь один из следующих значений:

Объект CultureInfo , представляющий язык и региональные параметры, основанные на интерпретации input . Объект, DateTimeFormatInfo возвращаемый его DateTimeFormat свойством, определяет символы и форматирование в input.
Объект DateTimeFormatInfo , определяющий формат данных даты и времени.

Применяется к

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)

Преобразует диапазон символов, содержащий строковое представление даты и времени, в его эквивалент DateTimeOffset, используя заданные форматы, сведения о форматировании, связанные с языком и региональными параметрами, а также стиль. Формат представления даты и времени должен полностью соответствовать одному из заданных форматов.

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Параметры

input: ReadOnlySpan<Char>

Диапазон символов, содержащий дату и время, которые нужно преобразовать.

formats: String[]

Массив спецификаторов формата, в котором заданы требуемые форматы input.

formatProvider: IFormatProvider

styles: DateTimeStyles

Побитовая комбинация значений перечисления, которая показывает разрешенный формат параметра input.

Возвращаемое значение

DateTimeOffset

Исключения

ArgumentException

FormatException

Параметр input — это пустой диапазон символов. -или- Параметр input не содержит допустимое строковое представление даты и времени. -или- Нет элемента formats , содержащего допустимый описатель формата. -или- Компонент часов и конструктор input AM/PM не согласны.

Этот метод анализирует диапазон символов, представляющий дату, соответствующую любому из шаблонов, назначенных параметру formats . Если input ни один из этих шаблонов не соответствует ни одному из вариантов, определенных параметром styles , метод вызывает исключение FormatException. Помимо сравнения input с несколькими шаблонами форматирования, эта перегрузка ведет себя одинаково с методом DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) .

Параметр formats представляет собой массив строк, элементы которого содержат один описатель стандартного формата или один или несколько настраиваемых описателей формата, которые определяют возможный шаблон input параметра. При вызове input метода должен соответствовать одному из этих шаблонов. Дополнительные сведения о допустимых кодах форматирования см. в разделе " Стандартные строки формата даты и времени " и "Настраиваемые строки формата даты и времени". Если соответствующий элемент включает formats в себя zz``zили настраиваемые описатели формата, указывающие на то, что смещение должно присутствовать, inputэто смещение должно включать либо отрицательный знак, либо zzz положительный знак. Если знак отсутствует, метод вызывает исключение FormatException.

Важно!

formats Использование параметра этой перегрузки для указания нескольких форматов может помочь уменьшить разочарование многих пользователей при вводе дат и времени. В частности, возможность определения нескольких шаблонов ввода позволяет приложению обрабатывать представления даты и времени, которые могут включать или не содержать начальные нули в месяцах, днях, часах, минутах и секундах.

Если соответствующий элемент требует formats input наличия даты, но не времени, результирующий DateTimeOffset объект назначается время полуночи (0:00:00). Если соответствующий элемент требует formats input наличия времени, но не даты, результирующий DateTimeOffset объект назначает текущую дату в локальной системе. Если соответствующий элемент не formats требует input смещения, смещение результирующего DateTimeOffset объекта зависит от значения styles параметра. Если styles этот параметр включен AssumeLocal, то для объекта назначается смещение локального часового пояса DateTimeOffset . Если styles этот параметр включен AssumeUniversal, то для объекта назначается DateTimeOffset смещение utc или +00:00. Если ни значение не указано, используется смещение локального часового пояса.

Определенные символы даты и времени и строки, используемые в input параметре formatProvider . То же самое верно для точного inputформата, если соответствующий элемент является строкой описателя стандартного formats формата. Параметр formatProvider может иметь один из следующих значений:

Объект CultureInfo , представляющий язык и региональные параметры, основанные на интерпретации input . Объект, DateTimeFormatInfo возвращаемый свойством CultureInfo.DateTimeFormat , определяет символы и форматирование в input.
Объект DateTimeFormatInfo , определяющий формат данных даты и времени.

Параметр styles определяет, разрешено ли пробел в входной строке, указывает, как строки без явного компонента смещения анализируются, и поддерживает преобразование в формате UTC в рамках операции синтаксического анализа. Поддерживаются все члены перечисления DateTimeStyles , кроме NoCurrentDateDefault. В следующей таблице перечислены эффекты каждого поддерживаемого элемента.

Член`DateTimeStyles`	Поведение
AdjustToUniversal	`input` Анализирует и при необходимости преобразует его в формат UTC. Он эквивалентен синтаксическому анализу строки и последующему вызову DateTimeOffset.ToUniversalTime метода возвращаемого DateTimeOffset объекта.
AssumeLocal	Если соответствующий элемент не `formats` требует, чтобы `input` оно содержало значение смещения, возвращенный DateTimeOffset объект получает смещение местного часового пояса. Это значение по умолчанию.
AssumeUniversal	Если соответствующий элемент `formats` не требует, чтобы `input` оно содержало значение смещения, возвращенный DateTimeOffset объект получает смещение UTC (+00:00).
AllowInnerWhite	Позволяет `input` включать внутреннее пробелы, не указанные в параметре `format`. Дополнительное пустое пространство может отображаться между компонентами даты и времени и отдельными компонентами (за исключением смещения) и игнорируется при анализе строки.
AllowLeadingWhite	Позволяет `input` включать ведущие пробелы, не указанные в параметре `formats`. Они игнорируются при синтаксическом анализе строки.
AllowTrailingWhite	Позволяет `input` включать конечные пробелы, не указанные в параметре `formats`. Они игнорируются при синтаксическом анализе строки.
AllowWhiteSpaces	Позволяет `input` включать начальные, конечные и внутренние пространства, не указанные в параметре `formats`. Все лишние пробелы, не указанные в сопоставленном элементе, `formats` игнорируются при синтаксическом анализе строки.
None	Указывает, что дополнительное пробел не разрешено в `input`. Пробел должен отображаться точно так же, как указано в определенном элементе совпадения `formats` . Это поведение по умолчанию.
RoundtripKind	Не влияет, так как DateTimeOffset структура не включает `Kind` свойство.

Применяется к

DateTimeOffset.ParseExact Метод

Определение

Перегрузки

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Параметры

Возвращаемое значение

Исключения

Примеры

Комментарии

Примечания для тех, кто вызывает этот метод

См. также раздел

Применяется к

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Параметры

Возвращаемое значение

Исключения

Примеры

Комментарии

Примечания для тех, кто вызывает этот метод

См. также раздел

Применяется к

ParseExact(String, String, IFormatProvider)

Параметры

Возвращаемое значение

Исключения

Примеры

Комментарии

Примечания для тех, кто вызывает этот метод

См. также раздел

Применяется к

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Параметры

Возвращаемое значение

Исключения

Комментарии

Применяется к

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)

Параметры

Возвращаемое значение

Исключения

Комментарии

Применяется к

Дополнительные ресурсы