string eng = "qwertyuiop[]asdfghjkl;'zxcvbnm,.QWERTYUIOP{}ASDFGHJKL:"ZXCVBNM<>`~ёЁ";
string ru =  "йцукенгшщзхъфывапролджэячсмитьбюЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖЭЯЧСМИТЬБЮеЕеЕ";
for (int i = 0; i < eng.Length; ++i)
  if (query.Contains(eng[i]))
    query = query.Replace(eng[i], ru[i]);

public sealed class Replacer
{
    private readonly Dictionary<Char, Char> _dictionary;

    public Replacer(String sourceSymbols, String targetSymbols)
    {
        if (sourceSymbols.Length != targetSymbols.Length)
            throw new NotSupportedException("sourceSymbols.Length != targetSymbols.Length");

        Int32 count = sourceSymbols.Length;

        Dictionary<Char, Char> dictionary = new Dictionary<Char, Char>(count);
        for (int i = 0; i < count; i++)
            dictionary.Add(sourceSymbols[i], targetSymbols[i]);

        _dictionary = dictionary;
    }

    public void FixCharacters(ref String query)
    {
        if (String.IsNullOrEmpty(query))
            return;

        if (String.IsInterned(query) == null)
        {
            FixNotInternedString(query);
        }
        else
        {
            FixInternedString(ref query);
        }
    }

    private unsafe void FixNotInternedString(String query)
    {
        Int32 index = query.Length - 1;
        fixed (Char* chPtr = query)
        {
            while (index >= 0)
            {
                Char oldChar = chPtr[index];

                Char newChar;
                if (_dictionary.TryGetValue(oldChar, out newChar))
                    chPtr[index] = newChar;

                index--;
            }
        }
    }

    private void FixInternedString(ref String query)
    {
        StringBuilder sb = new StringBuilder(query.Length);
        foreach (Char c in query)
        {
            Char fixedChar;
            if (_dictionary.TryGetValue(c, out fixedChar))
                sb.Append(fixedChar);
            else
                sb.Append(c);
        }
        query = sb.ToString();
    }
}

static void Main(string[] args)
{
    String eng = "qwertyuiop[]asdfghjkl;'zxcvbnm,.QWERTYUIOP{}ASDFGHJKL:"ZXCVBNM<>`~ёЁ";
    String rus = "йцукенгшщзхъфывапролджэячсмитьбюЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖЭЯЧСМИТЬБЮеЕеЕ";

    Replacer replacer = new Replacer(eng, rus);

    for (int i = 0; i < 10; i++)
    {
        String query = $"Hello World {i}";

        replacer.FixCharacters(ref query);

        Console.WriteLine(query); // "Руддщ Цщкдв"
    }
}

public static class LangConversion
{
    private static readonly Dictionary<char, char> engToRu = new Dictionary<char, char>();

    static LangConversion()
    {
        var eng = "qwertyuiop[]asdfghjkl;'zxcvbnm,.QWERTYUIOP{}ASDFGHJKL:"ZXCVBNM<>`~ёЁ";
        var ru = "йцукенгшщзхъфывапролджэячсмитьбюЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖЭЯЧСМИТЬБЮеЕеЕ";
        for (var i = 0; i < eng.Length; i++)
            engToRu[eng[i]] = ru[i];
    }

    public static string Fix(string str)
    {
        var sb = new StringBuilder(str.Length);
        foreach (char c in str)
        {
            char fixedChar;
            sb.Append(engToRu.TryGetValue(c, out fixedChar) ? fixedChar : c);
        }
        return sb.ToString();
    }
}

public static class LangConversion2
{
    public static string Fix(string str)
    {
        var sb = new StringBuilder(str.Length);
        foreach (char c in str)
        {
            sb.Append(Replace(c));
        }
        return sb.ToString();
    }

    private static char Replace(char c)
    {
        switch (c)
        {
            case 'q': return 'й';
            ...
            case 'Ё': return 'Е';
            default: return c;
        }
    }
}

public static class LangConversion3
{
    private static readonly char[] engToRu;

    static LangConversion3()
    {
        var eng = "qwertyuiop[]asdfghjkl;'zxcvbnm,.QWERTYUIOP{}ASDFGHJKL:"ZXCVBNM<>`~ёЁ";
        var ru = "йцукенгшщзхъфывапролджэячсмитьбюЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖЭЯЧСМИТЬБЮеЕеЕ";
        int maxCharCode = 0;
        foreach (char c in eng)
            maxCharCode = c > maxCharCode ? c : maxCharCode;
        engToRu = new char[maxCharCode + 1];
        for (var i = 0; i < eng.Length; i++)
            engToRu[eng[i]] = ru[i];
    }

    public static string Fix(string str)
    {
        var sb = new StringBuilder(str.Length);
        foreach (char c in str)
        {
            sb.Append(Replace(c));
        }
        return sb.ToString();
    }

    private static char Replace(char c)
    {
        if (c >= engToRu.Length)
            return c;
        var fixedChar = engToRu[c];
        return fixedChar != 0 ? fixedChar : c;
    }
}

Исходный вариант:               6480мс
Dictionary:                     2550мс
Pointers (ответ @LunarWhisper): 1560мс
Switch-case:                    1520мс
Array:                          1310мс
Pointers + array:                720мс
Pointers + switch-case:          580мс

for (int i = 0; i < eng.Length; ++i)
    query = query.Replace(eng[i], ru[i]);

// считаем один раз, оптимизация!
static (char, char)[] dictionary = eng.Zip(ru, (a, b) => (a, b)).ToArray();

//....

foreach (var (e, r) in dictionary)
    query = query.Replace(e, r);

foreach (var (e, r) in eng.Zip(ru, (a, b) => (a, b)))
    query = query.Replace(e, r);