// 定义一个Unix纪 元时间点，这是一个静态只读字段，避免重复创建。
private static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
public static long ToUnixTimeSeconds(DateTime dateTime)
{
    // 关键步骤：确保传入的dateTime是UTC时间。
    // 如果dateTime.Kind是DateTimeKind.Local，先转换为Utc。
    // 如果dateTime.Kind是DateTimeKind.Unspecified，我们假设它是UTC，但最好在调用前明确。
    DateTime utcDateTime = dateTime.ToUniversalTime();
    // 计算时间差，并获取总秒数。
    TimeSpan timeSpan = utcDateTime - UnixEpoch;
    return (long)timeSpan.TotalSeconds;
}
public static long ToUnixTimeMilliseconds(DateTime dateTime)
{
    DateTime utcDateTime = dateTime.ToUniversalTime();
    TimeSpan timeSpan = utcDateTime - UnixEpoch;
    return (long)timeSpan.TotalMilliseconds;
}

DateTime now = DateTime.UtcNow; // 始终使用DateTime.UtcNow获取当前UTC时间

// 转换为秒级时间戳
long secondsTimestamp = ((DateTimeOffset)now).ToUnixTimeSeconds();
// 转换为毫秒级时间戳
long millisecondsTimestamp = ((DateTimeOffset)now).ToUnixTimeMilliseconds();

public static long ToUnixTimeMicroseconds(DateTime dateTime)
{
    DateTime utcDateTime = dateTime.ToUniversalTime();
    TimeSpan timeSpan = utcDateTime - UnixEpoch;
    // Ticks 是 100 纳秒（即0.1微秒）的间隔数。
    // 1 秒 = 10,000,000 Ticks
    // 1 毫秒 = 10,000 Ticks
    // 1 微秒 = 10 Ticks
    return timeSpan.Ticks / 10; // 转换为微秒
}

private static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

public static DateTime FromUnixTimeSeconds(long seconds)
{
    // 创建UTC时间的DateTime
    return UnixEpoch.AddSeconds(seconds);
}

public static DateTime FromUnixTimeMilliseconds(long milliseconds)
{
    return UnixEpoch.AddMilliseconds(milliseconds);
}

long incomingTimestamp = 1716800000000; // 假设这是一个毫秒级时间戳

// 从秒级时间戳转换
DateTime dateTimeFromSeconds = DateTimeOffset.FromUnixTimeSeconds(incomingTimestamp / 1000).UtcDateTime;

// 从毫秒级时间戳转换 (更直接)
DateTime dateTimeFromMilliseconds = DateTimeOffset.FromUnixTimeMilliseconds(incomingTimestamp).UtcDateTime;

DateTime utcTime = DateTimeOffset.FromUnixTimeMilliseconds(timestamp).UtcDateTime;

// 转换为服务器本地时间
DateTime localTime = utcTime.ToLocalTime();

// 转换为特定时区的时间（需要时区信息）
// 例如，转换为中国标准时间 (UTC+8)
TimeZoneInfo cstZone = TimeZoneInfo.FindSystemTimeZoneById("China Standard Time"); // 在Windows上
// 或 TimeZoneInfo.FindSystemTimeZoneById("Asia/Shanghai"); // 在Linux/macOS上
DateTime cstTime = TimeZoneInfo.ConvertTimeFromUtc(utcTime, cstZone);

{
  "orderTime": 1716800000000,
  "expiresIn": 3600
}

public class ApiRequest
{
    public long OrderTime { get; set; } // 毫秒时间戳
    public int ExpiresIn { get; set; } // 秒数
}

[HttpPost]
public IActionResult CreateOrder([FromBody] ApiRequest request)
{
    // 1. 转换主要时间点
    DateTime orderUtcTime = DateTimeOffset.FromUnixTimeMilliseconds(request.OrderTime).UtcDateTime;
    
    // 2. 计算过期时间（基于当前时间加上偏移秒数）
    DateTime expirationUtcTime = DateTime.UtcNow.AddSeconds(request.ExpiresIn);
    
    // 3. 也可以计算基于orderTime的过期时间
    DateTime expirationFromOrder = orderUtcTime.AddSeconds(request.ExpiresIn);
    
    // ... 后续业务逻辑
    // 存储时，建议始终存储 orderUtcTime 和 expirationUtcTime
    return Ok();
}

// 业务逻辑中产生一个时间
DateTime paymentTime = DateTime.UtcNow;
long timestampForDb = ((DateTimeOffset)paymentTime).ToUnixTimeSeconds(); // 存秒级

// 使用Dapper插入
await connection.ExecuteAsync(
    "INSERT INTO Transactions (Id, Amount, Timestamp) VALUES (@Id, @Amount, @Ts)",
    new { Id = Guid.NewGuid(), Amount = 100.00m, Ts = timestampForDb }
);

// 假设查询返回一个包含long类型Timestamp字段的对象
var records = await connection.QueryAsync<TransactionRecord>(
    "SELECT Id, Amount, Timestamp FROM Transactions WHERE Timestamp > @Since",
    new { Since = DateTimeOffset.UtcNow.AddDays(-1).ToUnixTimeSeconds() }
);

foreach (var record in records)
{
    DateTime utcTime = DateTimeOffset.FromUnixTimeSeconds(record.Timestamp).UtcDateTime;
    Console.WriteLine($"Record {record.Id} at {utcTime:yyyy-MM-dd HH:mm:ss} UTC");
}

public static DateTime SafeConvertFromTimestamp(long timestamp)
{
    // 一个简单的启发式规则：如果数字特别大，很可能是毫秒
    // 当前时间（2024年）的毫秒级时间戳大约在1.7e12左右，秒级在1.7e9左右。
    // 我们可以用一个阈值来区分，例如 10^12 (即 1,000,000,000,000)
    if (timestamp > 1_000_000_000_000) // 大于万亿，很可能是毫秒
    {
        // 但再检查一下，避免是未来的秒级时间戳（比如3000年）
        // 3000-01-01的秒级时间戳约为3.3e10，仍远小于阈值。
        return DateTimeOffset.FromUnixTimeMilliseconds(timestamp).UtcDateTime;
    }
    else
    {
        // 否则按秒处理
        return DateTimeOffset.FromUnixTimeSeconds(timestamp).UtcDateTime;
    }
}

long timestamp = 1716800000000;
DateTime utcTime = DateTimeOffset.FromUnixTimeMilliseconds(timestamp).UtcDateTime;

// 错误做法：直接使用 ToLocalTime (依赖服务器时区)
DateTime potentiallyWrongLocalTime = utcTime.ToLocalTime(); // 如果用户不在服务器时区，这就错了

// 正确做法：知晓用户时区标识（如“America/New_York”）
string userTimeZoneId = "Eastern Standard Time"; // 或从用户配置中获取
TimeZoneInfo userTimeZone;
try
{
    userTimeZone = TimeZoneInfo.FindSystemTimeZoneById(userTimeZoneId);
}
catch (TimeZoneNotFoundException)
{
    // 处理时区未找到的情况，回退到UTC或默认时区
    userTimeZone = TimeZoneInfo.Utc;
}

DateTime userLocalTime = TimeZoneInfo.ConvertTimeFromUtc(utcTime, userTimeZone);
Console.WriteLine($"User local time: {userLocalTime:yyyy-MM-dd HH:mm:ss}");

using NodaTime;
using NodaTime.Text;

// 从Unix毫秒时间戳到 Instant
long milliseconds = 1716800000000;
Instant instant = Instant.FromUnixTimeMilliseconds(milliseconds);

// 从 Instant 到 UTC 的 DateTime
DateTime utcDateTime = instant.ToDateTimeUtc();

// 从 Instant 到特定时区的时间
DateTimeZone zone = DateTimeZoneProviders.Tzdb["Asia/Shanghai"];
ZonedDateTime zonedDateTime = instant.InZone(zone);
LocalDateTime localDateTime = zonedDateTime.LocalDateTime;

// 从 DateTime (UTC) 到 Instant
DateTime myUtcDateTime = DateTime.UtcNow;
Instant instantFromDt = Instant.FromDateTimeUtc(myUtcDateTime);
long timestampMs = instantFromDt.ToUnixTimeMilliseconds();