首先 - 你的性能问题很有趣，并且带有过早优化的味道 - 正如这个答案将显示的那样，你可能会看到 for 循环和 ToDictionary 之间的几毫秒性能差异。
除非您在实时系统中运行它，否则我看不出有什么问题。
在节目中 - 以下是我能想到的三种（半）不同方式构建字典的粗略基准（只有真实世界的时间是可靠的）。第一个使用for 循环，第二个使用相同但不使用数组的Length 属性（只是为了感兴趣）；第三次和第四次使用ToDictionary；一个使用Select，一个使用计数器变量（混合）：
[TestMethod]
public void SomeBenchmark()
{
List<double> forLoopTimes = new List<double>();
List<double> forLoop2Times = new List<double>();
List<double> toDictionaryTimes = new List<double>();
List<double> hybridTimes = new List<double>();
string[] array = Enumerable.Range(0, 5000).Select(i => i.ToString()).ToArray();
Dictionary<int, string> dictionary;
int runCount = 5000;
int arrayLen = array.Length;
while (runCount-- != 0)
{
Stopwatch sw = Stopwatch.StartNew();
dictionary = new Dictionary<int, string>();
for (int i = 0; i < array.Length; i++)
{
dictionary[i] = array[i];
}
sw.Stop();
forLoopTimes.Add(sw.Elapsed.TotalMilliseconds);
sw.Restart();
dictionary = new Dictionary<int, string>();
for (int i = 0; i < arrayLen; i++)
{ //same as before - but using arrayLen instead of property
dictionary[i] = array[i];
}
sw.Stop();
forLoop2Times.Add(sw.Elapsed.TotalMilliseconds);
sw.Restart();
dictionary = array.Select((s, i) => new { Key = i, Value = s }).ToDictionary(v => v.Key, v => v.Value);
sw.Stop();
toDictionaryTimes.Add(sw.Elapsed.TotalMilliseconds);
int counter = 0;
sw.Restart();
dictionary = array.ToDictionary(s => counter++, s => s);
sw.Stop();
hybridTimes.Add(sw.Elapsed.TotalMilliseconds);
}
Console.WriteLine("for loop average: {0} milliseconds", forLoopTimes.Average());
Console.WriteLine("for loop(2) average: {0} milliseconds", forLoop2Times.Average());
Console.WriteLine("ToDictionary average: {0} milliseconds", toDictionaryTimes.Average());
Console.WriteLine("Hybrid average: {0} milliseconds", hybridTimes.Average());
}
结果（发布版本，在我的戴尔 2.4Ghz 工作站上运行大约需要 20 秒）：
对于循环平均值：0.28880804 毫秒
For loop(2) 平均：0.2773845 毫秒
ToDictionary 平均：0.479094339999998 毫秒
混合平均：0.353655779999999 毫秒
所以for 循环无疑更快 - 至少是最接近的ToDictionary 实现的 22%。我已经尝试了 100,000 个元素，然后它达到了大约 30%。
注意第二个for 循环结果 - 似乎表明绕过Length 属性是个好主意。事实上，我已经连续运行了 4 次，结果如下（包括第一次，来自上面）：
For循环：0.28880804、0.28562478、0.283770739999999、0.287241679999999
For循环(2)：0.2773845、0.27621306、0.27869996、0.27962916
ToDictionary: 0.479094339999998, 0.476417939999997, 0.476162219999997, 0.475776479999997
混合：0.353655779999999、0.3583224、0.352022739999998、0.349865779999999
但是，我也看到了至少一个基准测试结果的结果——证明了这种基准测试在很大程度上是毫无意义的。实际上，我们也应该为每个测试生成不同的数组，以避免缓存等。
还有其他选择。
如果您调用的方法接受IDictionary<int, string>（注意 - 接口）；而不是Dictionary<int, string>，您可以创建一个简单的包装器类型来实现接口的必要成员，从而完全避免投影到字典中的需要；只要只需要某些成员。这是一个几乎完整的实现：
public class FakeDictionary : IDictionary<int, string>
{
private readonly string[] _array;
public FakeDictionary(string[] array)
{
_array = array;
}
#region IDictionary<int,string> Members
public void Add(int key, string value)
{
throw new NotSupportedException();
}
public bool ContainsKey(int key)
{
return key >= 0 && key < _array.Length;
}
public ICollection<int> Keys
{
get { return Enumerable.Range(0, _array.Length).ToArray(); }
}
public bool Remove(int key)
{
throw new NotSupportedException();
}
public bool TryGetValue(int key, out string value)
{
value = null;
if (key >= 0 && key < _array.Length)
{
value = _array[key];
return true;
}
return false;
}
public ICollection<string> Values
{
get { return _array; }
}
public string this[int key]
{
get
{
try
{
return _array[key];
}
catch (ArgumentOutOfRangeException ex)
{
throw new KeyNotFoundException("Invalid key", ex);
}
}
set //note - can't be used to add items
{
try
{
_array[key] = value;
}
catch (ArgumentOutOfRangeException ex)
{
throw new KeyNotFoundException("Invalid key", ex);
}
}
}
#endregion
#region ICollection<KeyValuePair<int,string>> Members
public void Add(KeyValuePair<int, string> item)
{
throw new NotSupportedException();
}
public void Clear()
{
throw new NotSupportedException();
}
public bool Contains(KeyValuePair<int, string> item)
{
return ContainsKey(item.Key) && _array[item.Key].Equals(item.Value);
}
public void CopyTo(KeyValuePair<int, string>[] array, int arrayIndex)
{
//too much for an SO answer.
throw new NotImplementedException();
}
public int Count
{
get { return _array.Length; }
}
public bool IsReadOnly
{
//technically it's not - because we can modify individual elements -
//but at the collection-level it is
get { return true; }
}
public bool Remove(KeyValuePair<int, string> item)
{
throw new NotSupportedException();
}
#endregion
#region IEnumerable<KeyValuePair<int,string>> Members
public IEnumerator<KeyValuePair<int, string>> GetEnumerator()
{
throw new NotImplementedException();
}
#endregion
#region IEnumerable Members
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
throw new NotImplementedException();
}
#endregion
}