Bir foreach döngüsünün geçerli yinelemesinin dizinini nasıl elde edersiniz?

Bir foreach döngüsünün geçerli yinelemesini temsil eden bir değer elde etmek için C # 'da karşılaştığım nadir bir dil yapısı var mı (yakın zamanda öğrendiğim birkaç, Stack Overflow'da bazıları gibi)?

Örneğin, şu anda koşullara bağlı olarak böyle bir şey yapmak:

int i = 0;
foreach (Object o in collection)
{
    // ...
    i++;
}

foreachUygulamak koleksiyonları yineleme içindir IEnumerable. Bunu, GetEnumeratordöndürülecek koleksiyonu arayarak yapar Enumerator.

Bu Numaralandırıcı bir yöntem ve bir özelliğe sahiptir:

• MoveNext'in ()
• şimdiki

CurrentNumaralandırıcı'nın şu anda açık olduğu nesneyi döndürür, bir sonraki nesneye MoveNextgüncellenir Current.

Bir endeks kavramı numaralandırma kavramına yabancıdır ve yapılamaz.

Bu nedenle, çoğu koleksiyon bir dizinleyici ve for döngü yapısı kullanılarak çaprazlanabilir.

Büyük ölçüde yerel bir değişken ile dizin izleme karşılaştırıldığında bu durumda bir for döngüsü kullanmayı tercih ederim.

Ian Mercer, Phil Haack'in blogunda buna benzer bir çözüm yayınladı :

foreach (var item in Model.Select((value, i) => new { i, value }))
{
    var value = item.value;
    var index = item.i;
}

Bu , LINQ'ların aşırı yüklenmesini kullanarak item ( item.value) ve index ( item.i) değerlerini alır :Select

[Select Select] fonksiyonunun ikinci parametresi kaynak elemanın dizinini temsil eder.

new { i, value }Yeni yaratıyor anonim nesne .

ValueTupleC # 7.0 veya üstünü kullanıyorsanız yığın ayırmalarını kullanarak önlenebilir :

foreach (var item in Model.Select((value, i) => ( value, i )))
{
    var value = item.value;
    var index = item.i;
}

Ayrıca item.otomatik yıkımı kullanarak da ortadan kaldırabilirsiniz :

<ol>
foreach ((MyType value, Int32 i) in Model.Select((value, i) => ( value, i )))
{
    <li id="item_@i">@value</li>
}
</ol>

Son olarak C # 7, bir foreachdöngü içinde bir dizin (yani, tuples) almak için iyi bir sözdizimine sahiptir :

foreach (var (item, index) in collection.WithIndex())
{
    Debug.WriteLine($"{index}: {item}");
}

Küçük bir uzatma yöntemi gerekli olacaktır:

public static IEnumerable<(T item, int index)> WithIndex<T>(this IEnumerable<T> self)       
   => self.Select((item, index) => (item, index)); 

Böyle bir şey yapabilirdi:

public static class ForEachExtensions
{
    public static void ForEachWithIndex<T>(this IEnumerable<T> enumerable, Action<T, int> handler)
    {
        int idx = 0;
        foreach (T item in enumerable)
            handler(item, idx++);
    }
}

public class Example
{
    public static void Main()
    {
        string[] values = new[] { "foo", "bar", "baz" };

        values.ForEachWithIndex((item, idx) => Console.WriteLine("{0}: {1}", idx, item));
    }
}

forÇoğu durumda bir döngünün daha iyi bir seçim olduğuna dair yorumlara katılmıyorum .

foreachyararlı bir yapıdır ve forher durumda bir döngü ile değiştirilemez.

Örneğin, bir DataReader'ınız varsa ve foreachbunu kullanarak tüm kayıtlar arasında geçiş yaparsanız, otomatik olarak Dispose yöntemini çağırır ve okuyucuyu kapatır (bu daha sonra bağlantıyı otomatik olarak kapatabilir). Bu nedenle, okuyucuyu kapatmayı unutsanız bile bağlantı sızıntılarını önlediğinden daha güvenlidir.

(Her zaman okuyucuları kapatmak iyi bir uygulamadır, ancak derleyici bunu yapmazsanız yakalayamaz - tüm okuyucuları kapattığınızı garanti edemezsiniz, ancak bağlantı alarak sızıntı yapmayacağınızı daha olası hale getirebilirsiniz. foreach kullanma alışkanlığında.)

DisposeYöntemin yararlı olduğuna ilişkin örtülü çağrının başka örnekleri olabilir .

Değişmez Yanıt - uyarı, performans yalnızca intdizini izlemek için a kullanmak kadar iyi olmayabilir . En azından kullanmaktan daha iyidir IndexOf.

Koleksiyondaki her öğeyi dizini bilen anonim bir nesneyle sarmak için Select'in aşırı yükleme aşırı yükünü kullanmanız yeterlidir. Bu, IEnumerable uygulayan her şeye karşı yapılabilir.

System.Collections.IEnumerable collection = Enumerable.Range(100, 10);

foreach (var o in collection.OfType<object>().Select((x, i) => new {x, i}))
{
    Console.WriteLine("{0} {1}", o.i, o.x);
}

LINQ, C # 7 ve System.ValueTupleNuGet paketini kullanarak şunları yapabilirsiniz:

foreach (var (value, index) in collection.Select((v, i)=>(v, i))) {
    Console.WriteLine(value + " is at index " + index);
}

Normal foreachyapıyı kullanabilir ve bir nesnenin üyesi olarak değil, değere ve dizine doğrudan erişebilirsiniz ve her iki alanı da yalnızca döngü kapsamında tutar. Bu nedenlerle, C # 7 ve kullanabiliyorsanız bunun en iyi çözüm olduğuna inanıyorum System.ValueTuple.

@ FlySwat'ın cevabını kullanarak şu çözümü buldum:

//var list = new List<int> { 1, 2, 3, 4, 5, 6 }; // Your sample collection

var listEnumerator = list.GetEnumerator(); // Get enumerator

for (var i = 0; listEnumerator.MoveNext() == true; i++)
{
  int currentItem = listEnumerator.Current; // Get current item.
  //Console.WriteLine("At index {0}, item is {1}", i, currentItem); // Do as you wish with i and  currentItem
}

Numaralandırıcıyı alırsınız GetEnumeratorve sonra bir döngü kullanarak fordöngü yaparsınız . Ancak, püf noktası döngünün durumunu yapmaktır listEnumerator.MoveNext() == true.

Yana MoveNextorada bir sonraki unsurdur ve biz tekrarlatacak elemanların bitince döngü koşulu döngü Dur yapar hale ulaşılabilir true sayimm getiri yöntemi.

Bir sayaç değişkeni kullanmanın yanlış bir yanı yoktur. Aslında, kullanmak ister for, foreach whileya dobir karşı değişken bir yere ilan ve artmalıdır.

Bu nedenle, uygun şekilde dizine eklenmiş bir koleksiyonunuz olduğundan emin değilseniz bu deyimi kullanın:

var i = 0;
foreach (var e in collection) {
   // Do stuff with 'e' and 'i'
   i++;
}

Else kullanımı bu bir sen eğer biliyorum senin o dizine eklenebilir toplama endeksi erişimi için O (1) 'dir (onun için olacak Arrayve muhtemelen için List<T>(dokümantasyon demiyor), şart olmamakla birlikte (örneğin diğer türleri için LinkedList)):

// Hope the JIT compiler optimises read of the 'Count' property!
for (var i = 0; i < collection.Count; i++) {
   var e = collection[i];
   // Do stuff with 'e' and 'i'
}

IEnumeratorÇağırma MoveNext()ve sorgulama yoluyla 'elle' çalıştırmak asla gerekli olmamalıdır Current- foreachbu özel rahatsızlığı kurtarıyor ... öğeleri atlamanız gerekiyorsa, sadece continuedöngü gövdesinde bir kullanın .

Ve sadece şeyiyle, sen ne bağlı yapıyor endeksinize, sen Paralel LINQ kullanmak olabilir (yukarıdaki yapılar esneklik bol sunuyoruz):

// First, filter 'e' based on 'i',
// then apply an action to remaining 'e'
collection
    .AsParallel()
    .Where((e,i) => /* filter with e,i */)
    .ForAll(e => { /* use e, but don't modify it */ });

// Using 'e' and 'i', produce a new collection,
// where each element incorporates 'i'
collection
    .AsParallel()
    .Select((e, i) => new MyWrapper(e, i));

Biz kullanmak AsParallel()zaten 2014 çünkü, yukarıda ve biz hız süslemeye bu çoklu çekirdek en iyi şekilde yapmak istiyorum. Ayrıca, 'sıralı' LINQ için, sadece bir ForEach()uzatma yöntemi alırsınız List<T>veArray ... ve foreachçirkin sözdizimi için hala tek iş parçacıklı çalıştığınız için bunu kullanmanın basit bir işlem yapmaktan daha iyi olduğu açık değildir .

Orijinal numaralandırıcıyı, dizin bilgilerini içeren başka bir numarayla sarabilirsiniz.

foreach (var item in ForEachHelper.WithIndex(collection))
{
    Console.Write("Index=" + item.Index);
    Console.Write(";Value= " + item.Value);
    Console.Write(";IsLast=" + item.IsLast);
    Console.WriteLine();
}

İşte ForEachHelpersınıfın kodu .

public static class ForEachHelper
{
    public sealed class Item<T>
    {
        public int Index { get; set; }
        public T Value { get; set; }
        public bool IsLast { get; set; }
    }

    public static IEnumerable<Item<T>> WithIndex<T>(IEnumerable<T> enumerable)
    {
        Item<T> item = null;
        foreach (T value in enumerable)
        {
            Item<T> next = new Item<T>();
            next.Index = 0;
            next.Value = value;
            next.IsLast = false;
            if (item != null)
            {
                next.Index = item.Index + 1;
                yield return item;
            }
            item = next;
        }
        if (item != null)
        {
            item.IsLast = true;
            yield return item;
        }            
    }
}

İşte bu sorun için yeni bulduğum bir çözüm

Orijinal kod:

int index=0;
foreach (var item in enumerable)
{
    blah(item, index); // some code that depends on the index
    index++;
}

Güncellenmiş kod

enumerable.ForEach((item, index) => blah(item, index));

Genişletme Yöntemi:

    public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enumerable, Action<T, int> action)
    {
        var unit = new Unit(); // unit is a new type from the reactive framework (http://msdn.microsoft.com/en-us/devlabs/ee794896.aspx) to represent a void, since in C# you can't return a void
        enumerable.Select((item, i) => 
            {
                action(item, i);
                return unit;
            }).ToList();

        return pSource;
    }

Sadece kendi indeksinizi ekleyin. Basit tutun.

int i = 0;
foreach (var item in Collection)
{
    item.index = i;
    ++i;
}

Herhangi bir IEnumerable için değil, sadece bir Liste için çalışacak, ancak LINQ'da şu var:

IList<Object> collection = new List<Object> { 
    new Object(), 
    new Object(), 
    new Object(), 
    };

foreach (Object o in collection)
{
    Console.WriteLine(collection.IndexOf(o));
}

Console.ReadLine();

@Jonathan Harika bir cevap olduğunu söylemedim, sadece sorduğunu yapmanın mümkün olduğunu gösterdim dedim :)

@Graphain Hızlı olmasını beklemiyordum - Nasıl çalıştığından tam olarak emin değilim, karşılaştırmalar helluvalotu olacak eşleşen bir nesne bulmak için her seferinde tüm listeyi tekrarlayabilir.

Bununla birlikte, List, sayımla birlikte her nesnenin bir dizinini tutabilir.

Jonathan daha ayrıntılı bir fikre sahip gibi gözüküyor, eğer detaylandırırsa?

Öte yandan, her yerde daha basit, daha basit ve daha uyarlanabilir bir yerde kalmak daha iyi olur.

C # 7 nihayet bize bunu yapmanın zarif bir yolunu sunuyor:

static class Extensions
{
    public static IEnumerable<(int, T)> Enumerate<T>(
        this IEnumerable<T> input,
        int start = 0
    )
    {
        int i = start;
        foreach (var t in input)
        {
            yield return (i++, t);
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        var s = new string[]
        {
            "Alpha",
            "Bravo",
            "Charlie",
            "Delta"
        };

        foreach (var (i, t) in s.Enumerate())
        {
            Console.WriteLine($"{i}: {t}");
        }
    }
}

Neden foreach ?!

List kullanıyorsanız foreach yerine for yöntemini kullanmak en basit yöntemdir :

for (int i = 0 ; i < myList.Count ; i++)
{
    // Do something...
}

Veya foreach kullanmak istiyorsanız:

foreach (string m in myList)
{
     // Do something...
}

Her döngünün dizinini bilmek için bunu kullanabilirsiniz:

myList.indexOf(m)

int index;
foreach (Object o in collection)
{
    index = collection.indexOf(o);
}

Bu destekleyici koleksiyonlar için işe yarar IList.

Bu şekilde yapıyorum, basitliği / kısalığı için güzel, ancak döngü gövdesinde çok şey yapıyorsanız obj.Value, oldukça hızlı bir şekilde eski olacak.

foreach(var obj in collection.Select((item, index) => new { Index = index, Value = item }) {
    string foo = string.Format("Something[{0}] = {1}", obj.Index, obj.Value);
    ...
}

Bu cevap: doğrudan dil desteği için C # dil ekibinin lobisini yapın.

Başlıca cevap şöyle diyor:

Açıkçası, bir endeks kavramı numaralandırma kavramına yabancıdır ve yapılamaz.

Bu, mevcut C # dil sürümü (2020) için geçerli olsa da, bu kavramsal bir CLR / Dil sınırı değildir, yapılabilir.

Microsoft C # dil geliştirme ekibi, yeni bir Interface IIndexedEnumerable için destek ekleyerek yeni bir C # dili özelliği oluşturabilir

foreach (var item in collection with var index)
{
    Console.WriteLine("Iteration {0} has value {1}", index, item);
}

//or, building on @user1414213562's answer
foreach (var (item, index) in collection)
{
    Console.WriteLine("Iteration {0} has value {1}", index, item);
}

foreach ()Kullanılırsa ve varsa , with var indexderleyici öğe koleksiyonunun IIndexedEnumerablearabirimi bildirmesini bekler . Arabirim yoksa, derleyici, kaynağı, dizini izleme koduna ekleyen bir IndexedEnumerable nesnesiyle çok dolgu yapabilir.

interface IIndexedEnumerable<T> : IEnumerable<T>
{
    //Not index, because sometimes source IEnumerables are transient
    public long IterationNumber { get; }
}

Daha sonra CLR, yalnızca withanahtar kelime belirtildiğinde ve kaynak doğrudan uygulanmıyorsa kullanılan dahili dizin izlemeye sahip olacak şekilde güncellenebilirIIndexedEnumerable

Neden:

• Foreach daha hoş görünüyor ve iş uygulamalarında, foreach döngüleri nadiren bir performans darboğazıdır
• Foreach bellekte daha verimli olabilir. Her adımda yeni koleksiyonlara dönüştürmek yerine bir işlevler hattına sahip olmak. Daha az CPU önbellek hatası ve daha az çöp toplama olduğunda birkaç CPU döngüsü kullanıp kullanmadığını kim takar?
• Kodlayıcının dizin izleme kodu eklemesini gerektiren, güzelliği bozar
• Uygulanması oldukça kolaydır (lütfen Microsoft) ve geriye dönük olarak uyumludur

Çoğu insan burada Microsoft çalışanları olmasa da, bu bir doğru cevap, bu tür bir özellik eklemek Microsoft kulis edebilirsiniz. Bir uzantı işleviyle zaten kendi yineleyicinizi oluşturabilir ve tuples kullanabilirsiniz , ancak Microsoft, uzantı işlevinden kaçınmak için sözdizimsel şekeri serpebilir

Koleksiyon bir listeyse, List.IndexOf komutunu aşağıdaki gibi kullanabilirsiniz:

foreach (Object o in collection)
{
    // ...
    @collection.IndexOf(o)
}

Anahtar kelime continuegüvenli yapı kullanmak daha iyidir

int i=-1;
foreach (Object o in collection)
{
    ++i;
    //...
    continue; //<--- safe to call, index will be increased
    //...
}

Döngünüzü şöyle yazabilirsiniz:

var s = "ABCDEFG";
foreach (var item in s.GetEnumeratorWithIndex())
{
    System.Console.WriteLine("Character: {0}, Position: {1}", item.Value, item.Index);
}

Aşağıdaki yapı ve uzatma yöntemini ekledikten sonra.

Yapı ve uzantı yöntemi, Numaralandırılabilir'i kapsar.

public struct ValueWithIndex<T>
{
    public readonly T Value;
    public readonly int Index;

    public ValueWithIndex(T value, int index)
    {
        this.Value = value;
        this.Index = index;
    }

    public static ValueWithIndex<T> Create(T value, int index)
    {
        return new ValueWithIndex<T>(value, index);
    }
}

public static class ExtensionMethods
{
    public static IEnumerable<ValueWithIndex<T>> GetEnumeratorWithIndex<T>(this IEnumerable<T> enumerable)
    {
        return enumerable.Select(ValueWithIndex<T>.Create);
    }
}

Bu soruna yönelik çözümüm bir uzantı yöntemi WithIndex(),

http://code.google.com/p/ub-dotnet-utilities/source/browse/trunk/Src/Utilities/Extensions/EnumerableExtensions.cs

Gibi kullanın

var list = new List<int> { 1, 2, 3, 4, 5, 6 };    

var odd = list.WithIndex().Where(i => (i.Item & 1) == 1);
CollectionAssert.AreEqual(new[] { 0, 2, 4 }, odd.Select(i => i.Index));
CollectionAssert.AreEqual(new[] { 1, 3, 5 }, odd.Select(i => i.Item));

İlgi için, Phil Haack bunun bir örneğini Razor Templated Temsilcisi bağlamında yazdı ( http://haacked.com/archive/2011/04/14/a-better-razor-foreach-loop.aspx )

Etkili bir şekilde yineleme bir "IteratedItem" sınıfında saran bir uzantı yöntemi yazar (aşağıya bakın), hem dizin hem de yineleme sırasında öğeye erişim sağlar.

public class IndexedItem<TModel> {
  public IndexedItem(int index, TModel item) {
    Index = index;
    Item = item;
  }

  public int Index { get; private set; }
  public TModel Item { get; private set; }
}

Bununla birlikte, tek bir işlem (yani lambda olarak sağlanabilen bir işlem) yapıyorsanız, Razor olmayan bir ortamda iyi olurken, Razor olmayan bağlamlarda for / foreach sözdiziminin sağlam bir yedeği olmayacaktır. .

Bunun oldukça verimli olması gerektiğini düşünmüyorum, ama işe yarıyor:

@foreach (var banner in Model.MainBanners) {
    @Model.MainBanners.IndexOf(banner)
}

Bunu LINQPad'de oluşturdum :

var listOfNames = new List<string>(){"John","Steve","Anna","Chris"};

var listCount = listOfNames.Count;

var NamesWithCommas = string.Empty;

foreach (var element in listOfNames)
{
    NamesWithCommas += element;
    if(listOfNames.IndexOf(element) != listCount -1)
    {
        NamesWithCommas += ", ";
    }
}

NamesWithCommas.Dump();  //LINQPad method to write to console.

Ayrıca string.joinşunları da kullanabilirsiniz :

var joinResult = string.Join(",", listOfNames);

Bir foreach döngüsünün mevcut yinelemesinin değerini almanın bir yolu olduğuna inanmıyorum. Kendinizi saymak, en iyi yol gibi görünüyor.

Neden bilmek istersiniz diye sorabilir miyim?

Görünüşe göre en çok üç şeyden birini yapıyor olacaksınız:

1) Nesneyi koleksiyondan almak, ancak bu durumda zaten var.

2) Nesneleri daha sonra işlemek için saymak ... koleksiyonlarda kullanabileceğiniz bir Count özelliği vardır.

3) Nesnedeki bir özelliği döngüdeki sırasına göre ayarlama ... buna rağmen nesneyi koleksiyona eklediğinizde kolayca ayarlayabilirsiniz.

Koleksiyonunuz nesnenin dizinini bir yöntemle döndüremediği sürece, tek yol örneğinizdeki gibi bir sayaç kullanmaktır.

Ancak, dizinlerle çalışırken, sorunun tek makul cevabı bir for döngüsü kullanmaktır. Başka herhangi bir şey zaman ve mekan karmaşıklığından bahsetmemek yerine kod karmaşıklığı getirir.

Böyle bir şeye ne dersin? MyEnumerable boşsa, myDelimitedString öğesinin boş olabileceğini unutmayın.

IEnumerator enumerator = myEnumerable.GetEnumerator();
string myDelimitedString;
string current = null;

if( enumerator.MoveNext() )
    current = (string)enumerator.Current;

while( null != current)
{
    current = (string)enumerator.Current; }

    myDelimitedString += current;

    if( enumerator.MoveNext() )
        myDelimitedString += DELIMITER;
    else
        break;
}

Sadece bu problemi yaşadım, ancak benim durumumdaki problemi düşünmek, beklenen çözümle ilgisiz en iyi çözümü verdi.

Oldukça yaygın bir durum olabilir, temel olarak, bir kaynak listesinden okuyorum ve bir hedef listesinde bunlara dayalı nesneler oluşturuyorum, ancak, önce kaynak öğelerin geçerli olup olmadığını kontrol etmek ve herhangi bir satırını döndürmek istiyorum hata. İlk bakışta, Current özelliğindeki nesnenin numaralandırıcısına dizin almak istiyorum, ancak, bu öğeleri kopyaladığım için, geçerli dizini zaten geçerli hedeften dolaylı olarak biliyorum. Açıkçası hedef nesnenize bağlıdır, ama benim için bir Liste'ydi ve büyük olasılıkla ICollection'ı uygulayacak.

yani

var destinationList = new List<someObject>();
foreach (var item in itemList)
{
  var stringArray = item.Split(new char[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries);

  if (stringArray.Length != 2)
  {
    //use the destinationList Count property to give us the index into the stringArray list
    throw new Exception("Item at row " + (destinationList.Count + 1) + " has a problem.");
  }
  else
  {
    destinationList.Add(new someObject() { Prop1 = stringArray[0], Prop2 = stringArray[1]});
  }
}

Her zaman uygulanabilir değil, ancak bahsetmeye değer çoğu zaman yeterli.

Her neyse, mesele şu ki bazen mantığınızda zaten belli olmayan bir çözüm var ...

Soruya dayalı dizin bilgileri ile ne yapmaya çalıştığınızdan emin değildim. Ancak, C # 'da, genellikle IEnumerable.Select yöntemini kullanarak dizini istediğiniz her şeyden çıkarabilirsiniz. Örneğin, bir değerin tek veya çift olması gibi bir şey kullanabilirim.

string[] names = { "one", "two", "three" };
var oddOrEvenByName = names
    .Select((name, index) => new KeyValuePair<string, int>(name, index % 2))
    .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);

Bu, öğenin listede tek (1) veya çift (0) olup olmadığına göre adıyla bir sözlük verir.