[.net] 문자열 중간에서 문화에 민감한 “시작”작업을 수행하려면 어떻게해야합니까?

이것은 실제로 정규화없이 IsPrefix.

동일한 수의 문자 가 아닌 동일한 수의 텍스트 요소 를 비교해야 하지만 여전히 일치하는 문자 수를 반환합니다.

Noda Time의 ValueCursor.cs에서MatchCaseInsensitive 메서드 복사본을 만들고 정적 컨텍스트에서 사용할 수 있도록 약간 수정했습니다.

// Noda time code from MatchCaseInsensitive in ValueCursor.cs
static int IsMatch_Original(string source, int index, string match, CompareInfo compareInfo)
{
    unchecked
    {
        if (match.Length > source.Length - index)
        {
            return 0;
        }

        // TODO(V1.2): This will fail if the length in the input string is different to the length in the
        // match string for culture-specific reasons. It's not clear how to handle that...
        if (compareInfo.Compare(source, index, match.Length, match, 0, match.Length, CompareOptions.IgnoreCase) == 0)
        {
            return match.Length;
        }

        return 0;
    }
}

(참조 용으로 만 포함되어 있습니다. 아시다시피 제대로 비교되지 않는 코드입니다.)

해당 메서드의 다음 변형은 프레임 워크에서 제공하는 StringInfo.GetNextTextElement 를 사용합니다 . 아이디어는 텍스트 요소별로 텍스트 요소를 비교하여 일치를 찾고 발견되면 소스 문자열에서 일치하는 실제 문자 수를 반환하는 것입니다.

// Using StringInfo.GetNextTextElement to match by text elements instead of characters
static int IsMatch_New(string source, int index, string match, CompareInfo compareInfo)
{
    int sourceIndex = index;
    int matchIndex = 0;

    // Loop until we reach the end of source or match
    while (sourceIndex < source.Length && matchIndex < match.Length)
    {
        // Get text elements at the current positions of source and match
        // Normally that will be just one character but may be more in case of Unicode combining characters
        string sourceElem = StringInfo.GetNextTextElement(source, sourceIndex);
        string matchElem = StringInfo.GetNextTextElement(match, matchIndex);

        // Compare the current elements.
        if (compareInfo.Compare(sourceElem, matchElem, CompareOptions.IgnoreCase) != 0)
        {
            return 0; // No match
        }

        // Advance in source and match (by number of characters)
        sourceIndex += sourceElem.Length;
        matchIndex += matchElem.Length;
    }

    // Check if we reached end of source and not end of match
    if (matchIndex != match.Length)
    {
        return 0; // No match
    }

    // Found match. Return number of matching characters from source.
    return sourceIndex - index;
}

그 방법은 (: 기본적으로 그냥 문자열의 변종 몇 당신이 제공 한 테스트 내 테스트 케이스에 따라 적어도 잘 작동 "b\u00e9d"과 "be\u0301d").

그러나 GetNextTextElement 메서드는 각 텍스트 요소에 대한 하위 문자열을 생성 하므로이 구현에는 많은 하위 문자열 비교가 필요하므로 성능에 영향을 미칩니다.

따라서 GetNextTextElement를 사용하지 않고 대신 유니 코드 조합 문자를 건너 뛰어 문자에서 실제 일치 길이 를 찾는 다른 변형을 만들었습니다 .

// This should be faster
static int IsMatch_Faster(string source, int index, string match, CompareInfo compareInfo)
{
    int sourceLength = source.Length;
    int matchLength = match.Length;
    int sourceIndex = index;
    int matchIndex = 0;

    // Loop until we reach the end of source or match
    while (sourceIndex < sourceLength && matchIndex < matchLength)
    {
        sourceIndex += GetTextElemLen(source, sourceIndex, sourceLength);
        matchIndex += GetTextElemLen(match, matchIndex, matchLength);
    }

    // Check if we reached end of source and not end of match
    if (matchIndex != matchLength)
    {
        return 0; // No match
    }

    // Check if we've found a match
    if (compareInfo.Compare(source, index, sourceIndex - index, match, 0, matchIndex, CompareOptions.IgnoreCase) != 0)
    {
        return 0; // No match
    }

    // Found match. Return number of matching characters from source.
    return sourceIndex - index;
}

이 방법은 다음 두 도우미를 사용합니다.

static int GetTextElemLen(string str, int index, int strLen)
{
    bool stop = false;
    int elemLen;

    for (elemLen = 0; index < strLen && !stop; ++elemLen, ++index)
    {
        stop = !IsCombiningCharacter(str, index);
    }

    return elemLen;
}

static bool IsCombiningCharacter(string str, int index)
{
    switch (CharUnicodeInfo.GetUnicodeCategory(str, index))
    {
        case UnicodeCategory.NonSpacingMark:
        case UnicodeCategory.SpacingCombiningMark:
        case UnicodeCategory.EnclosingMark:
            return true;

        default:
            return false;
    }
}

나는 벤치 마킹을 한 적이 없기 때문에 더 빠른 방법이 실제로 더 빠른지 실제로 알지 못합니다. 확장 된 테스트도하지 않았습니다.

그러나 이것은 유니 코드 결합 문자를 포함 할 수있는 문자열에 대해 문화적 민감한 부분 문자열 일치를 수행하는 방법에 대한 귀하의 질문에 답할 것입니다.

다음은 내가 사용한 테스트 사례입니다.

static Tuple<string, int, string, int>[] tests = new []
{
    Tuple.Create("x b\u00e9d y", 2, "be\u0301d", 3),
    Tuple.Create("x be\u0301d y", 2, "b\u00e9d", 4),

    Tuple.Create("x b\u00e9d", 2, "be\u0301d", 3),
    Tuple.Create("x be\u0301d", 2, "b\u00e9d", 4),

    Tuple.Create("b\u00e9d y", 0, "be\u0301d", 3),
    Tuple.Create("be\u0301d y", 0, "b\u00e9d", 4),

    Tuple.Create("b\u00e9d", 0, "be\u0301d", 3),
    Tuple.Create("be\u0301d", 0, "b\u00e9d", 4),

    Tuple.Create("b\u00e9", 0, "be\u0301d", 0),
    Tuple.Create("be\u0301", 0, "b\u00e9d", 0),
};

튜플 값은 다음과 같습니다.

1. 소스 문자열 (haystack)
2. 소스의 시작 위치입니다.
3. 일치 문자열 (바늘)입니다.
4. 예상되는 일치 길이입니다.

세 가지 방법으로 이러한 테스트를 실행하면 다음 결과가 생성됩니다.

Test #0: Orignal=BAD; New=OK; Faster=OK
Test #1: Orignal=BAD; New=OK; Faster=OK
Test #2: Orignal=BAD; New=OK; Faster=OK
Test #3: Orignal=BAD; New=OK; Faster=OK
Test #4: Orignal=BAD; New=OK; Faster=OK
Test #5: Orignal=BAD; New=OK; Faster=OK
Test #6: Orignal=BAD; New=OK; Faster=OK
Test #7: Orignal=BAD; New=OK; Faster=OK
Test #8: Orignal=OK; New=OK; Faster=OK
Test #9: Orignal=OK; New=OK; Faster=OK

마지막 두 테스트는 소스 문자열이 일치 문자열보다 짧은 경우를 테스트합니다. 이 경우 원래 (Noda 시간) 방법도 성공합니다.

답변