Как преобразовать Unix timestamp в DateTime и наоборот в C#?

Question

Я работаю над реализацией преобразования timestamp, но столкнулся с проблемами с точностью до миллисекунд и наносекунд. Вот моя текущая реализация:

```csharp
public Double CreatedEpoch
{
  get
  {
    DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0).ToLocalTime();
    TimeSpan span = (this.Created.ToLocalTime() - epoch);
    return span.TotalSeconds;
  }
  set
  {
    DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0).ToLocalTime();
    this.Created = epoch.AddSeconds(value);
  }
}
```

Каковы лучшие практики для преобразования Unix timestamp в C#, особенно в отношении точности и обработки часовых поясов?

НейроОтветы · Accepted Answer

Преобразование Unix timestamp в объекты DateTime в C# является простым с использованием встроенных методов .NET, но требует внимания к точности и обработке часовых поясов. Рекомендуемый подход использует `DateTimeOffset.FromUnixTimeSeconds()` и `DateTimeOffset.FromUnixTimeMilliseconds()` для преобразований на основе UTC, с тщательным учетом `DateTimeKind` для избежания ошибок, связанных с часовыми поясами.

## Содержание
- [Базовые методы преобразования](#базовые-методы-преобразования)
- [Обработка точности timestamp](#обработка-точности-timestamp)
- [Лучшие практики обработки часовых поясов](#лучшие-практики-обработки-часовых-поясов)
- [Распространенные проблемы и решения](#распространенные-проблемы-и-решения)
- [Полный пример реализации](#полный-пример-реализации)

## Базовые методы преобразования {#базовые-методы-преобразования}

.NET предоставляет встроенные методы для преобразования Unix timestamp, которые должны быть вашим первым выбором. Эти методы автоматически вычисляют эпоху и работают с временем UTC.

### Из Unix timestamp в DateTime

```csharp
// Использование DateTimeOffset (рекомендуемый подход)
DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1609459200); // 1 января 2021 UTC
DateTime dateTime = dateTimeOffset.DateTime;

// Для точности до миллисекунд
DateTimeOffset dateTimeOffsetMs = DateTimeOffset.FromUnixTimeMilliseconds(1609459200000);
DateTime dateTimeMs = dateTimeOffsetMs.DateTime;

// Использование DateTime напрямую с ручным расчетом эпохи
DateTime unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
DateTime dateTimeManual = unixEpoch.AddSeconds(1609459200);
```

Обсуждение на [Stack Overflow](https://*.stackoverflow.com/questions/249760/how-can-i-convert-a-unix-timestamp-to-datetime-and-vice-versa) подтверждает, что эти встроенные методы являются предпочтительным подходом в современных приложениях .NET.

### Из DateTime в Unix timestamp

```csharp
// Использование DateTimeOffset (рекомендуется)
DateTimeOffset dto = new DateTimeOffset(DateTime.UtcNow);
long unixTimeSeconds = dto.ToUnixTimeSeconds();
long unixTimeMilliseconds = dto.ToUnixTimeMilliseconds();

// Ручной расчет
DateTime unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
DateTime now = DateTime.UtcNow;
long unixTime = (long)(now - unixEpoch).TotalSeconds;
```

Блог [Brian Pedersen's Blog](https://*.briancaos.wordpress.com/2022/02/24/c-datetime-to-unix-timestamps/) демонстрирует эти шаблоны преобразования в практических сценариях.

---

## Обработка точности timestamp {#обработка-точности-timestamp}

Unix timestamp могут выражаться в разных единицах, и понимание требований к точности важно для точных преобразований.

### Секунды против миллисекунд

- **Секунды**: Традиционный Unix timestamp (10 цифр)
- **Миллисекунды**: Современный timestamp (13 цифр, распространен в JavaScript и многих API)

```csharp
// Проверка, находится ли timestamp в секундах или миллисекундах
public static DateTime ConvertUnixTimestamp(long timestamp)
{
    // Если timestamp больше типичных значений для 2038 года, считаем миллисекунды
    if (timestamp > 253402300799) // 1 января 10000 UTC в секундах
    {
        return DateTimeOffset.FromUnixTimeMilliseconds(timestamp).DateTime;
    }
    else
    {
        return DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
    }
}
```

### Высокая точность (микросекунды и наносекунды)

Для приложений, требующих более высокой точности, вам потребуются ручные расчеты:

```csharp
// Точность до микросекунд (1 микросекунда = 0.001 миллисекунды)
public static DateTime FromUnixTimeMicroseconds(long microseconds)
{
    DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
    return epoch.AddTicks(microseconds * 10); // 1 тик = 100 наносекунд
}

// Точность до наносекунд
public static DateTime FromUnixTimeNanoseconds(long nanoseconds)
{
    DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
    return epoch.AddTicks(nanoseconds / 100);
}
```

Обсуждение [GitHub issue](https://*.github.com/dotnet/runtime/issues/23799) показывает, что .NET добавляет нативную поддержку микросекунд в конструкторах DateTime, что указывает на растущий спрос на высокоточное время.

---

## Лучшие практики обработки часовых поясов {#лучшие-практики-обработки-часовых-поясов}

Обработка часовых поясов является наиболее распространенным источником ошибок в преобразованиях timestamp. Вот ключевые принципы:

### Всегда используйте UTC для расчетов

Unix timestamp определяется как секунды/миллисекунды с 1 января 1970 UTC. Никогда не используйте локальное время для расчетов эпохи.

```csharp
// ❌ Неверно - использует локальное время для эпохи
DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0); // DateTimeKind.Unspecified

// ✅ Верно - явно использует UTC
DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
```

### Правильно обрабатывайте DateTimeKind

```csharp
public static class UnixTimestampConverter
{
    private static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
    
    public static DateTime FromUnixSeconds(long seconds, DateTimeKind kind = DateTimeKind.Utc)
    {
        DateTime utcDateTime = UnixEpoch.AddSeconds(seconds);
        return kind == DateTimeKind.Utc ? utcDateTime : utcDateTime.ToLocalTime();
    }
    
    public static long ToUnixSeconds(DateTime dateTime)
    {
        DateTime utcDateTime = dateTime.Kind == DateTimeKind.Utc ? 
            dateTime : dateTime.ToUniversalTime();
        return (long)(utcDateTime - UnixEpoch).TotalSeconds;
    }
}
```

### Избегайте проблем с переходом на летнее время

Статья на [Medium](https://*.medium.com/@hanxuyang0826/handling-timestamps-and-time-zones-in-c-7f156750720d) подчеркивает, что "UTC не меняется с изменением сезонов, но местное время или гражданское время может измениться, если часовой пояс observes переход на летнее время". Именно поэтому UTC следует использовать для всех расчетов timestamp.

---

## Распространенные проблемы и решения {#распространенные-проблемы-и-решения}

### Проблема 1: Неправильная инициализация эпохи

**Ваш текущий код:**
```csharp
DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0).ToLocalTime();
```

**Проблема:** Это создает эпоху с `DateTimeKind.Unspecified`, затем преобразует в локальное время, что может вызвать несоответствия.

**Решение:** Всегда используйте UTC для эпохи:
```csharp
DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
```

### Проблема 2: Потеря точности с Double

**Ваш текущий код:**
```csharp
return span.TotalSeconds; // Возвращает double
```

**Проблема:** `double` может потерять точность для больших timestamp. Используйте `long` для целых секунд или миллисекунд.

**Решение:**
```csharp
// Для секунд (целые числа)
return (long)span.TotalSeconds;

// Для миллисекунд (целые числа)
return (long)span.TotalMilliseconds;
```

### Проблема 3: Несогласованная обработка часовых поясов

**Проблема:** Преобразование в локальное время как для эпохи, так и для расчета может усугублять ошибки.

**Решение:** Используйте UTC внутренне, преобразуйте в локальное время только при отображении пользователям.

### Проблема 4: Неопределение единиц измерения timestamp

**Проблема:** Предположение, что все timestamp в секундах, когда некоторые могут быть в миллисекундах.

**Решение:** Реализуйте автоматическое обнаружение или сделайте это явным в вашем API:
```csharp
public static DateTime ConvertTimestamp(long timestamp, TimeUnit unit = TimeUnit.Seconds)
{
    return unit switch
    {
        TimeUnit.Seconds => DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime,
        TimeUnit.Milliseconds => DateTimeOffset.FromUnixTimeMilliseconds(timestamp).DateTime,
        _ => throw new ArgumentException("Неподдерживаемая единица времени")
    };
}
```

---

## Полный пример реализации {#полный-пример-реализации}

Вот улучшенная версия вашего свойства, которая решает все проблемы:

```csharp
public class TimestampConverter
{
    private static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
    
    // Улучшенная версия с использованием long для целочисленной точности
    public long CreatedEpochSeconds
    {
        get
        {
            // Всегда работаем в UTC для расчетов
            DateTime utcCreated = this.Kind == DateTimeKind.Utc ? 
                this.Created : this.Created.ToUniversalTime();
                
            return (long)(utcCreated - UnixEpoch).TotalSeconds;
        }
        set
        {
            // Устанавливаем с UTC kind для поддержания согласованности
            this.Created = UnixEpoch.AddSeconds(value);
            this.Kind = DateTimeKind.Utc;
        }
    }
    
    // Версия с точностью до миллисекунд
    public long CreatedEpochMilliseconds
    {
        get
        {
            DateTime utcCreated = this.Kind == DateTimeKind.Utc ? 
                this.Created : this.Created.ToUniversalTime();
                
            return (long)(utcCreated - UnixEpoch).TotalMilliseconds;
        }
        set
        {
            this.Created = UnixEpoch.AddMilliseconds(value);
            this.Kind = DateTimeKind.Utc;
        }
    }
    
    // Использование DateTimeOffset для автоматической обработки часовых поясов
    public DateTimeOffset CreatedDateTimeOffset
    {
        get => new DateTimeOffset(this.Created);
        set => this.Created = value.DateTime;
    }
    
    // Методы расширения для более чистого синтаксиса
    public static DateTime ToDateTime(long unixSeconds) 
        => DateTimeOffset.FromUnixTimeSeconds(unixSeconds).DateTime;
    
    public static long ToUnixSeconds(DateTime dateTime) 
        => new DateTimeOffset(dateTime).ToUnixTimeSeconds();
}
```

### Примеры использования

```csharp
// Преобразование текущего времени в Unix timestamp
long nowSeconds = TimestampConverter.ToUnixSeconds(DateTime.UtcNow);
long nowMilliseconds = DateTimeOffset.Now.ToUnixTimeMilliseconds();

// Преобразование обратно в DateTime
DateTime dateTime = TimestampConverter.ToDateTime(nowSeconds);

// Использование улучшенного свойства
var converter = new TimestampConverter();
converter.CreatedEpochSeconds = 1609459200; // 1 января 2021 UTC
Console.WriteLine(converter.Created); // Показывает правильную дату UTC
```

Руководство по преобразованию [C# conversion guide from iifx.dev](https://*.iifx.dev/en/articles/747640) предоставляет дополнительные примеры и лучшие практики для этих шаблонов преобразования.

## Заключение {#заключение}

Преобразование между Unix timestamp и объектами DateTime в C# требует внимания к трем ключевым областям:

1. **Используйте встроенные методы .NET**, такие как `DateTimeOffset.FromUnixTimeSeconds()` и `DateTimeOffset.FromUnixTimeMilliseconds()`, для надежных, протестированных преобразований
2. **Поддерживайте согласованность UTC**, всегда используя `DateTimeKind.Utc` для расчетов эпохи и внутренних операций
3. **Выбирайте подходящую точность**, используя `long` для целых секунд/миллисекунд вместо `double` для избежания потери точности

Улучшенная реализация решает основные проблемы в вашем исходном коде: неправильную инициализацию эпохи, потерю точности с `double` и несогласованную обработку часовых поясов. Следуя этим лучшим практикам, вы создадите преобразования timestamp, которые будут точными и надежными в разных часовых поясах и при изменениях перехода на летнее время.

Для большинства приложений подход на основе `DateTimeOffset` обеспечивает лучший баланс простоты и точности, в то время как ручные расчеты становятся необходимыми только для специализированных требований высокой точности.

## Источники {#источники}

1. [Как преобразовать Unix timestamp в DateTime и наоборот? - Stack Overflow](https://*.stackoverflow.com/questions/249760/how-can-i-convert-a-unix-timestamp-to-datetime-and-vice-versa)
2. [Преобразование между Unix timestamp и DateTime в C# – Aske DOTNET](https://*.aske.wachs.dk/06/07/2021/c-conversion-between-unix-timestamps-and-datetime/)
3. [C# DateTime в UNIX timestamp | Brian Pedersen's Sitecore and .NET Blog](https://*.briancaos.wordpress.com/2022/02/24/c-datetime-to-unix-timestamps/)
4. [Как получить Unix timestamp в C# - Stack Overflow](https://*.stackoverflow.com/questions/17632584/how-to-get-the-unix-timestamp-in-c-sharp)
5. [Упрощение обработки часовых поясов с Unix Time: Практический опыт в C# - Medium](https://*.medium.com/@hanxuyang0826/handling-timestamps-and-time-zones-in-c-7f156750720d)
6. [Руководство по преобразованию DateTime и Unix timestamp в C# - iifx.dev](https://*.iifx.dev/en/articles/747640)
7. [Добавление микросекунд и наносекунд в TimeStamp, DateTime, DateTimeOffset и TimeOnly - GitHub](https://*.github.com/dotnet/runtime/issues/23799)
8. [Преобразование в/из Unix timestamp в C# - DZone](https://*.dzone.com/articles/converting-tofrom-unix)

Полное руководство: Преобразование Unix Timestamp в DateTime в C#

Преобразование Unix-меток времени в объекты DateTime в C#

Содержание

Базовые методы преобразования

Из Unix-метки времени в DateTime

Из DateTime в Unix-метку времени

Обработка точности меток времени

Секунды против миллисекунд

Высокая точность (микросекунды и наносекунды)

Лучшие практики работы с часовыми поясами

Всегда используйте UTC для расчетов

Правильно обрабатывайте DateTimeKind

Избегайте проблем с переходом на летнее время

Распространенные проблемы и решения

Проблема 1: Неправильная инициализация эпохи

Проблема 2: Потеря точности с Double

Проблема 3: Непоследовательная обработка часовых поясов

Проблема 4: Неопределение единиц измерения метки времени

Полный пример реализации

Примеры использования

Заключение

Источники