Início / coding / Perguntas / 79564918
Accepted
Wojciech
Asked: 2025-04-10 01:01:23 +0800 CST

Devo usar ReadOnlySpan<char> como chave em ConcurrentDictionary em vez de string para melhor desempenho?

  • 772

O ConcurrentDictionarycódigo-fonte menciona a possibilidade de usar TAlternateKey, que é uma estrutura de referência. https://github.com/dotnet/runtime/blob/main/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs

Além disso, depois de alguma pesquisa, encontrei outros exemplos interessantes. Como aqui: https://github.com/dotnet/runtime/blob/main/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCache.cs

#if NET9_0_OR_GREATER
            private readonly ConcurrentDictionary<string, CacheEntry>.AlternateLookup<ReadOnlySpan<char>> _stringAltLookup;

            public CoherentState()
            {
                _stringAltLookup = _stringEntries.GetAlternateLookup<ReadOnlySpan<char>>();
            }
#endif
//...
#if NET9_0_OR_GREATER
            internal bool TryGetValue(ReadOnlySpan<char> key, [NotNullWhen(true)] out CacheEntry? entry)
                => _stringAltLookup.TryGetValue(key, out entry);
#endif

#if NET9_0_OR_GREATER
            private readonly ConcurrentDictionary<string, CacheEntry>.AlternateLookup<ReadOnlySpan<char>> _stringAltLookup;

            public CoherentState()
            {
                _stringAltLookup = _stringEntries.GetAlternateLookup<ReadOnlySpan<char>>();
            }
#endif

Devo usar ReadOnlySpan<char>como chave em ConcurrentDictionaryvez de stringpara melhor desempenho?

c#

1 respostas

  1. Best Answer

    Por si só, seu uso AlternateLookupnão trará nenhum benefício de desempenho; você só deve considerar usá-lo quando estiver enfrentando casos específicos de ineficiências que ele foi criado para resolver.

    O mais comum desses problemas é usar Dictionary<string, TValue>chaves que são compatíveis com string, mas que não são instâncias de string:

    var dict = new Dictionary<string, int>();
dict["x"] = 1;

var stringChunk = "xyz";
var key = stringChunk.AsSpan(0, 1);
return dict[key.ToString()];

    Observe a chamada para ToStringwhich, que é necessária para obter o tipo de chave apropriado. Embora você deva usar um tipo imutável como stringpara maior robustez, isso tem desvantagens neste caso, pois tudo o que você quer é usar algo compatível com stringem termos de igualdade (e hash):

    var dict = new Dictionary<string, int>();
dict["x"] = 1;

var alternate = dict.GetAlternateLookup<ReadOnlySpan<char>>();

var stringChunk = "xyz";
var key = stringChunk.AsSpan(0, 1);
return alternate[key];

    Agora, graças a AlternateLookup, você pode manipular o dicionário diretamente. É claro que isso só funciona se o comparador suportar ReadOnlySpan<char>(e, inversamente, você pode tornar seus próprios comparadores compatíveis com esse mecanismo se tiver um caso que precise ser otimizado).

    Em suma, usar AlternateLookupé vantajoso apenas se você já tiver algo compatível com o tipo de chave (neste caso, uma sequência arbitrária de caracteres) e, caso contrário, precisaria convertê-lo para o tipo correto para garantir a correção de tipo. Se o que você começou com um string, não adianta usar AlternateLookupapenas para usar ReadOnlySpan<char>em vez disso.

    • 2

relate perguntas