1

我正在使用旧数据库，需要开始使用 c# 生成 id。我需要生成与旧 ID 对应的 ID。

我想将 DateTime 转换为 7 digit \ base36 配置。我认为一旦我将代码从base36代码转换为DateTime（再次感谢Joshua），逆向工程就很容易了，但是我仍然遇到困难。

我花了一天的时间试图弄清楚如何从 DateTime 转换为 base36。

下面是从 base36 代码转换为 DateTime 的代码。这段代码似乎工作正常。id 被添加到 sRecid，然后转换为 DateTime。

    id          Date Time
    A7LXZMM     2004-02-02 09:34:47.000
    KWZKXEX     2018-11-09 11:15:46.000
    LIZTMR9     2019-09-13 11:49:46.000

    using System;
    using System.Globalization;         
    using System.Text;
    using System.Numerics;

    public class Program
    {
      public static void Main()
      {

        string sRecid = "KWZKXEX";
        char c0 = sRecid[0];
        char c1 = sRecid[1];
        char c2 = sRecid[2];
        char c3 = sRecid[3];
        char c4 = sRecid[4];
        char c5 = sRecid[5];
        char c6 = sRecid[6];

        double d6, d5, d4, d3, d2, d1, d0, dsecs;

        Console.WriteLine("c0 = " + c0.ToString());
        Console.WriteLine();

        d6 = Math.Pow(36, 6) * ((Char.IsNumber(c0)) ? (byte)c0 - 48 : (byte)c0 - 55);
        d5 = Math.Pow(36, 5) * ((Char.IsNumber(c1)) ? (byte)c1 - 48 : (byte)c1 - 55);
        d4 = Math.Pow(36, 4) * ((Char.IsNumber(c2)) ? (byte)c2 - 48 : (byte)c2 - 55);
        d3 = Math.Pow(36, 3) * ((Char.IsNumber(c3)) ? (byte)c3 - 48 : (byte)c3 - 55);
        d2 = Math.Pow(36, 2) * ((Char.IsNumber(c4)) ? (byte)c4 - 48 : (byte)c4 - 55);
        d1 = Math.Pow(36, 1) * ((Char.IsNumber(c5)) ? (byte)c5 - 48 : (byte)c5 - 55);
        d0 = Math.Pow(36, 0) * ((Char.IsNumber(c6)) ? (byte)c6 - 48 : (byte)c6 - 55);

        dsecs = (d6 + d5 + d4 + d3 + d2 + d1 + d0) / 50;

        DateTime dt = new DateTime(1990, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
        dt = dt.AddSeconds(dsecs).ToLocalTime();

        Console.WriteLine("d6 = " + d6.ToString());
        Console.WriteLine("d5 = " + d5.ToString());
        Console.WriteLine("d4 = " + d4.ToString());
        Console.WriteLine("d3 = " + d3.ToString());
        Console.WriteLine("d2 = " + d2.ToString());
        Console.WriteLine("d1 = " + d1.ToString());
        Console.WriteLine("d0 = " + d0.ToString());
        Console.WriteLine("dsecs = " + dsecs.ToString());
        Console.WriteLine("dt = " + dt.ToString());
      }
    }

这是我遇到问题的代码。

    using System;
    using System.Globalization;         
    using System.Text;
    using System.Numerics;

    public class Program
    {
      /*
        A7LXZMM     2004-02-02 09:34:47.000
        KWZKXEX     2018-11-09 11:15:46.000
        LIZTMR9     2019-09-13 11:49:46.000 
      */

      public static void Main()
      {

        DateTime dt = new DateTime(2004, 02, 02, 09, 34, 47);  // Convert this datetime to A7LXZMM

        DateTime dtBase = new DateTime(1990, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
        double offsetseconds = (DateTime.Now - DateTime.UtcNow).TotalSeconds;
        double seconds = ((dt - dtBase).TotalSeconds) * 50;

        double d6 = seconds / (Math.Pow(36, 6));
        var q6 = d6.ToString().Split('.');
        double dQuotient = double.Parse(q6[0]);
        double dRemainder = double.Parse(q6[1]);
        char c0 = ((dQuotient <= 9) ? (char)(dQuotient + 48) : (char)(dQuotient + 55));

        Console.WriteLine("d6 = " + d6.ToString());
        Console.WriteLine("dQuotient = " + dQuotient.ToString());
        Console.WriteLine("c0 = " + c0.ToString());
        Console.WriteLine("");

        double d5 = dQuotient / (Math.Pow(36, 5));
        var q5 = d5.ToString().Split('.');
        dQuotient = double.Parse(q5[0]);
        dRemainder = double.Parse(q5[1]);
        char c1 = ((dQuotient <= 9) ? (char)(dQuotient + 48) : (char)(dQuotient + 55));

        Console.WriteLine("d5 = " + d5.ToString());
        Console.WriteLine("dQuotient = " + dQuotient.ToString());
        Console.WriteLine("c1 = " + c1.ToString());
        Console.WriteLine("");

      }
    }

代码开始时很好，我可以得到第一个字符（c0），但我在处理下一个字符（c1 以后）时遇到了问题。

在我的示例中，我传递了日期 2004-02-02 09:34:47 并打算返回 A7LXZMM。我哪里错了？

谢谢。

4

2 回答 2

2

您的问题的根源是您未能将本地时区偏移量纳入计算。您尝试确定 TZ 偏移量，尽管方式不正确，但实际上从未使用过。

尝试不正确的原因是您检索了两次当前时间，而当前时间实际上可能在这两次调用之间发生变化。在 .NET 环境中，由于DateTime.Now和.UtcNow属性的分辨率相对较低，这不太可能发生，但理论上如果您在正确的时刻捕获调用，它可能会发生。

当然，这个错误并不重要，因为计算值从未使用过。

恕我直言，这两个代码示例的另一个大问题是它们没有充分概括，也没有充分抽象：

  • 泛化：代码根本不可重用，假设 Base36 格式，以及时间值的 epoch。
  • 抽象的：代码将所有的实现都放在一个单一的程序语句中，因此很难对计算的各个组件进行推理。

代码的最后一个大问题是它将编码时间调整为本地时间。当地时间仅供人类使用。这在某种程度上与抽象方面有关。但要点是，在处理时间值时，您的代码应该只在内部使用 UTC。本地时间仅在与用户交互时才有用，即使这样也仅用于支持您希望用户专门在其本地时区工作的用户场景（有时您的用户遍布世界各地并且他们相互协调您的时间值，强制用户使用 UTC 是有意义的）。

最后一点也让我们其他人很难参与到您的代码中，因为您与我们其他人处于不同的时区（似乎比 UTC 早一小时）。

这是我将如何解决问题的示例。这里的主要内容是我已经将 Base36 处理与数据库值处理分开。我还引入了一个明确的时区偏移参数并切换到使用DateTimeOffset而不是DateTime，因为这允许我在您的时区工作。:) 实际上，我会使用DateTimeOffset值，但仅使用 UTC，即偏移量为 0。非零偏移量仅用于此示例，如果您坚持使用，则可以在生产代码中省略偏移量参数UTC 内部。

首先，一个 Base36 编码器类：

static class Base36
{
    public static string EncodeAsFixedWidth(long value, int totalWidth)
    {
        string base36Text = Encode(value);

        return base36Text.PadLeft(totalWidth, '0');
    }

    public static string Encode(long value)
    {
        StringBuilder sb = new StringBuilder();

        while (value >= 36)
        {
            int digit = (int)(value % 36);
            char digitCharacter = _GetDigitCharacter(digit);

            sb.Append(digitCharacter);
            value = value / 36;
        }

        sb.Append(_GetDigitCharacter((int)value));
        _Reverse(sb);
        return sb.ToString();
    }

    public static long Decode(string base36Text)
    {
        long value = 0;

        foreach (char ch in base36Text)
        {
            value = value * 36 + _GetBase36DigitValue(ch);
        }

        return value;
    }

    private static void _Reverse(StringBuilder sb)
    {
        for (int i = 0; i < sb.Length / 2; i++)
        {
            char ch = sb[i];

            sb[i] = sb[sb.Length - i - 1];
            sb[sb.Length - i - 1] = ch;
        }
    }

    private static int _GetBase36DigitValue(char ch)
    {
        return ch < 'A' ? ch - '0' : ch - 'A' + 10;
    }

    private static char _GetDigitCharacter(int digit)
    {
        return (char)(digit < 10 ? '0' + digit : 'A' + digit - 10);
    }
}

好的，现在我们有了，很容易编写一个类来处理数据库值本身的编码：

static class DatabaseDateTime
{
    private static readonly DateTimeOffset _epoch = new DateTimeOffset(1990, 1, 1, 0, 0, 0, 0, TimeSpan.Zero);

    public static DateTimeOffset Decode(string databaseText, int timeZoneOffsetHours)
    {
        double secondsSinceEpoch = Base36.Decode(databaseText) / 50d;
        DateTimeOffset result = _epoch.AddSeconds(secondsSinceEpoch);

        return new DateTimeOffset(result.AddHours(timeZoneOffsetHours).Ticks, TimeSpan.FromHours(timeZoneOffsetHours));
    }

    internal static string Encode(DateTimeOffset testResult)
    {
        double secondsSinceEpoch = testResult.Subtract(_epoch).TotalSeconds;

        return Base36.EncodeAsFixedWidth((long)(secondsSinceEpoch * 50), 7);
    }
}

最后，出于本练习的目的，我编写了一个小示例程序，它使用您的示例值来验证上述代码是否按预期工作：

static void Main(string[] args)
{
    (string DatabaseText, DateTimeOffset EncodedDateTime)[] testCases =
    {
        ("A7LXZMM", DateTimeOffset.Parse("2004-02-02 09:34:47.000 +01:00")),
        ("KWZKXEX", DateTimeOffset.Parse("2018-11-09 11:15:46.000 +01:00")),
        ("LIZTMR9", DateTimeOffset.Parse("2019-09-13 11:49:46.000 +01:00"))
    };

    List<DateTimeOffset> testResults = new List<DateTimeOffset>(testCases.Length);

    foreach (var testCase in testCases)
    {
        DateTimeOffset decodedDateTime = DatabaseDateTime.Decode(testCase.DatabaseText, 1);

        // Compare as string, because reference data was provided as string and is missing
        // some of the precision in the actual database text provided.
        if (decodedDateTime.ToString() != testCase.EncodedDateTime.ToString())
        {
            WriteLine($"ERROR: {testCase.DatabaseText} -- expected: {testCase.EncodedDateTime}, actual: {decodedDateTime}");
        }

        testResults.Add(decodedDateTime);
    }

    foreach (var testCase in testResults.Zip(testCases, (r, c) => (Result: r, DatabaseText: c.DatabaseText)))
    {
        string base36Text = DatabaseDateTime.Encode(testCase.Result);

        if (base36Text != testCase.DatabaseText)
        {
            WriteLine($"ERROR: {testCase.Result} -- expected: {testCase.DatabaseText}, actual: {base36Text}");
        }
    }
}

当我运行上面的代码时，我没有得到任何输出，正如所期望的那样（即WriteLine()只有当程序的计算与预期不匹配时才执行上面的唯一调用）。

于 2019-10-02T00:33:11.673 回答
0

不要通过日期的字符串表示。使用 Tick Represantation，它很长（64 位），更容易处理。

然后你将它除以 36，只要它不为零，

string result = string.Empty;
long ticks = DateTime.Now.Ticks;
while (ticks>0)
{
   int n = ticks % 36;
   ticks /= 36;
   char c = n<26 ? ('A'+n) : ('0'+n-26);
   result = c + result;
}

这与任何其他基地相同。

要反转它，您需要反转：

int n = c <= '9' ? (c-'0'+26) : (c-'A')

乘以 36 的指数

如果 Base36 的此要求未在外部定义，则在使用更大的字母表时，您会得到更短的字符串。对于 63 个符号，您很可能只需要 6 个字符即可获得相同的范围。只需添加小写字符和一个额外的标点符号即可。

于 2019-10-01T21:52:14.397 回答