foreach - Eine Meinung

Sunray

Erfahrenes Mitglied
For Each muss wirklich nicht zwangsläufig aufs "normale" Iterieren beschränkt sein.
In VB.NET könnte man das selektive For-Each ruhig ungefähr so implementieren.
Code:
For Each entry As String In myArrayList Where CStr(entry).Length > 2
Für C# müsste man sich dann halt was ausdenken. Aber es ist auf jeden Fall sinnvoller diese Funktion an das bestehende Foreach anzuhängen, weil der grossteil der "Arbeit" ja immer noch das iterieren ist. Ansonsten hättest du 2 Konstrukte, die fast das selbe machen.

Ja, Foreach ist fürs iterieren gedacht. Aber wieso sollte man da nicht mit einem einzigen, simplen Ausdruck die Menge der übergebenen Elemente reduzieren können.
Ich denke, dass auf Seiten des Frameworks (Interfaces, Collection Klassen) nichts geändert werden müsste.
 

Christian Fein

Erfahrenes Mitglied
Hab da ein "Selectiven Iterator" eben in Java mit Hilfe von Generics geschrieben.

Sprich ein Typsicherer selektiver Iterator.
Hauptanwendung ist die übergabe eines Objectes das ISelector<T> implementiert.
Dieser sagt ob jenes object selectiert wird oder nicht.

Der Code (erst das Interface, dann der Iterator, danach die main Methode und Anwendung):

Code:
package de.jorona.test;

public interface ISelectort<T> {
	public boolean select(T object);
}

Implementationen dieses Interface entscheiden ob ein Object in der Iteration berücksichtigt wird oder nicht

Code:
package de.jorona.test;

import java.util.ArrayList;
import java.util.Iterator;

public class SelectIterator<T> implements Iterator {
	
	private ArrayList<T> items = new ArrayList<T>();
	private ArrayList<T> okitems = new ArrayList<T>();
	private ISelectort<T> selectable;
	private int index = 0;
	private Iterator<T> iter;
	
	public SelectIterator(ArrayList<T> items,ISelectort<T> selectable) {
		this.selectable = selectable;
		this.items = items;
		Iterator<T> iterator = items.iterator();
		while(iterator.hasNext()) {
			T item = iterator.next();
			if(selectable.select(item))
				okitems.add(item);
		}
		iter = okitems.iterator();
	}
	
	public boolean hasNext() {	return iter.hasNext(); }
	
 	public T next() { return iter.next();	}
 	
 	public void remove() {	iter.remove();	}			
}

Generische Iterator. Checked anhand übergebener ISelector<T> Implementierung ob
das Object Typs T berücksichtigt wird oder nicht. Wenn ja packt der das ganze in ein neues Array.

Die Anwendung, hier wird nur über Strings iteriert die mit "e" anfangen. Mann kann diese ganze Geschichte natürlich allein durch die übergabe einer anderen ISelector<T> Implementierung ändern
Code:
/*
 * Created on 05.01.2005
  */
package de.jorona.test;

import java.util.ArrayList; 
public class ForEachTest {
	
	public static void main(String[] args) {
		ArrayList<String> items = new ArrayList<String>();
		items.add("eins");
		items.add("zwei");
		items.add("esel");
		items.add("efeu");
		SelectIterator<String> selectIterator = new SelectIterator<String>(items,
				new ISelectort<String>() {
					public boolean select(String arg0) {						
						return arg0.startsWith("e");
					}			
				}
		);
		while(selectIterator.hasNext()) {
			System.out.println(selectIterator.next());
		}
	}
}

In C# würde ich ähnlich machen, ausser natürlich das noch keine Generics existieren, wird Zeit das dies umgesetzt wird.

grüsse
 

jccTeq

Erfahrenes Mitglied
Wann kommt es denn offiziell? Wir sind hier im Team nämlich am Grübeln, ob wir 2003 Enterprise Architect kaufen sollen oder auf 2005 warten sollen.
 

Norbert Eder

Erfahrenes Mitglied
.NET 2.0 wird vermutlich noch ein bisserle dauern. Einen Termin wüßte ich ehrlich gesagt nicht ... genausowenig wie ich wüßte, WO .NET noch immer hinter Java wär .... ;)
 

Alexander Schuc

crazy-weasel
Hi.

Melde mich nochmal zu dem Thema.

Bei Comega, einer Programiersprache von Microsoft zu Forschungszwecken, gibt es einerseits einen neuen Streamtyp dere ien Art speziells Array darstellt (um es kurz zu sagen), und bei diesem ist es möglich, durch alle Elemente zu iterieren, allerdings mit Filtereinschränkungen.

Mehr dazu gibts im dot.net Magazin 3.05.

Hier noch ein Beispiel:

Code:
public int* RandomGenerator() // das ist dieser neue Stream-Typ
{ // das yield bewirkt, das beim Aufruf eine Zahl zurückgegeben wird, und es
  // wird erst weitergearbeitet beim nächsten Aufruf.
  for (int i = 0; i <= 10; i++)
    yield return i;
}

// Das gibt nun alle Zahlen aus:
RandomGenerator().{ Console.WriteLine(it); }

// Dies nur noch Zahlen bei denen bei der Division durch 2 der Rest 0 beträgt
RandomGenerator()[it % 2 == 0].{ Console.WriteLine(it); }

Interessante Sprache finde ich, und sie kann noch viel mehr. Wie gesagt eine Forschungssprache, und gibt keine Pläne eine kommerzielle Version davon auf den Markt zu bringen.
Der Compiler soll sich dennoch relativ gut benutzen lassen, und schöne .net Assemblies erzeugen.

Ich hoffe einige Features der Sprache werden wir bei C# 3.0 sehen. :D

http://research.microsoft.com/Comega

Bei Generic z.b nur um mal ein Beispiel zu nennen
Hab jetzt nur mal den Artikel über Generics im dot.net Magazin gelesen. Dort ist auch ein Vergleich zu den Java Generics. Die Umsetzung in .net scheint mir aber die bessere zu sein. :)

MfG,
Alex