Чего лучший способ состоит в том, чтобы выполнить итерации через универсальный Список со строгим контролем типов <T>?

Для VB.NET:

For Each tmpObject as ObjectType in ObjectTypeList
    'Do some stuff '
Next

С любой универсальной реализацией IEnumerable лучший способ:

//C#
foreach( var item in listVariable) {
    //do stuff
}

существует важное исключение как бы то ни было. IEnumerable включает издержки Текущих () и MoveNext (), в именно это на самом деле компилируется цикл foreach.

, Когда у Вас есть простой массив структур:

//C#
int[] valueTypeArray;
for(int i=0; i < valueTypeArray.Length; ++i) {
     int item = valueTypeArray[i];
     //do stuff
}

более быстро.

Обновление

После обсуждения с @Steven Sudit (см. комментарии) я думаю, что мой исходный совет может устареть или может быть ошибочным, таким образом, я запустил некоторые тесты:

// create a list to test with
var theList = Enumerable.Range(0, 100000000).ToList();

// time foreach
var sw = Stopwatch.StartNew();
foreach (var item in theList)
{
    int inLoop = item;
}
Console.WriteLine("list  foreach: " + sw.Elapsed.ToString());

sw.Reset();
sw.Start();

// time for
int cnt = theList.Count;
for (int i = 0; i < cnt; i++)
{
    int inLoop = theList[i];
}
Console.WriteLine("list  for    : " + sw.Elapsed.ToString());

// now run the same tests, but with an array
var theArray = theList.ToArray();

sw.Reset();
sw.Start();

foreach (var item in theArray)
{
    int inLoop = item;
}
Console.WriteLine("array foreach: " + sw.Elapsed.ToString());

sw.Reset();
sw.Start();

// time for
cnt = theArray.Length;
for (int i = 0; i < cnt; i++)
{
    int inLoop = theArray[i];
}
Console.WriteLine("array for    : " + sw.Elapsed.ToString());

Console.ReadKey();

Так, я выполнил это в выпуске со всеми оптимизациями:

list  foreach: 00:00:00.5137506
list  for    : 00:00:00.2417709
array foreach: 00:00:00.1085653
array for    : 00:00:00.0954890

И затем отлаживают без оптимизаций:

list  foreach: 00:00:01.1289015
list  for    : 00:00:00.9945345
array foreach: 00:00:00.6405422
array for    : 00:00:00.4913245

, Таким образом, это кажется довольно последовательным, for, более быстро, чем foreach, и массивы более быстры, чем универсальные списки.

Однако это через 100 000 000 повторений, и различием являются приблизительно.4 из секунды между самыми быстрыми и самыми медленными методами. Если Вы не делаете крупную производительность критические циклы, об этом просто не стоит вызывать беспокойство.

Я могу пропускать что-то, но выполнять итерации через универсальный список, должно быть довольно простым, если Вы используете мои примеры ниже. List<> класс реализует IList и интерфейсы IEnumerable так, чтобы можно было легко выполнить итерации через них в основном любого способа, которым Вы хотите.

самый эффективный путь состоял бы в том, чтобы использовать для цикла:

for(int i = 0; i < genericList.Count; ++i) 
{
     // Loop body
}

можно также принять решение использовать цикл foreach:

foreach(<insertTypeHere> o in genericList)
{
    // Loop body
}

Это зависит от Вашего приложения:

• для цикла, если эффективность является приоритетом
• цикл foreach или метод ForEach, какой бы ни передает Ваше намерение более ясно

C#

myList<string>().ForEach(
    delegate(string name)
    {
        Console.WriteLine(name);
    });

Анонимные делегаты в настоящее время не реализуются в VB.Net, но и C# и VB.Net, должен быть в состоянии сделать лямбды:

<час> C#

myList<string>().ForEach(name => Console.WriteLine(name));

VB.Net

myList(Of String)().ForEach(Function(name) Console.WriteLine(name))

Как Grauenwolf, на который указывают вышеупомянутое, VB не скомпилирует, так как лямбда не возвращает значение. Нормальный Цикл foreach как другие предложил, является, вероятно, самым легким на данный момент, но как обычно он берет блок кода, чтобы сделать то, что C# может сделать в одной строке.

Вот банальный пример того, почему это могло бы быть полезно: это дает Вам способность передать в логике цикла от другого объема, чем, где IEnumerable существует, таким образом, Вы не должны даже представлять его, если Вы не хотите.

Говорят, что у Вас есть список относительных путей URL, которые Вы хотите сделать абсолютным:

public IEnumerable<String> Paths(Func<String> formatter) {
    List<String> paths = new List<String>()
    {
        "/about", "/contact", "/services"
    };

    return paths.ForEach(formatter);
}

Таким образом Вы могли вызвать функцию этот путь:

var hostname = "myhost.com";
var formatter = f => String.Format("http://{0}{1}", hostname, f);
IEnumerable<String> absolutePaths = Paths(formatter);

Предоставление Вы "http://myhost.com/about", "http://myhost.com/contact" и т.д., Очевидно, существуете лучшие способы выполнить это в этом specfic примере, я просто пытаюсь продемонстрировать основной принцип.

Не зная внутреннюю реализацию списка, я обычно думаю, что лучшим способом выполнить итерации по ней был бы цикл foreach. Поскольку foreach использует IEnumerator для технической победы список, это до самого списка, чтобы определить, как переместиться от объекта до объекта.

, Если бы внутренняя реализация была, скажем, связанным списком, то простое для цикла было бы вполне немного медленнее, чем foreach.

, который имеет смысл?