Jump to content
  • C# (C Sharp) Lezione #4 - Iteratori - Programmazione Guida passo per passo


     Share

    C# Sharp e gli iteratori, sono una maniera di rappresentare una sequenza di elementi che hanno in comune il tipo, una catena, una stringa, una sequenza di cosi, che hanno tutti in comune il tipo T.

    Partiamo da come dovrebbe essere:

    • IEnumerable<T>
      •  - IEnumerator<T> GetEnumerator()
    • IEnumerator<T>
      •  - bool MoveNext()
      •  - T current { get; }
      •  - void Dispose()

    Nota: in Java le classi Iterable e Iterator svolgono lo stesso ruolo

     

    Modelliamo gli intervalli (chiusi) di interi in modo tale che siano "foreach-abili", per semplicità, ignoriamo Equals (& company)

    Per esempio:

    var ontToFive = new IntInterval(1,5);
    	foreach (var i in oneToFive)
          Console.WriteLine(i);

     

    Classe IntInterval

    public class IntInterval : IEnumerable<int> {
    	public int LowerBound { get; private set; }
    	public int UpperBound { get; private set; }
    public IntInterval(int lowerBound, int upperBound) {
    	this.LowerBound = lowerBound;
    	this.UpperBound = upperBound;
    }
    public IEnumerator<int> GetEnumerator() {
    	return new Enumerator(this);
    }
    IEnumerator IEnumerable.GetEnumerator() {
    	return this.GetEnumerator();
    }
    	private class Enumerator : IEnumerator<int> { ... }
    }

    Classe IntInterval.Enumerator

    private class Enumerator : IEnumerator<int> {
    	private readonly IntInterval _interval;
    	private int _current;
    	public Enumerator(IntInterval interval) {
    		this._interval = interval;
    		this.Reset();
    	}
    	public void Reset() { this._current = this._interval.LowerBound  1; }
    		public bool MoveNext() {
    			return ++this._current <= this._interval.UpperBound;
    	}
    	public int Current { get { return this._current; } }
    	object IEnumerator.Current { get { return this.Current; } }
    	public void Dispose() { }
    }

     

    Enumerator

    La classe IntInterval.Enumerator è piuttosto semplice da scrivere, ma non particolarmente interessante

    Da C# 2, il compilatore crea in automatico degli Enumerator a partire da un blocco di codice che restituisce un valore dopo l'altro usando yield return

    public class IntInterval : IEnumerable<int> {
       public int LowerBound { get; private set; }
       public int UpperBound { get; private set; }
      
       public IntInterval(int lowerBound, int upperBound) {
       	this.LowerBound = lowerBound;
       	this.UpperBound = upperBound;
       }
       public IEnumerator<int> GetEnumerator() {
       	for (var a = this.LowerBound; a <= this.UpperBound; ++a)
       		yield return a;
       }
       IEnumerator IEnumerable.GetEnumerator() {
       	return this.GetEnumerator();
       }
    }

     

    Iteratori

    Un blocco, corpo di un membro il cui tipo di ritorno sia IEnumerator/IEnumerator<T> o IEnumerable/IEnumerable<T>, che contiene yield return è in iteratation-block

     

    Tale membro viene chiamato iterator(iterator)

     - non può contenere return o avere parametri passati per riferimento (ref o out)

     - può contenere yield break, che termina la sequenza

    L'invocazione di un iteratore non provoca l'immediata esecuzione del codice, ma la costruzione di un oggetto enumerator (o enumerable) per la sequenza corrispondente

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     Share


    User Feedback

    Recommended Comments

    There are no comments to display.


×
×
  • Create New...

Important Information

Terms of Use Privacy Policy Guidelines We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.