NOT: Bu gönderi çok daha ayrıntılı hale geldi ve bu nedenle konu dışı, özür dilerim.
Bununla birlikte, arkadaşlarım bunu okudu ve 'bir yerde' değerli olduğuna inandılar. Bu konu yer değil. Bunun nereye gitmesi gerektiğiyle ilgili görüşlerinizi takdir ediyorum (bu sitede yeniyim).
Her neyse, bu .NET 3.5'teki C # sürümüdür ve tanımlanmış semantiği kullanan herhangi bir koleksiyon türü üzerinde çalışması şaşırtıcıdır. Bu, çoğu yaygın geliştirme senaryosunda performans veya CPU döngüsü minimizasyonu değil, varsayılan bir ölçüdür (yeniden kullanım!), Ancak gerçek dünyada asla böyle görünmüyor (erken optimizasyon).
*** Uzantı yöntemi, herhangi bir koleksiyon türü üzerinde çalışan ve türün tek bir değerini bekleyen bir eylem temsilcisi gerçekleştiren, tümü her öğe üzerinde tersten uygulandı **
3.5 Gereksinimleri:
public static void PerformOverReversed<T>(this IEnumerable<T> sequenceToReverse, Action<T> doForEachReversed)
{
foreach (var contextItem in sequenceToReverse.Reverse())
doForEachReversed(contextItem);
}
Daha eski .NET sürümleri veya Linq'in iç özelliklerini daha iyi anlamak ister misiniz? Okuyun .. Ya da değil ..
VARSAYIM: .NET türü sistemde, Dizi türü IEnumerable arabiriminden miras alır (genel IEnumerable yalnızca IEnumerable değil).
Baştan sona yinelemeniz gereken tek şey bu, ancak ters yönde ilerlemek istiyorsunuz. IEnumerable, 'nesne' türündeki Array üzerinde çalıştığından, herhangi bir tür geçerlidir,
KRİTİK ÖLÇÜ: Herhangi bir diziyi ters sırayla işleyebildiğinizi varsayıyoruz ki bu 'daha iyi', o zaman bunu sadece tamsayılar üzerinde yapabileceksiniz.
.NET CLR 2.0-3.0 için çözüm a:
Açıklama: İçerdiği her bir örneğin aynı türde olması yetkisine sahip herhangi bir IEnumerable uygulama örneğini kabul edeceğiz. Yani bir dizi alırsak, dizinin tamamı X tipi örnekleri içerir.! = X türünde başka örnekler varsa bir istisna atılır:
Tekil hizmet:
public class ReverserService {private ReverserService () {}
/// <summary>
/// Most importantly uses yield command for efficiency
/// </summary>
/// <param name="enumerableInstance"></param>
/// <returns></returns>
public static IEnumerable ToReveresed(IEnumerable enumerableInstance)
{
if (enumerableInstance == null)
{
throw new ArgumentNullException("enumerableInstance");
}
// First we need to move forwarad and create a temp
// copy of a type that allows us to move backwards
// We can use ArrayList for this as the concrete
// type
IList reversedEnumerable = new ArrayList();
IEnumerator tempEnumerator = enumerableInstance.GetEnumerator();
while (tempEnumerator.MoveNext())
{
reversedEnumerable.Add(tempEnumerator.Current);
}
// Now we do the standard reverse over this using yield to return
// the result
// NOTE: This is an immutable result by design. That is
// a design goal for this simple question as well as most other set related
// requirements, which is why Linq results are immutable for example
// In fact this is foundational code to understand Linq
for (var i = reversedEnumerable.Count - 1; i >= 0; i--)
{
yield return reversedEnumerable[i];
}
}
}
public static class ExtensionMethods
{
public static IEnumerable ToReveresed(this IEnumerable enumerableInstance)
{
return ReverserService.ToReveresed(enumerableInstance);
}
}
[TestFixture] genel sınıf Testing123 {
/// <summary>
/// .NET 1.1 CLR
/// </summary>
[Test]
public void Tester_fornet_1_dot_1()
{
const int initialSize = 1000;
// Create the baseline data
int[] myArray = new int[initialSize];
for (var i = 0; i < initialSize; i++)
{
myArray[i] = i + 1;
}
IEnumerable _revered = ReverserService.ToReveresed(myArray);
Assert.IsTrue(TestAndGetResult(_revered).Equals(1000));
}
[Test]
public void tester_why_this_is_good()
{
ArrayList names = new ArrayList();
names.Add("Jim");
names.Add("Bob");
names.Add("Eric");
names.Add("Sam");
IEnumerable _revered = ReverserService.ToReveresed(names);
Assert.IsTrue(TestAndGetResult(_revered).Equals("Sam"));
}
[Test]
public void tester_extension_method()
{
// Extension Methods No Linq (Linq does this for you as I will show)
var enumerableOfInt = Enumerable.Range(1, 1000);
// Use Extension Method - which simply wraps older clr code
IEnumerable _revered = enumerableOfInt.ToReveresed();
Assert.IsTrue(TestAndGetResult(_revered).Equals(1000));
}
[Test]
public void tester_linq_3_dot_5_clr()
{
// Extension Methods No Linq (Linq does this for you as I will show)
IEnumerable enumerableOfInt = Enumerable.Range(1, 1000);
// Reverse is Linq (which is are extension methods off IEnumerable<T>
// Note you must case IEnumerable (non generic) using OfType or Cast
IEnumerable _revered = enumerableOfInt.Cast<int>().Reverse();
Assert.IsTrue(TestAndGetResult(_revered).Equals(1000));
}
[Test]
public void tester_final_and_recommended_colution()
{
var enumerableOfInt = Enumerable.Range(1, 1000);
enumerableOfInt.PerformOverReversed(i => Debug.WriteLine(i));
}
private static object TestAndGetResult(IEnumerable enumerableIn)
{
// IEnumerable x = ReverserService.ToReveresed(names);
Assert.IsTrue(enumerableIn != null);
IEnumerator _test = enumerableIn.GetEnumerator();
// Move to first
Assert.IsTrue(_test.MoveNext());
return _test.Current;
}
}