根据字节长度缩短UTF8字符串的最佳方法

Question

最近的一个项目要求将数据导入 Oracle 数据库。 执行此操作的程序是一个 C# .Net 3.5 应用程序，我使用 Oracle.DataAccess 连接库来处理实际的插入。

我遇到了一个问题，在插入特定字段时我会收到此错误消息：

ORA-12899 Value Too Large for column X

我使用了 Field.Substring(0, MaxLength); 但仍然得到了错误（虽然不是每条记录）。

最后我看到了应该很明显的东西，我的字符串是 ANSI 格式，字段是 UTF8 格式。 它的长度以字节为单位定义，而不是字符。

这让我想到了我的问题。 修剪字符串以固定 MaxLength 的最佳方法是什么？

我的子字符串代码按字符长度工作。 是否有简单的 C# 函数可以按字节长度智能地修剪 UT8 字符串（即不砍掉半个字符）？

Answer 1

我认为我们可以做得比每次添加时天真地计算字符串的总长度更好。 LINQ 很酷，但它可能会意外地导致低效的代码。 如果我想要一个巨大的 UTF 字符串的前 80,000 个字节怎么办？ 这是很多不必要的计数。 “我有 1 个字节。现在我有 2 个字节。现在我有 13 个字节……现在我有 52,384 个字节……”

这很愚蠢。 大多数时候，至少在英语中，我们可以精确地剪切第n个字节。 即使在另一种语言中，我们距离一个好的切入点也只有不到 6 个字节。

所以我将从 @Oren 的建议开始，即关闭 UTF8 字符值的前导位。 让我们从第 n+1 个字节开始，然后使用 Oren 的技巧来确定是否需要提前剪切几个字节。

三种可能性

如果剪切后的第一个字节的前导位有一个 0，我知道我正好在单个字节（传统 ASCII）字符之前剪切，并且可以切干净。

如果剪切后有一个11，则剪切后的下一个字节是多字节字符的开始，所以这也是剪切的好地方！

但是，如果我有一个 10，我知道我正处于多字节字符的中间，并且需要返回检查它真正开始的位置。

也就是说，虽然我想在第 n 个字节之后剪切字符串，但如果第 n+1 个字节位于多字节字符的中间，则剪切将创建无效的 UTF8 值。 我需要备份，直到到达以 11 开头的一个并在其之前剪切。

代码

注释：我使用诸如 Convert.ToByte("11000000", 2) 这样的东西，这样就可以很容易地知道我正在屏蔽哪些位（更多关于位屏蔽此处）。 简而言之，我&返回字节前两位的内容，并返回0其余部分。 然后，我检查 XX000000 中的 XX，看看它是 10 还是 11（如果适用）。

我今天发现C# 6.0 实际上可能支持二进制表示，这很酷，但是我们现在将继续使用这个拼凑来说明正在发生的事情。

PadLeft 只是因为我对控制台的输出过于强迫。

因此，这里有一个函数，可以将您缩减为 n 字节长的字符串或小于 n 的最大数字，并以“完整”UTF8 字符结尾。

public static string CutToUTF8Length(string str, int byteLength)
{
    byte[] byteArray = Encoding.UTF8.GetBytes(str);
    string returnValue = string.Empty;

    if (byteArray.Length > byteLength)
    {
        int bytePointer = byteLength;

        // Check high bit to see if we're [potentially] in the middle of a multi-byte char
        if (bytePointer >= 0 
            && (byteArray[bytePointer] & Convert.ToByte("10000000", 2)) > 0)
        {
            // If so, keep walking back until we have a byte starting with `11`,
            // which means the first byte of a multi-byte UTF8 character.
            while (bytePointer >= 0 
                && Convert.ToByte("11000000", 2) != (byteArray[bytePointer] & Convert.ToByte("11000000", 2)))
            {
                bytePointer--;
            }
        }

        // See if we had 1s in the high bit all the way back. If so, we're toast. Return empty string.
        if (0 != bytePointer)
        {
            returnValue = Encoding.UTF8.GetString(byteArray, 0, bytePointer); // hat tip to @NealEhardt! Well played. ;^)
        }
    }
    else
    {
        returnValue = str;
    }

    return returnValue;
}

我最初将其写为字符串扩展。 当然，只需在 string str 之前添加 this 即可将其恢复为扩展格式。 我删除了 this，以便我们可以将该方法放入简单控制台应用程序中的 Program.cs 中进行演示。

测试和预期输出

这是一个很好的测试用例，它在下面创建的输出，编写为简单控制台应用的 Program.cs< 中的 Main 方法/代码>。

static void Main(string[] args)
{
    string testValue = "12345“”67890”";

    for (int i = 0; i < 15; i++)
    {
        string cutValue = Program.CutToUTF8Length(testValue, i);
        Console.WriteLine(i.ToString().PadLeft(2) +
            ": " + Encoding.UTF8.GetByteCount(cutValue).ToString().PadLeft(2) +
            ":: " + cutValue);
    }

    Console.WriteLine();
    Console.WriteLine();

    foreach (byte b in Encoding.UTF8.GetBytes(testValue))
    {
        Console.WriteLine(b.ToString().PadLeft(3) + " " + (char)b);
    }

    Console.WriteLine("Return to end.");
    Console.ReadLine();
}

输出如下。 请注意，testValue 中的“智能引号”在 UTF8 中是三个字节长（尽管当我们以 ASCII 将字符写入控制台时，它会输出哑引号）。 另请注意输出中每个智能引号的第二个和第三个字节的 ? 输出。

我们的 testValue 的前五个字符是 UTF8 中的单字节，因此 0-5 字节值应该是 0-5 个字符。 然后我们有一个三字节的智能引用，直到 5 + 3 字节才能完整包含它。 果然，我们看到在调用 8 时弹出。我们的下一个智能引号在 8 + 3 = 11 处弹出，然后我们回到单字节字符到 14。

 0:  0::
 1:  1:: 1
 2:  2:: 12
 3:  3:: 123
 4:  4:: 1234
 5:  5:: 12345
 6:  5:: 12345
 7:  5:: 12345
 8:  8:: 12345"
 9:  8:: 12345"
10:  8:: 12345"
11: 11:: 12345""
12: 12:: 12345""6
13: 13:: 12345""67
14: 14:: 12345""678


 49 1
 50 2
 51 3
 52 4
 53 5
226 â
128 ?
156 ?
226 â
128 ?
157 ?
 54 6
 55 7
 56 8
 57 9
 48 0
226 â
128 ?
157 ?
Return to end.

所以这很好很有趣，而且我正值这个问题五周年纪念日之前。 尽管奥伦对这些位的描述有一个小错误，但这正是您想要使用的技巧。 谢谢你的提问； 整洁的。

Answer 2

这里有两种可能的解决方案 - LINQ 单行从左到右处理输入，传统的 for 循环从右到左处理输入。 哪个处理方向更快取决于字符串长度、允许的字节长度以及多字节字符的数量和分布，很难给出一般性建议。 LINQ 和传统代码之间的决定可能是品味问题（或者可能是速度问题）。

如果速度很重要，可以考虑只累加每个字符的字节长度直到达到最大长度，而不是在每次迭代中计算整个字符串的字节长度。 但我不确定这是否可行，因为我不太了解 UTF-8 编码。 我理论上可以想象字符串的字节长度不等于所有字符的字节长度之和。

public static String LimitByteLength(String input, Int32 maxLength)
{
    return new String(input
        .TakeWhile((c, i) =>
            Encoding.UTF8.GetByteCount(input.Substring(0, i + 1)) <= maxLength)
        .ToArray());
}

public static String LimitByteLength2(String input, Int32 maxLength)
{
    for (Int32 i = input.Length - 1; i >= 0; i--)
    {
        if (Encoding.UTF8.GetByteCount(input.Substring(0, i + 1)) <= maxLength)
        {
            return input.Substring(0, i + 1);
        }
    }

    return String.Empty;
}

Answer 3

所有其他答案似乎都忽略了这样一个事实：此功能已经内置到 .NET 中，位于 编码器 类。 为了加分，这种方法也适用于其他编码。

public static string LimitByteLength(string message, int maxLength)
{
    if (string.IsNullOrEmpty(message) || Encoding.UTF8.GetByteCount(message) <= maxLength)
    {
        return message;
    }

    var encoder = Encoding.UTF8.GetEncoder();
    byte[] buffer = new byte[maxLength];
    char[] messageChars = message.ToCharArray();
    encoder.Convert(
        chars: messageChars,
        charIndex: 0,
        charCount: messageChars.Length,
        bytes: buffer,
        byteIndex: 0,
        byteCount: buffer.Length,
        flush: false,
        charsUsed: out int charsUsed,
        bytesUsed: out int bytesUsed,
        completed: out bool completed);

    // I don't think we can return message.Substring(0, charsUsed)
    // as that's the number of UTF-16 chars, not the number of codepoints
    // (think about surrogate pairs). Therefore I think we need to
    // actually convert bytes back into a new string
    return Encoding.UTF8.GetString(buffer, 0, bytesUsed);
}

---

如果您使用的是 .NET Standard 2.1+，则可以稍微简化一下：

public static string LimitByteLength(string message, int maxLength)
{
    if (string.IsNullOrEmpty(message) || Encoding.UTF8.GetByteCount(message) <= maxLength)
    {
        return message;
    }

    var encoder = Encoding.UTF8.GetEncoder();
    byte[] buffer = new byte[maxLength];
    encoder.Convert(message.AsSpan(), buffer.AsSpan(), false, out _, out int bytesUsed, out _);
    return Encoding.UTF8.GetString(buffer, 0, bytesUsed);
}

---

其他答案都没有考虑扩展字素簇，例如

Answer 4

ruffin 的回答的简短版本。 利用UTF8 的设计：

    public static string LimitUtf8ByteCount(this string s, int n)
    {
        // quick test (we probably won't be trimming most of the time)
        if (Encoding.UTF8.GetByteCount(s) <= n)
            return s;
        // get the bytes
        var a = Encoding.UTF8.GetBytes(s);
        // if we are in the middle of a character (highest two bits are 10)
        if (n > 0 && ( a[n]&0xC0 ) == 0x80)
        {
            // remove all bytes whose two highest bits are 10
            // and one more (start of multi-byte sequence - highest bits should be 11)
            while (--n > 0 && ( a[n]&0xC0 ) == 0x80)
                ;
        }
        // convert back to string (with the limit adjusted)
        return Encoding.UTF8.GetString(a, 0, n);
    }

Answer 5

如果 UTF-8 字节 具有零值高位，则它是字符的开头。 如果它的高位为 1，则它位于字符的“中间”。 检测字符开头的能力是 UTF-8 的明确设计目标。

查看维基百科文章的描述部分了解更多详细信息。

Answer 6

您是否需要以字节为单位声明数据库列？ 这是默认值，但如果数据库字符集是可变宽度，则它不是特别有用的默认值。 我强烈建议用字符来声明该列。

CREATE TABLE length_example (
  col1 VARCHAR2( 10 BYTE ),
  col2 VARCHAR2( 10 CHAR )
);

这将创建一个表，其中 COL1 将存储 10 个字节的数据，而 col2 将存储 10 个字符的数据。 字符长度语义在 UTF8 数据库中更有意义。

假设您希望创建的所有表默认使用字符长度语义，则可以将初始化参数 NLS_LENGTH_SEMANTICS 设置为 CHAR。 此时，如果您未在字段长度中指定 CHAR 或 BYTE，您创建的任何表都将默认使用字符长度语义而不是字节长度语义。

Answer 7

根据Oren Trutner 的评论，这里还有两个解决该问题的方法：
这里我们根据字符串末尾的每个字符来计算要从字符串末尾删除的字节数，因此我们不会在每次迭代中评估整个字符串。

string str = "朣楢琴执执 瑩浻牡楧硰执执獧浻牡楧敬瑦 瀰 絸朣杢执獧扻捡杫潲湵 潣" 
int maxBytesLength = 30;
var bytesArr = Encoding.UTF8.GetBytes(str);
int bytesToRemove = 0;
int lastIndexInString = str.Length -1;
while(bytesArr.Length - bytesToRemove > maxBytesLength)
{
   bytesToRemove += Encoding.UTF8.GetByteCount(new char[] {str[lastIndexInString]} );
   --lastIndexInString;
}
string trimmedString = Encoding.UTF8.GetString(bytesArr,0,bytesArr.Length - bytesToRemove);
//Encoding.UTF8.GetByteCount(trimmedString);//get the actual length, will be <= 朣楢琴执执 瑩浻牡楧硰执执獧浻牡楧敬瑦 瀰 絸朣杢执獧扻捡杫潲湵 潣潬昣昸昸慢正 

还有一个更高效（且可维护）的解决方案：
根据所需的长度从字节数组中获取字符串并剪切最后一个字符，因为它可能已损坏

string str = "朣楢琴执执 瑩浻牡楧硰执执獧浻牡楧敬瑦 瀰 絸朣杢执獧扻捡杫潲湵 潣" 
int maxBytesLength = 30;    
string trimmedWithDirtyLastChar = Encoding.UTF8.GetString(Encoding.UTF8.GetBytes(str),0,maxBytesLength);
string trimmedString = trimmedWithDirtyLastChar.Substring(0,trimmedWithDirtyLastChar.Length - 1);

第二个解决方案的唯一缺点是我们可能会剪切一个完美的最后一个字符，但我们已经在剪切字符串，所以它可能符合要求。
感谢 Shade 想到了第二种解决方案

Answer 8

这是另一种基于二分查找的解决方案：

public string LimitToUTF8ByteLength(string text, int size)
{
    if (size <= 0)
    {
        return string.Empty;
    }

    int maxLength = text.Length;
    int minLength = 0;
    int length = maxLength;

    while (maxLength >= minLength)
    {
        length = (maxLength + minLength) / 2;
        int byteLength = Encoding.UTF8.GetByteCount(text.Substring(0, length));

        if (byteLength > size)
        {
            maxLength = length - 1;
        }
        else if (byteLength < size)
        {
            minLength = length + 1;
        }
        else
        {
            return text.Substring(0, length); 
        }
    }

    // Round down the result
    string result = text.Substring(0, length);
    if (size >= Encoding.UTF8.GetByteCount(result))
    {
        return result;
    }
    else
    {
        return text.Substring(0, length - 1);
    }
}

Answer 9

public static string LimitByteLength3(string input, Int32 maxLenth)
    {
        string result = input;

        int byteCount = Encoding.UTF8.GetByteCount(input);
        if (byteCount > maxLenth)
        {
            var byteArray = Encoding.UTF8.GetBytes(input);
            result = Encoding.UTF8.GetString(byteArray, 0, maxLenth);
        }

        return result;
    }