Perguntas[c#](coding)

public static byte[] TestEncrypt(string plainText, byte[] key, byte[] iv)
{
    using Aes aes = Aes.Create();
    
    aes.Key = key;
    aes.IV = iv;
  
    // Create a new MemoryStream object to contain the encrypted bytes.
    using MemoryStream memoryStream = new MemoryStream();
    // Create a CryptoStream object to perform the encryption.
    using CryptoStream cryptoStream = new CryptoStream(memoryStream, aes.CreateEncryptor(), CryptoStreamMode.Write);
    // Encrypt the plaintext.
    using StreamWriter streamWriter = new StreamWriter(cryptoStream);
    streamWriter.Write(plainText);
    cryptoStream.FlushFinalBlock();

    byte[] cipherText = memoryStream.ToArray();

    return cipherText;
}

 public static string TestDecrypt(byte[] encryptedText, byte[] key, byte[] iv)
 {
     using Aes aes = Aes.Create();

     aes.Key = key;
     aes.IV = iv;
     using MemoryStream memoryStream = new MemoryStream(encryptedText);

     memoryStream.Position = 0;
     using CryptoStream cryptoStream = new CryptoStream(memoryStream, aes.CreateDecryptor(), CryptoStreamMode.Read);
         
     using StreamReader streamReader = new StreamReader(cryptoStream);
     cryptoStream.Flush();
     var data = streamReader.ReadToEnd() ;
     return data;
 }

Estou usando os dois métodos acima para criptografar e descriptografar uma string. Percebo que o leitor de fluxo sempre retorna uma string vazia. Verifiquei várias vezes que ambos os métodos recebem os mesmos valores de chave e iv, incluindo que o texto criptografado não é modificado/violado quando passado para o método TestDecrypt.

Ainda não consegui descobrir por que uma string vazia está sendo retornada?

Por favor, teste os métodos com qualquer chave aleatória e valor de IV. Só quero saber se o texto criptografado foi descriptografado com sucesso.

Espero que o texto criptografado seja descriptografado com sucesso, retornando ao texto original. O resultado é uma string vazia, o que é incorreto.

Sou iniciante em C#. Estou tentando converter uma string JSON em uma lista parecida com esta:

firstName   lastName  departmentID
John        Doe       AAA111
John2       Doe2      BBB222

Postagem atualizada - com base na resposta do David (obrigado por isso). Desculpe por toda a confusão que posso ter causado.

Aqui está o código:

public IActionResult JsonTest()
{

    var respJSON = @"
        [
              {
                ""firstName"": ""John"",
                ""lastName"": ""Doe"",
                ""departmentID"": { ""id"": ""AAA111"" },
              },
              {
                ""firstName"": ""John2"",
                ""lastName"": ""Doe2"",
                ""departmentID"": { ""id"": ""BBB222"" }
              }
          ]
        ";

    List<UserNameWithDept> user = JsonConvert.DeserializeObject<List<UserNameWithDept>>(respJSON);

    return Ok();
}


public class Identifier
{
    [JsonProperty("id")]
    public string Id { get; set; }
}

public class UserNameWithDept
{
    [JsonProperty("firstName")]
    public string FirstName { get; set; }

    [JsonProperty("lastName")]
    public string LastName { get; set; }

    [JsonProperty("departmentID")]
    public Identifier Department { get; set; }
}

Estou pegando o Departamento como um objeto e então o valor dentro dele.

Como posso fazer a lista ficar assim? Departamento tem valor, não objeto.

Department  "AAA111"
FirstName   "John"
LastName    "Doe"

Estou usando o Blazor WASM com .Net 8 e o pacote Kontent.Ai.Delivery e estou tentando integrar o cache ao sistema. Um problema que estou enfrentando é que, depois de armazenar os dados como JSON no cache, não consigo desserializar os dados no objeto porque a classe é gerada com Kontent AI e é um modelo fortemente tipado como este.

public partial class RichTextModulesType
{
    public const string Codename = "rich_text_modules_type";
    public const string PositionCodename = "position";
    public const string DescriptionCodename = "description";
    public const string ImageCodename = "image";
    public const string ImagePositionCodename = "image_position";
    public const string AdditionalTextCodeName = "additional_text";

    public IRichTextContent AdditionalText { get; set; }
    public IEnumerable<IMultipleChoiceOption> Position { get; set; }
    public IRichTextContent Description { get; set; }
    public IEnumerable<IAsset> Image { get; set; }
    public IEnumerable<IMultipleChoiceOption> ImagePosition { get; set; }
    public IContentItemSystemAttributes System { get; set; }
}

Quando tento desserializar os dados, ocorre o erro

Componente de renderização de exceção não tratada: O tipo de coleção 'Kontent.Ai.Delivery.Abstractions.IRichTextContent' é abstrato, uma interface ou é somente leitura e não pôde ser instanciado e preenchido.

É assim que os dados foram recuperados antes de serializar e colocar no cache

var response = await DeliveryClient.GetItemsAsync<PageType>(
    new MyParams("...")
);
if (response.Items.Count() > 0)
{
    PageInfo = response.Items.FirstOrDefault<PageType>();
    string responseBody = JsonSerializer.Serialize(PageInfo, new JsonSerializerOptions
    {
        ReferenceHandler = System.Text.Json.Serialization.ReferenceHandler.IgnoreCycles,
        MaxDepth = 128
    });
    await CacheStorageAccessor.StoreAsync(new HttpRequestMessage(HttpMethod.Get, cacheKey), new HttpResponseMessage
    {
        Content = new StringContent(responseBody)
    }, 3600);
}

Quais são minhas opções aqui?

Tenho experiência com Laravel e PHP e sou iniciante em ASP.NET Core e Blazor. Tenho interesse em explorar o Blazor e pretendo usar o PostgreSQL como banco de dados e o ASP.NET Core como backend.

Identifiquei duas opções de hospedagem que gostaria de experimentar:

1. Blazor Server com modo de renderização de web assembly interativo
2. Montagem web Blazor

Pela minha pesquisa inicial, essas duas opções parecem bastante semelhantes, o que me confunde. Pelo que entendi, o Blazor Server com renderização interativa de web assembly pode ser equivalente ao Blazor web assembly, mas não tenho certeza se isso é exato.

Alguém poderia esclarecer as principais diferenças entre essas duas abordagens?

Especificamente:

1. Como eles diferem em termos de arquitetura, desempenho e casos de uso?
2. O Blazor Server com web assembly interativo é essencialmente o mesmo que o Blazor web assembly ou há vantagens/desvantagens distintas para cada um?

Qualquer informação será muito apreciada.

Tenho um projeto em C# que chama algumas APIs. Essas APIs são bem diferentes, e a resposta é diferente para quase todas as chamadas.

Eu escrevi um serviço de cliente genérico:

public class HttpClientHelper
{
    private readonly IHttpClientFactory _httpClientFactory;

    public HttpClientHelper(IHttpClientFactory httpClientFactory)
    {
        _httpClientFactory = httpClientFactory;
    }

    public async Task<TResponse> MakeHttpRequestAsync<TRequest, TResponse>(
        string clientName,
        string url,
        HttpMethod httpMethod,
        TRequest requestBody = default,
        bool handleErrors = false)
    {
        // Get a named HttpClient instance
        var client = _httpClientFactory.CreateClient(clientName);

        var request = new HttpRequestMessage
        {
            Method = httpMethod,
            RequestUri = new Uri(url)
        };

        // Serialize the request body to JSON (if it exists)
        if (requestBody != null)
        {
            var json = JsonSerializer.Serialize(requestBody);
            request.Content = new StringContent(json, 
                                  Encoding.UTF8, "application/json");
        }

        // Send the HTTP request
        var response = await client.SendAsync(request);

        // Handle errors if specified
        if (handleErrors && !response.IsSuccessStatusCode)
        {
            throw new HttpRequestException($"Failed: {response.StatusCode}");
        }

        // Deserialize the response JSON into the specified type
        var responseJson = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<TResponse>(responseJson, 
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
    }
}

Agora, quero ter um retorno mais estruturado desta função. Por exemplo, gosto de usar para todas as respostas algo como

public class ApiResponse<T> where T : class
{
    public T? Data { get; set; }
    public string? ErrorMessage { get; set; }
    public int HttpErrorCode { get; set; } = 200;
    public bool Success { get; set; } = false;
}

Não preciso lidar com os erros no código principal, e tudo é gerenciado perfeitamente no cliente da API genérica. Se houver um erro na chamada, no ApiResponse, posso definir Successcomo false.

Se eu escrever este código:

public async Task<ApiResponse<TResponse>> 
    MakeHttpRequestAsync<TRequest, ApiResponse<TResponse>>(
    ...
    )
{
    // code
}

Recebo um erro

O tipo ou nome do namespace TResponsenão pôde ser encontrado (está faltando uma diretiva using ou uma referência de assembly?)

O que não quero é derivar uma classe do ApiResponseporque uso os modelos em outras partes do código.

Existe uma maneira de implementar isso?

Estou tentando escrever meu próprio motor de jogo. Empacotei os arquivos, como os recursos dos jogos, para que o motor pudesse lê-los com mais rapidez e facilidade. No entanto, encontrei um problema. Não consegui encontrar a origem do problema. Quando tento ler os dados do arquivo PAK que criei, há um desvio nos dados lidos. Não consigo ler os dados corretamente.

Estrutura do arquivo:

[Header]
[Index Table]
[Asset Data]

Códigos:

namespace EngineCore
{
    public class PakEntry
    {
        public string Name { get; set; }
        public byte Type { get; set; }
        public uint Offset { get; set; }
        public uint Size { get; set; }
    }
}

namespace EngineCore
{
    public interface IPakReaderBackend
    {
        byte[] Read(PakEntry entry);
        void Dispose();
    }
}

using System;
using System.IO;
using System.IO.MemoryMappedFiles;

namespace EngineCore
{
    public class MemoryMappedBackend : IPakReaderBackend, IDisposable
    {
        private readonly MemoryMappedFile mmf;
        private MemoryMappedViewAccessor accessor;

        public MemoryMappedBackend(string path)
        {
            mmf = MemoryMappedFile.CreateFromFile(path, FileMode.Open);
        }

        public byte[] Read(PakEntry entry)
        {
            using var accessor = mmf.CreateViewAccessor(entry.Offset, entry.Size, MemoryMappedFileAccess.Read);
            byte[] buffer = new byte[entry.Size];
            accessor.ReadArray(0, buffer, 0, buffer.Length);
            return buffer;
        }

        public void Dispose()
        {
            accessor?.Dispose();
            mmf?.Dispose();
            GC.SuppressFinalize(this);
        }
    }
}

using System.IO;

namespace EngineCore
{
    public class SeekAndReadBackend : IPakReaderBackend
    {
        private readonly string pakFilePath;

        public SeekAndReadBackend(string path)
        {
            pakFilePath = path;
        }

        public byte[] Read(PakEntry entry)
        {
            byte[] buffer = new byte[entry.Size];
            using (FileStream fs = new FileStream(pakFilePath, FileMode.Open, FileAccess.Read))
            {
                fs.Seek(entry.Offset, SeekOrigin.Current);
                fs.Read(buffer, 0, buffer.Length);
            }
            return buffer;
        }

        public void Dispose() { }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace EngineCore
{
    public class PakWriter : IDisposable
    {
        private const string Magic = "TGPAK";
        private const ushort Version = 1;
        private readonly List<PakEntry> entries;
        private readonly MemoryStream dataStream;

        public PakWriter()
        {
            entries = new List<PakEntry>();
            dataStream = new MemoryStream();
        }

        public void AddFile(string filePath, byte type)
        {
            byte[] fileData = File.ReadAllBytes(filePath);
            uint offset = (uint)dataStream.Position;


            dataStream.Write(fileData, 0, fileData.Length);

            entries.Add(new PakEntry
            {
                Name = Path.GetFileName(filePath),
                Type = type,
                Offset = offset,
                Size = (uint)fileData.Length
            });
        }

        public void Save(string outputPath)
        {
            using (FileStream fs = new FileStream(outputPath, FileMode.Create, FileAccess.Write))
            {
                using (BinaryWriter bw = new BinaryWriter(fs))
                {
                    bw.Write(Encoding.ASCII.GetBytes(Magic.PadRight(6, '\0')));
                    bw.Write(Version);
                    bw.Write((uint)entries.Count);
                    long indexOffsetPos = fs.Position;
                    bw.Write((uint)0);

                    dataStream.Seek(0, SeekOrigin.Begin);
                    dataStream.CopyTo(fs);

                    long indexOffset = fs.Position;

                    foreach (var entry in entries)
                    {
                        byte[] nameBytes = Encoding.UTF8.GetBytes(entry.Name);
                        bw.Write((byte)nameBytes.Length);
                        bw.Write(nameBytes);
                        bw.Write(entry.Type);
                        bw.Write(entry.Offset);
                        bw.Write(entry.Size);
                    }

                    fs.Seek(indexOffsetPos, SeekOrigin.Begin);
                    bw.Write((uint)indexOffset);
                }
            }
        }

        public void Dispose()
        {
            entries.Clear();
            dataStream?.Dispose();
            GC.SuppressFinalize(this);
        }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace EngineCore
{
    public class PakReader : IDisposable
    {
        public List<PakEntry> Entries { get; private set; } = new List<PakEntry>();
        private readonly IPakReaderBackend backend;

        public PakReader(string filePath, bool useMemoryMapping = false)
        {
            using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                using (BinaryReader br = new BinaryReader(fs))
                {
                    string magic = Encoding.ASCII.GetString(br.ReadBytes(6)).TrimEnd('\0');
                    if (magic != "TGPAK") throw new Exception("Invalid pak");

                    ushort version = br.ReadUInt16();
                    uint entryCount = br.ReadUInt32();
                    uint indexOffset = br.ReadUInt32();

                    fs.Seek(indexOffset, SeekOrigin.Begin);
                    for (int i = 0; i < entryCount; i++)
                    {
                        byte nameLen = br.ReadByte();
                        string name = Encoding.UTF8.GetString(br.ReadBytes(nameLen));
                        byte type = br.ReadByte();
                        uint offset = br.ReadUInt32();
                        uint size = br.ReadUInt32();

                        Entries.Add(new PakEntry
                        {
                            Name = name,
                            Type = type,
                            Offset = offset,
                            Size = size
                        });
                    }
                }
            }
            backend = useMemoryMapping ? new MemoryMappedBackend(filePath) : new SeekAndReadBackend(filePath);
        }

        public byte[] Read(string name)
        {
            PakEntry entry = Entries.FirstOrDefault(e => e.Name == name);
            if (entry == null)
            {
                return null;
            }
            return backend.Read(entry);
        }

        public void Dispose()
        {
            backend.Dispose();
            GC.SuppressFinalize(this);
        }
    }
}

Teste

// Write
PakWriter pakW = new PakWriter();
pakW.AddFile("Assets/Test1.txt", 7);
pakW.AddFile("Assets/Test2.txt", 7);
pakW.AddFile("Assets/Player.fbx", 3);
pakW.AddFile("Assets/Wall.res", 5);
pakW.Save("Bin/data.pak");
pakW.Dispose();

// Read
PakReader pakR = new PakReader("Bin/data.pak");
Console.WriteLine("Assets:");
foreach (PakEntry entry in pakR.Entries)
{
    Console.WriteLine($" - {entry.Name} (Type: {entry.Type}, Size: {entry.Size} bytes)");
}
byte[] data = pakR.Read("Test2.txt");
Console.WriteLine("Test2:" + Encoding.UTF8.GetString(data));
Console.ReadLine();
pakR.Dispose();

Saída:

Assets:
 - Test1.txt (Type: 7, Size: 20 bytes)
 - Test2.txt (Type: 7, Size: 20 bytes)
 - Player.fbx (Type: 3, Size: 759512 bytes)
 - Wall.res (Type: 5, Size: 13544 bytes)
Test2:AAAAAAAAAAAAAAAABBBB

Estou com problemas com um programa em que preciso gerar relatórios simultaneamente em várias threads. É um programa legado, o código não está bem documentado e gera um erro ao executar testes NUnit, mas não ao executar o aplicativo localmente no IIS ou em uma máquina Windows Server dedicada com IIS. A primeira coisa que me chama a atenção é o código a seguir. Pelo que entendi, DEVERIA SER THREAD-SEGURO, mas não tenho 100% de certeza.

public static class Transliterator
{
    private static readonly ConcurrentDictionary<SupportedConversions, ConcurrentDictionary<char, string>> converters = new ConcurrentDictionary<SupportedConversions, ConcurrentDictionary<char, string>>
    {
            [SupportedConversions.MK_ENG] = new ConcurrentDictionary<char, string>()
            {
                  ['а'] = "a"
                , ['б'] = "b"
                , ['в'] = "v"
                , ['г'] = "g"
                , ['д'] = "d"
                , ['ѓ'] = "gj"
                , ['е'] = "e"
                , ['ж'] = "zh"
                , ['з'] = "z"
                , ['ѕ'] = "dz"
                , ['и'] = "i"
                , ['ј'] = "j"
                , ['к'] = "k"
                , ['л'] = "l"
                , ['љ'] = "lj"
                , ['м'] = "m"
                , ['н'] = "n"
                , ['њ'] = "nj"
                , ['о'] = "o"
                , ['п'] = "p"
                , ['р'] = "r"
                , ['с'] = "s"
                , ['т'] = "t"
                , ['ќ'] = "kj"
                , ['у'] = "u"
                , ['ф'] = "f"
                , ['х'] = "h"
                , ['ц'] = "c"
                , ['ч'] = "ch"
                , ['џ'] = "dzh"
                , ['ш'] = "sh"
                , ['А'] = "A"
                , ['Б'] = "B"
                , ['В'] = "V"
                , ['Г'] = "G"
                , ['Д'] = "D"
                , ['Ѓ'] = "Gj"
                , ['Е'] = "E"
                , ['Ж'] = "Zh"
                , ['З'] = "Z"
                , ['Ѕ'] = "Dz"
                , ['И'] = "I"
                , ['Ј'] = "J"
                , ['К'] = "K"
                , ['Л'] = "L"
                , ['Љ'] = "Lj"
                , ['М'] = "M"
                , ['Н'] = "N"
                , ['Њ'] = "Nj"
                , ['О'] = "O"
                , ['П'] = "P"
                , ['Р'] = "R"
                , ['С'] = "S"
                , ['Т'] = "T"
                , ['Ќ'] = "Kj"
                , ['У'] = "U"
                , ['Ф'] = "F"
                , ['Х'] = "H"
                , ['Ц'] = "C"
                , ['Ч'] = "Ch"
                , ['Џ'] = "Dzh"
                , ['Ш'] = "Sh" 
            }
    };

    public static string Transliterate(string source, SupportedConversions conversion)
    {
        ConcurrentDictionary<char, string> converter = converters[conversion];

        var result = new StringBuilder();

        foreach (char letter in source)
        {
            if (converter.TryGetValue(letter, out string convertedLetter))
            {
                result.Append(convertedLetter);
            }
            else
            {
                result.Append(letter);
            }
        }
        
        return result.ToString();
    }

    public enum SupportedConversions
    {
        MK_ENG = 0
    }
}

Tenho uma aplicação Node.js com acesso a banco de dados. A string de conexão é obtida de um arquivo JSON e a parte da senha dentro da string de conexão contém salt, nonce e a cifra, que é criptografada por AES-GCM. O segredo para criptografar + descriptografar a senha usa uma derivação de chave do SCrypt dentro da biblioteca interna de criptografia do Node.js. Até agora, tudo bem, a criptografia e a descriptografia funcionam perfeitamente.

Entretanto, para outro caso de uso, tenho que usar essa string de conexão agora de um aplicativo C# e não consigo descriptografar a string de senha.

O método falha com o seguinte erro:

A tag de autenticação computada não corresponde à tag de autenticação de entrada

Já rastreei a derivação da chave. Não consegui encontrar uma implementação .NET que correspondesse à derivação da chave do nodejs.

Aqui está meu código - Node.js:

decrypt(encryptedText) {
    const decoded = Buffer.from(encryptedText, "base64").toString("utf8");
    const [saltHex, ivHex, authTagHex, encryptedHex] = decoded.split(":");
    const salt = Buffer.from(saltHex, "hex");
    const secretByte = Buffer.from(this.secretKey, "utf-8");
    const key = crypto.scryptSync(salt, secretByte, 32, { cost: 16384, blockSize: 8, parallelization: 1 });
    const iv = Buffer.from(ivHex, "hex");
    const authTag = Buffer.from(authTagHex, "hex");
    const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
    decipher.setAuthTag(authTag);
    let decrypted = decipher.update(encryptedHex, "hex", "utf8");
    decrypted += decipher.final("utf8");
    return decrypted;
}

Código C#:

public static String DecryptAESGCM(Dictionary<string, byte[]> encrypted, string secret)
{
    byte[] secretByte = Encoding.UTF8.GetBytes(secret);

    //clsLogger.Log(Encoding.UTF8.GetString(encrypted.GetValueOrDefault("salt")), enumLogLevel.INFO);

    // Derive key
    byte[] derivedKey = SCrypt.ComputeDerivedKey(secretByte, encrypted.GetValueOrDefault("salt"), 16384, 8, 1, 1, 32);

    using (AesGcm aes = new AesGcm(derivedKey, encrypted.GetValueOrDefault("tag").Length))
    {
        byte[] plainText = new byte[encrypted.GetValueOrDefault("cipher").Length];
        aes.Decrypt(encrypted.GetValueOrDefault("nonce"), encrypted.GetValueOrDefault("cipher"), encrypted.GetValueOrDefault("tag"), plainText);

        return Encoding.UTF8.GetString(plainText);
    }
}

O dicionário em C# é um armazenamento de valor-chave com byte[]salt, nonce, tag e cifra.

Já tentei várias bibliotecas diferentes para reproduzir a chave derivada e garanti que salt e secret tenham os mesmos valores em node.js e c# antes da função ser chamada, mas as chaves derivadas são sempre diferentes.

Alguém teve um caso semelhante e conseguiu resolver ou tem alguma ideia de como?

Obrigado antecipadamente!
Robin

Tenho um método com condição de troca para executar diferentes operações em whileloop com CancellationToken, conforme mencionado aqui.

    private Task MessagesAsync(CancellationToken cancelToken) => Task.Run(() =>
    {       
        while (!cancelToken.IsCancellationRequested)
        {        
            var message = this.routerSocket.ReceiveMultipartMessage();
            if (message is null)
                continue;         

            switch (MessageType)
            {
                case Email:
                    OnSendEmail(message);
                    break;
                case SMS:
                    OnSendSMS(message);
                    break; 

                // (Other code)
                    this.routerSocket.SignalOK();
           }
        }
    }, cancelToken);

Agora eu tenho o OnSendMailmétodo

private void OnSendEmail(String message)
{        
    try
    {            
         EmailService.SendEmail(message); // Will throw exception.                    
    }
    catch (Exception ex)
    {      
        this.publisherSocket.SendMultipartMessage(ex.Message); // Will send UI notification
    }
}

Nisso, EmailService.SendEmail(message)retornará um erro de operação inválida e deverá capturar a exceção. publisherSocket.SendMultipartMessage()Notificará a interface do usuário quando algum erro ocorrer.

O problema é que, como esse método é chamado no loop while com Cancellationtoken, ele não cancela a execução. Ele faz chamadas constantes para OnSendEmail()o método e recebemos várias caixas de mensagem com mensagens de erro na interface do usuário.

Como podemos receber apenas uma notificação de erro na interface do usuário? Além disso, quando ocorre um erro, ele não deve fazer chamadas repetidas vezes para OnSendEmail().

Devemos restringir a chamada para OnSendEmail()quando a exceção for capturada. Por favor, me ajude com esta questão.

Na documentação do ConcurrentDictionary é declarado que a fábrica de valores é chamada fora dos bloqueios e que uma chave/valor pode ser inserido por outro thread enquanto valueFactory está gerando um valor. Você não pode confiar que só porque valueFactory foi executado, seu valor produzido será inserido no dicionário e retornado.

Meu código original se parece com isso:

public class MyClass
{
  private readonly ConcurrentDictionary<string, Task<string>> myData = new();

  public Task<string> GetData(string key)
  {
    return myData.GetOrAdd(key, key => longCalculation(key));
  }
}

Se várias threads chamarem MyClass.GetData("theSameKey")ao mesmo tempo, longCalculation"theSameKey" será executado várias vezes porque valueFactoryserá delegado a outra string.

Para evitar ter que longCalculationexecutar desnecessariamente, alterei meu código para usar Lazy, conforme sugerido por JG no SD, para que o delegado fosse executado apenas uma vez:

public class MyClass
{
  private readonly ConcurrentDictionary<string, Lazy<Task<string>>> myData = new();

  public async Task<string> GetData(string key)
  {
    var lazyTask = new new Lazy<Task<string>>(() => longCalculation(key),
      LazyThreadSafetyMode.ExecutionAndPublication);
    var task = myData.GetOrAdd(key, lazyTask).Value;
    return await task;
  }
}

Esta versão, se houver várias chamadas de threads, MyClass.GetData("theSameKey") longCalculationé executada apenas uma vez. Embora eu tenha uma correção para obter o comportamento desejado, gostaria de ter mais detalhes explicando por que isso acontece.