C#中时间戳与DateTime互转避坑与最佳实践指南

// 定义一个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();