IEnumerable “Durum Makinelerini” Tespit Etme

Ben sadece c # verim dönüşü ile çok şirin Başlarken adlı ilginç bir makale okudum

Bir IEnumerable'ın gerçek bir numaralandırılabilir koleksiyon olup olmadığını veya verim anahtar kelimesi ile oluşturulan bir durum makinesi olup olmadığını tespit etmenin en iyi yolunun ne olduğunu merak etmemi sağladı.

Örneğin, DoubleXValue'yu (makaleden) aşağıdaki gibi değiştirebilirsiniz:

private void DoubleXValue(IEnumerable<Point> points)
{
    if(points is List<Point>)
      foreach (var point in points)
        point.X *= 2;
    else throw YouCantDoThatException();
}

Soru 1) Bunu yapmanın daha iyi bir yolu var mı?

Soru 2) Bu bir API oluştururken endişelenmem gereken bir şey mi?

Sorunuz, anladığım kadarıyla, yanlış bir önermeye dayanıyor gibi görünüyor. Bakalım akıl yürütmeyi yeniden yapılandırabilir miyim:

• Bağlantılı makale, otomatik olarak oluşturulan sekansların nasıl "tembel" bir davranış sergilediğini ve bunun nasıl sezgisel bir sonuca yol açabileceğini gösterir.
• Bu nedenle, belirli bir IEnumerable örneğinin otomatik olarak oluşturulup oluşturulmadığını kontrol ederek bu tembel davranışı gösterip göstermeyeceğini tespit edebilirim.
• Bunu nasıl yaparım?

Sorun, ikinci öncülün yanlış olmasıdır. Belirli bir IEnumerable'ın bir yineleyici blok dönüşümünün sonucu olup olmadığını tespit edebilseniz bile (ve evet, bunu yapmanın yolları vardır) varsayım yanlış olduğu için yardımcı olmaz. Nedenini açıklayalım.

class M { public int P { get; set; } }
class C
{
  public static IEnumerable<M> S1()
  {
    for (int i = 0; i < 3; ++i) 
      yield return new M { P = i };
  }

  private static M[] ems = new M[] 
  { new M { P = 0 }, new M { P = 1 }, new M { P = 2 } };
  public static IEnumerable<M> S2()
  {
    for (int i = 0; i < 3; ++i)
      yield return ems[i];
  }

  public static IEnumerable<M> S3()
  {
    return new M[] 
    { new M { P = 0 }, new M { P = 1 }, new M { P = 2 } };
  }

  private class X : IEnumerable<M>
  {
    public IEnumerator<X> GetEnumerator()
    {
      return new XEnum();
    }
    // Omitted: non generic version
    private class XEnum : IEnumerator<X>
    {
      int i = 0;
      M current;
      public bool MoveNext()
      {
        current = new M() { P = i; }
        i += 1;
        return true;
      }
      public M Current { get { return current; } }
      // Omitted: other stuff.
    }
  }

  public static IEnumerable<M> S4()
  {
    return new X();
  }

  public static void Add100(IEnumerable<M> items)
  {
    foreach(M item in items) item.P += 100;
  }
}

Pekala, dört yöntemimiz var. S1 ve S2 otomatik olarak oluşturulan dizilerdir; S3 ve S4, manuel olarak oluşturulan dizilerdir. Şimdi varsayalım:

var items = C.Sn(); // S1, S2, S3, S4
S.Add100(items);
Console.WriteLine(items.First().P);

S1 ve S4 için sonuç 0 olacaktır; diziyi her numaralandırdığınızda, oluşturulan bir M'ye yeni bir referans alırsınız. S2 ve S3 için sonuç 100 olacaktır; diziyi her numaralandırdığınızda, M'ye aynı referansı son kez alırsınız. Sıralama kodunun otomatik olarak oluşturulup oluşturulmadığı, numaralandırılan nesnelerin referans kimliğine sahip olup olmadığı sorusuyla dikeydir. Bu iki özelliğin - otomatik üretim ve referans kimlik - aslında birbirleriyle hiçbir ilgisi yoktur. Bağlantı verdiğiniz makale onları biraz karıştırıyor.

Bir sekans sağlayıcısı, her zaman referans kimliğine sahip nesneleri önermiş olarak belgelenmedikçe , bunu kabul ettiği akılsızdır.

Bence anahtar kavram, herhangi bir IEnumerable<T>koleksiyonu değişmez olarak ele almanız gerektiğidir: ondan nesneleri değiştirmemelisiniz, yeni nesnelerle yeni bir koleksiyon oluşturmalısınız:

private IEnumerable<Point> DoubleXValue(IEnumerable<Point> points)
{
    foreach (var point in points)
        yield return new Point(point.X * 2, point.Y);
}

(Ya da aynısını LINQ kullanarak daha özlü bir şekilde yazın Select().)

Koleksiyondaki öğeleri gerçekten değiştirmek istiyorsanız, kullanmayın IEnumerable<T>, kullanın IList<T>(veya IReadOnlyList<T>koleksiyonun kendisini, yalnızca içindeki öğeleri değiştirmek istemiyorsanız ve .Net 4.5'deyseniz):

private void DoubleXValue(IList<Point> points)
{
    foreach (var point in points)
        point.X *= 2;
}

Bu şekilde, birisi yönteminizi kullanmaya çalışırsa IEnumerable<T>derleme sırasında başarısız olur.

Ben şahsen bu makalede vurgulanan sorunun IEnumerablebugünlerde birçok C # geliştiricileri tarafından arayüzü aşırı kullanımdan kaynaklandığını düşünüyorum . Nesnelerin bir koleksiyonuna ihtiyaç duyduğunuzda varsayılan tür haline gelmiş gibi görünüyor - ancak IEnumerablesize söylemeyen çok fazla bilgi var ... çok önemli: yeniden yapılandırılmış olsun ya da olmasın *.

An'ın gerçekten bir veya başka bir şey olup olmadığını tespit etmeniz gerektiğini fark ederseniz , soyutlama sızdı ve muhtemelen parametre türünüzün biraz fazla gevşek olduğu bir durumdasınız. Tek başına sağlanmayan ek bilgilere ihtiyacınız varsa veya gibi diğer arabirimlerden birini seçerek bu gereksinimi açıkça belirtin .IEnumerableIEnumerableIEnumerableICollectionIList

Downvoters için düzenleyin Lütfen geri dönün ve soruyu dikkatlice okuyun. OP, IEnumerableAPI yöntemine geçirilmeden önce örneklerin gerçekleştirildiğinden emin olmak için bir yol istemektedir . Cevabım bu soruyu ele alıyor. Doğru kullanım yolu ile ilgili daha geniş bir sorun var IEnumerableve kesinlikle OP'nin yapıştırdığı kodun beklentileri bu daha geniş sorunun yanlış anlaşılmasına dayanıyor, ancak OP doğru şekilde nasıl kullanılacağını IEnumerableveya değişmez türlerle nasıl çalışılacağını sormadı . Sorulmamış bir soruyu cevaplamadığım için beni aşağılamak adil değil.

* Terimini kullanıyorum reify, diğerleri stabilizeveya materialize. Topluluk tarafından henüz ortak bir konvansiyonun kabul edildiğini sanmıyorum.