Scribd
Upload
43 views

Foreach Int in Yield Return: (I Data) I

The document defines several classes related to enumerables and comparables in C#: 1. MyIntList implements IEnumerable<int> and defines an inner Enumerator class to iterate over its integer data array. 2. MyGenCollection also implements IEnumerable<int> but uses yield return to generate its enumerator instead of a separate class. 3. Test demonstrates using yield return to define an IEnumerable<int> directly without a separate class. 4. Entliczek2 implements IEnumerable<char> to iterate over a string. 5. Various examples show implementing IComparable and IComparer interfaces to allow sorting by properties like temperature or duck weight

Uploaded by

anon_394655724
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
43 views

Foreach Int in Yield Return: (I Data) I

The document defines several classes related to enumerables and comparables in C#: 1. MyIntList implements IEnumerable<int> and defines an inner Enumerator class to iterate over its integer data array. 2. MyGenCollection also implements IEnumerable<int> but uses yield return to generate its enumerator instead of a separate class. 3. Test demonstrates using yield return to define an IEnumerable<int> directly without a separate class. 4. Entliczek2 implements IEnumerable<char> to iterate over a string. 5. Various examples show implementing IComparable and IComparer interfaces to allow sorting by properties like temperature or duck weight

Uploaded by

anon_394655724
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
You are on page 1/ 4

class MyIntList : IEnumerable<int>

{
int[] data = { 1, 2, 3 };
// The generic enumerator is compatible with both IEnumerable and
// IEnumerable<T>. We implement the nongeneric GetEnumerator method
// explicitly to avoid a naming conflict.
public IEnumerator<int> GetEnumerator()
{ return new Enumerator(this); }
IEnumerator IEnumerable.GetEnumerator()
{ return new Enumerator(this); }
class Enumerator : IEnumerator<int>
{
int currentIndex = -1;
MyIntList collection;
public Enumerator(MyIntList collection)
{
this.collection = collection;
}
public int Current { get { return collection.data[currentIndex]; } }
object IEnumerator.Current { get { return Current; } }
public bool MoveNext()
{
return ++currentIndex < collection.data.Length;
}
public void Reset() { currentIndex = -1; }
// Given we don't need a Dispose method, it's good practice to
// implement it explicitly, so it's hidden from the public interface.
void IDisposable.Dispose() { }
}

}
*********************************
public class MyGenCollection : IEnumerable<int>
{
int[] data = { 1, 2, 3 };
public IEnumerator<int> GetEnumerator()
{
foreach (int i in data)
yield return i;
}
IEnumerator IEnumerable.GetEnumerator() // Explicit implementation
{
// keeps it hidden.
return GetEnumerator();
}
}
************************************
public class Test
{
public static IEnumerable<int> GetSomeIntegers()
{
yield return 1;
yield return 2;
yield return 3;
}
}
-foreach (int i in Test.GetSomeIntegers())
Console.WriteLine(i);
1
2
3
class Entliczek2 : IEnumerable<char>

string tabliczka = "ABCdefghaaijk";


public IEnumerator<char> GetEnumerator()
{
return tabliczka.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}

Sorting

int[] numerki = { 6,7, 1, 2, 3, 4, 5 };


Array.Sort(numerki, (x, y) => { if (x > y) return -1; else if (x < y) return 1; else return
0; });

public class Temperature : IComparable


{
protected double tempF;
public int CompareTo(object obj)
{
if (obj == null) return 1;

Temperature otherTemperature = obj as Temperature;


if (otherTemperature != null)
return this.tempF.CompareTo(otherTemperature.tempF);
else
throw new ArgumentException("Object is not a Temperature");

}
public int CompareTo(object obj)
{
if (obj == null) return 1;
Temperature otherTemperature = obj as Temperature;
if (otherTemperature != null)
if(this.tempF>otherTemperature.tempF)
return 1;
else if( this.tempF<otherTemperature.tempF)
return-1;
else
return 0;
else
throw new ArgumentException("Object is not a Temperature");

public class Temperature : IComparable<Temperature>


{
public double tempF;
public int CompareTo(Temperature obj)
{
if (obj == null) return 1;
if (this.tempF > obj.tempF)
return 1;
else if (this.tempF < obj.tempF)
return -1;
else
return 0;
}
}

IComparer

class Kaczka
{
public int Wiek { get; set; }
public int Waga { get; set; }
}
class KaczkaComapreByWaga : IComparer<Kaczka>
{
int IComparer<Kaczka>.Compare(Kaczka x, Kaczka y)
{
if (x.Waga < y.Waga)
return -1;
else if (x.Waga < y.Waga)
return 1;
else
return 0;
}
class KaczkaCompareByWiek : IComparer<Kaczka>
{
public int Compare(Kaczka x, Kaczka y)
{
return x.Wiek.CompareTo(y.Wiek);
}
}
List<Kaczka> kaczaList = new List<Kaczka>
{ new Kaczka { Wiek = 12, Waga = 13 },
new Kaczka { Wiek = 15, Waga = 11 },
new Kaczka { Wiek = 1, Waga = 14 },
new Kaczka { Wiek = 18, Waga = 19 },
new Kaczka { Wiek = 11, Waga = 4 }
};
kaczaList.Sort(new KaczkaCompareByWiek());
foreach (var k in kaczaList)
Console.WriteLine("Wiek: {0}, Waga: {1},", k.Wiek, k.Waga);
class Kaczka
{
public int Wiek { get; set; }
public int Waga { get; set; }

public static IComparer<Kaczka> ByWiek


{
get { return new KaczkaCompareByWiek(); }
}

}
kaczaList.Sort(Kaczka.ByWiek);
Array.Sort(tablicaDoPosortowania, new IComparerClass());

You might also like