Как я могу вручную проанализировать пользовательский формат DateTime с необязательными полями в C #

Question

Допустим, у меня есть следующие даты / время в каком-то собственном, почти ISO-подобном формате:

• "2011-11-07T11:17"
• "--T11:17" (11:17 утра, без даты, только время)
• "-11-07" (7 ноября, без года, без времени)

Разделители являются обязательными, и я должен знать, что данныенастоящее или нет.Данные будут установлены в такую ​​структуру, как:

struct MyDate
{
    int? Year ;
    int? Month ;
    int? Day ;
    int? Hour ;
    int? Minute ;
}

Самый простой способ - зацикливать символ за символом и извлекать данные, если они есть.

Но у меня есть нытьеСоздается впечатление, что должен быть какой-то API для извлечения, например, целого числа и возврата индекса первого нецелого символа (аналогично C strtol).

Есть ли strtol -подобная функция в C # или что-то более высокоуровневое для извлечения типизированных данных вместо анализа строки за символом?

Answer 1

Я бы сказал так:

РЕДАКТИРОВАТЬ 2

Теперь включено:

• статические Parse и TryParse методы в структуре MyDate:)
• ToString () для легкого тестирования
• минимальные юнит тест-кейсы
• Демонстрация БОНУСА: оператор неявного преобразования из строки в MyDate (чтобы вы могли передать строку, где требуется MyDate)

Опять же, смотрите его в прямом эфире http://ideone.com/rukw4

using System;
using System.Text;
using System.Text.RegularExpressions;

struct MyDate 
{ 
    public int? Year, Month, Day, Hour, Minute; 

    private static readonly Regex dtRegex = new Regex(
        @"^(?<year>\d{4})?-(?<month>\d\d)?-(?<day>\d\d)?"
    +   @"(?:T(?<hour>\d\d)?:(?<minute>\d\d)?)?$",
        RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);

    public static bool TryParse(string input, out MyDate result)
    {
        Match match = dtRegex.Match(input);
        result = default(MyDate);

        if (match.Success)
        {
            if (match.Groups["year"].Success)
                result.Year = Int32.Parse(match.Groups["year"].Value);
            if (match.Groups["month"].Success)
                result.Month = Int32.Parse(match.Groups["month"].Value);
            if (match.Groups["day"].Success)
                result.Day = Int32.Parse(match.Groups["day"].Value);
            if (match.Groups["hour"].Success)
                result.Hour = Int32.Parse(match.Groups["hour"].Value);
            if (match.Groups["minute"].Success)
                result.Minute = Int32.Parse(match.Groups["minute"].Value);
        }

        return match.Success;
    }

    public static MyDate Parse(string input)
    {
        MyDate result;
        if (!TryParse(input, out result))
            throw new ArgumentException(string.Format("Unable to parse MyDate: '{0}'", input));

        return result;
    }

    public override string ToString()
    {
        return string.Format("{0:0000}-{1:00}-{2:00}T{3:00}:{4:00}", Year, Month, Day, Hour, Minute);
    }

    public static implicit operator MyDate(string input)
    {
        return Parse(input);
    }
}

class Program
{
    static void Main(string[] args)
    {
        foreach (var testcase in new [] { 
                "2011-11-07T11:17",
                "-11-07T11:17",
                "2011--07T11:17",
                "2011-11-T11:17",
                "2011-11-07T:17",
                "2011-11-07T11:",
                // extra:
                "--T11:17", // (11:17 am, no date, only time)
                "-11-07", // (november the 7th, no year, no time)
                // failures:
                "2011/11/07 T 11:17",
                "no match" })
        {
            MyDate parsed;
            if (MyDate.TryParse(testcase, out parsed))
                Console.WriteLine("'{0}' -> Parsed into '{1}'", testcase, parsed);
            else
                Console.WriteLine("'{0}' -> Parse failure", testcase);
        }
    }
}

Выход:

'2011-11-07T11:17' -> Parsed into '2011-11-07T11:17'
'-11-07T11:17' -> Parsed into '-11-07T11:17'
'2011--07T11:17' -> Parsed into '2011--07T11:17'
'2011-11-T11:17' -> Parsed into '2011-11-T11:17'
'2011-11-07T:17' -> Parsed into '2011-11-07T:17'
'2011-11-07T11:' -> Parsed into '2011-11-07T11:'
'--T11:17' -> Parsed into '--T11:17'
'-11-07' -> Parsed into '-11-07T:'
'2011/11/07 T 11:17' -> Parse failure
'no match' -> Parse failure

Answer 2

Если производительность не имеет значения, я бы использовал Регулярные выражения для вашей задачи.

Используйте (\d*)-(\d*)-(\d*)T(\d*):(\d*) в качестве выражения, а затем проанализируйте каждую группу захвата в соответствующее поле вашей структуры, преобразовав пустые строки в null значения:

var match = Regex.Match(str, @"(\d*)-(\d*)-(\d*)T(\d*):(\d*)");
var date = new MyDate();

if (match.Groups[1].Value != "") date.Year = int.Parse(match.Groups[1].Value);
if (match.Groups[2].Value != "") date.Month = int.Parse(match.Groups[2].Value);
if (match.Groups[3].Value != "") date.Day = int.Parse(match.Groups[3].Value);
if (match.Groups[4].Value != "") date.Hour = int.Parse(match.Groups[4].Value);
if (match.Groups[5].Value != "") date.Minute = int.Parse(match.Groups[5].Value);

EDIT: Разделители 'T' и ':' являются обязательными в этом коде. Если вы хотите иначе, обратитесь к ответу @sehe.

Answer 3

Вы можете использовать DateTime.ParseExact.Проверьте документацию здесь

Answer 4

Если вы знаете формат даты, который вы можете использовать, например, DateTime.ParseExact ... если вам нужно что-то похожее на strtol, вы можете использовать Convert.ToInt32.