Wie wird in die Log-Datei geschrieben?

Wenn ich das richtig verstanden habe, macht das eine andere Anwendung. In dem Fall wirst du mit deiner Queue nicht weitkommen. Denn solang ein anderes Programm in die Datei schreibt, wirst du sie nicht lesen können.

Funktioniert doch nicht so gut.

Beispiel:

Person 3 muss 7€ zahlen.
Person 4 muss 8€ zahlen.

Person 1 erhält 3€.
Person 2 erhält 4€.
Person 5 erhält 2€.
Person 6 erhält 6€.

Minimize p = 4a+3b+5c+1d+5e+4f+6g+2h subject to
// a bedeutet Zahlung von P3 an P1
// b -"-                             P3 an P2
...
// e -"-                             P4 an P1
...
// h -"-                             P4 an P6


//Nebenbedinungen Zahlseite:
a+b+c+d=7
e+f+g+h=8

//Nebenbedingungen Empfangsseite:
a+e=3
b+f=4
c+g=2
d+h=6

Optimal Solution: p = 48; a = 0, b = 0, c = 1, d = 6, e = 3, f = 4, g = 1, h = 0

Bedeutet:

P3 -> P5: 1€
P3 -> P6: 6€

P4 -> P1: 3€
P4 -> P2: 4€
P4 -> P5: 1€

Ganz großes Damentennis! 5 Transkationen finden statt, obwohl die Sache auch mit 4 zu meistern wäre.

Wobei man nicht unbedingt "querschießen" sollte. Ich habe die Erfahrung gemacht, dass Professoren sich in ihrer Eitelkeit schnell verletzt fühlen, wenn man sie kritisiert und sie dann oft kindisch/trotzig reagieren und einem Steine in den Weg legen.

Da man zwei Mengen hat (Zahler und Empfänger) wäre das ja eine Art lineares Zuordnungsproblem, das in seiner Grundform wie im angehängten Bild aussieht.

Kosten wären ja dann wohl die Differenzen von Forderung und Verbindlichkeit und die Restriktion müsste man entsprechend den möglichen Transfers konfigurieren.

PS: Könnte man nicht TeX im Forum integrieren?

Wobei du bedenken musst, dass Praktikanten 40h/Woche arbeiten und ein Werkstudent i.d.R. 20h in der Woche.

Wenn man nur 8h in der Woche arbeitet, muss man sich auch nicht wundern...

du kannst doch nicht das Gehalt eines Festangestellten mit dem Stundensatz eines Selbständigen vergleichen...

Achso, ich redete von Praktikanten und Werkstundenten.

Ein Praktikant oder Werkstudent mit 18€/Stunde kann leben wie Gott in Frankreich. 😉

18€ für einen Studenten finde ich schon sehr viel. Das verdient mancher Festangestellter nicht einmal.

Ich bin nach dem Studium mit 45.000€ Brutto eingestiegen. Das sind etwa 21€/Stunde - und damals war das viel Geld.

Die 5-10€ bezogen sich auch auf die Praktikanten/Werkstudenten. Bei uns bekommt ein studentischer Praktikant 1.100€ (Brutto=Netto) - das liegt genau in dem Bereich.

Natürlich ist das billig, allerdings muss man auch sagen, dass man sie eben nicht so einsetzen kann wie einen "echten" Mitarbeiter. Man sollte es sich zweimal überlegen, ob man einen Viertsemester, der gerade mal die Basics gelernt hat, gleich im Hauptsource eines Programms rumpfuschen lässt.

In der Tat wäre es am einfachsten, einfach mit zwei unterschiedlichen User Controls zu arbeiten.

Und den Dialog würde ich auch weglassen und die Ansichtsmöglichkeiten direkt im Menü anzeigen. Das spart lästig Klicks und ist der Useability zuträglich.

Hallo,

soweit ich weiß, besteht die Möglichkeit, einen so genannten "Sperrvermerk" über die zu legen. Dies verhindert, dass die Thesis veröffentlicht werden kann, sodass nur du, deine Prüfer und das Prüfungsamt deine Arbeit kennen.

Nach einiger Zeit fängt einer der Betreuer an ungewöhnliches Verhalten zu zeigen. Das blöde ist, dass bei ihm noch eine mündliche Prüfung absolviert werden muss. Mich würden speziell Erfahrungen im Bezug auf das letzte Beispiel interessieren.

Ungewöhnliches Verhalten? In Bezug auf was?

Gruß
ProgrammierTroll

Mein Ansatz wäre gewesen, immer denjenigen Partner zu suchen, bei dem die Differenz aus Forderung und Verbindlichkeit am geringsten wäre.

Aber trotzdem:

Wie würde denn das Optimierungskalkül für eine ganzzahlige Programmierung aussehen?

Müsste ich nicht ohnehin alle Transfermöglichkeiten darstellen, damit ich die Restriktionen genau abbilden kann?

Das wäre dann ja bei hohen Anzahl von Personen ein großer Aufwand.

DirectoryInfo.MoveTo ist die Lösung. Wie du siehst wirkt ein Blick in die Dokumentation oft Wunder großes Grinsen

Ich glaube nicht, dass er das gemeint hat.

Naja kennt zufällig wer ne gute alternative zu listbox die wie eine Listbox ist nur mit Spalten.

Ja, eine ListView beispielsweise. (Allerdings habe ich den Verdachte, dass dieser Thread nicht lange Leben wird...

Das eigentlich Problem scheint eher das Befüllen der Controls zu sein.

Hier würde ich eher Laden der Forms und Befüllen der Controls voneinander trennen.

Ob die veranschlagte Zeit in Ordnung geht kann dir hier keiner sagen.Wie denn auch.

Immer an Murphy denken. 😉

Murphy's Law:
"Things are more complex than they seem to be"
"Things take longer than expected"
"Things cost more than expected"
"If something can go wrong it will"

Corollar:
"Murphy was an optimist"

Das Initialisieren wird doch nicht so lang dauern, das es eine Progressbar rechtfertigt.

Ansonsten könnte man ControlAdded abonnieren, aber viel Sinn ergibt das für mich nicht.

Wenn du es so machst, wie du schreibst, sollte es eigentlich gehen.

Bitte zeige deinen Code.

Wie nimmst du die Änderungen vor?

   public interface IContainer<out TypeA, out TypeB>
            where TypeA : IA
            where TypeB : IB
        { }

Stichwort: Kovarianz.

Ok, habe noch einmal darüber nachgedacht, warum meine Idee nicht gut ist:

Man verbreitert die Schnittstelle zum Data Mapper und erhöht gleichzeitig die Kopplung zwischen BA und DAC. Die BAL muss mehr wissen, als eigentlich gut ist. Außerdem ist der Mapper dann für Multithreading ausgerichtet, obwohl ich vielleicht nicht immer so große Datenmengen habe, dass ich eine Threadsafe-Collection verwenden möchte. Die Methode muss immer so funktionieren, wie sie definiert wurde, egal ob ich nun einen Thread oder mehrere verwende.

Andere Idee wäre, ich lasse die Methode wie oben und erzeugen einen zweiten Thread, der die Daten holt. Wenn alle Daten da sind, feuere ich einen Event und erhöhe die Größe der VirtualList. Ich spare mir dadurch die Threadsafe-Collection, aber ich muss warten, bis alle Daten geladen sind. Nun weiß ich nicht genau, wie schmerzhaft bei solchen hohen Anzahl von Datensätzen ist, da ich das noch nie gebraucht habe.

Stimmt! Wird in Grundlagenbüchern aber immer so gemacht, wie ich es getan habe, aber danke.

Realisieren könnte man das z.B. mit einer ListView oder einem DataGridView (Winforms) im Virtual Mode. Das Nachladen kannst du in einem eigenen Thread erledigen. Vielleicht zuerst ein COUNT(*), um die Anzahl der Zeilen zu bestimmen, dann diesen Wert der VirtualListSize eigenschaft zuweisen und dann schon mal anfangen, die Daten nachzuladen.

Wie darf ich mir das konkret vorstellen?

Nehmen wir mal folgende, simple Methode aus einem beliebigen Data Mapper, welche eine Liste von BusinessClass-Objekten zurückliefiert, die den Suchkriterien der Query entsprechen.

  protected List<BusinessClass> findMany(SQLStatement aStatement)
        {
            IList<BusinessClass>resultList = new List<BusinessClass>();
            SqlCeCommand findQuery = null;
            SqlCeDataReader reader = null;

            try
            {
                mapperConnection.connect();
                findQuery = new SqlCeCommand(aStatement.sqlStatement(), mapperConnection.DalConnection);


                reader = findQuery.ExecuteReader();

                while (reader.Read())
                {
                    resultList.Add(load(reader));
                }

                reader.Close();                                                                                                                                                                                                                      
            }
            catch (Exception e)
            {
                throw; //re-throwing without resetting the callstack ;)
            }
            finally
            {
                mapperConnection.disconnect();
            }
            return resultList;
        }

Das Problem bei diesem Mapper wäre ja nun, dass ich warten muss, bis die Liste alle Datensätze erhalten hat.

Wenn ich also einen zweiten Thread fahre, müsste ich der Methode eine threadsichere Collection übergeben, welche diese dann befüllt. Über die VirtualList greife ich dann auf die Collection zu und lade den Datensatz, der gerade angezeigt werden soll (sofern dieser vorhanden ist).

Also ehrlich gesagt, kommt mir das nicht ganz sauber vor. Versteh ich das so richtig?

Wobei ich mit den Delegaten im Prinzip stark detallierte Interfaces definiere, darum seh ich nicht so den Sinn, zusätzlich noch mit Interfaces rumzufrickeln.

Das ist sehr seltsam. Ich habe auch einen "Algorithmus", der so ähnlich arbeitet wie deiner, kommt auf etwa 710 Versuche. Frag mich gerade, wo mein Fehler liegt.

            public void FindString()
            {
                String guessString = "";
                StringBuilder guessStringBuilder = new StringBuilder(guessString);
                int[,] letterAppearences = new int[(int)'Y' - (int)'A' + 1, 2];
                int testLetter = (int)'A';
                int targetNumberLetter = 1;
                int length = 0;
                int rightChar = 0;

                do
                {
                    guessString += " ";
                    length++;
                }
                while (stringHider.Ask(guessString) == -1);

                guessStringBuilder.Length = length;

                for (int i = 0; i < (int)'Y' - (int)'A'+1; i++)
                {
                    letterAppearences[i, 0] = testLetter;;
              
                    for (int j = 0; j < length; j++)
                    {
                        guessStringBuilder[j] = (char)testLetter;
                    }

                    letterAppearences[i, 1] = stringHider.Ask(guessStringBuilder.ToString());
                    testLetter++;
                }

                guessStringBuilder.Replace('Y', (char)0);

          
                for (int i = 0; i < length; i++)
                {
                    for (int j = 0; j < letterAppearences.GetLength(0); j++)
                    {
                        if (letterAppearences[j, 1] > 0)
                        {
                            if (guessStringBuilder[i] == (char)0)
                            {
                                guessStringBuilder[i] = (char)letterAppearences[j, 0];
                                rightChar = stringHider.Ask(guessStringBuilder.ToString());

                                if (rightChar==-2)
                                {
                                    letterAppearences[j, 1]--;
                                }
                                if (rightChar == targetNumberLetter)
                                {
                                    targetNumberLetter++;
                                    letterAppearences[j, 1]--;
                                }
                                else if(rightChar != -2)
                                {
                                    guessStringBuilder[i] = (char)0;
                                }
                            }
                        }
                    }
                }
            }

so ganz nebenbei ist der Titel des Themas "Informatik-Studium sinnvoll/nützlich? Welche Alternativen zum Studium sind sinnvoll/nützlich?". Besinnt euch bitte darauf.

Hängt wir sehen auch davon ab, in welchem Bereich man später entwickelt. Ich arbeite hauptsächlich in Projekten Rund um das Thema Logistik, d.h., wir entwickeln große Transportmanagementsysteme. Da kommt es nicht selten vor, dass man das eine oder andere knackige Problem lösen muss. Am Anfang habe ich mich damit z.T. sehr schwer getan und musste mir die nötige Kompetenz oft am Wochenende im Selbststudium aneignen.

Ich habe außerdem Freunde, die in der Finanzbranche tätig sind. Da werden als Entwickler z.T. nur Mathematiker eingestellt, weil man da eben auch wissen über stoachastische Prozesse zur Vorhersage von Aktienkursen, quadratische Programmierung etc. braucht.

Und gerade im Bereich Baken, Versicherungen oder Finanzandienstleistern wird nicht wenig Software erstellt.

Der Weg mit den Threads und den Events ist mEn der richtige.

Scheint ja sich etwas zu tun. Hängt vermutlich auch mit der Umstellung auf das Bachelor/Master-System zusammen, das die Unis zwingt, ihre Ausbildung praktischer auszurichten.
Ich stamme ja noch aus Diplom-Dinosaurier-Zeiten (;-)), aber gut ich denke, wir schweifen langsam etwas ab...

Ups, sorry! Habe vergessen, dass ich in einem internationalen Forum unterwegs bin.

Wenn ich von "den Unis" rede, meine ich deutsche Unis. Die sind im Vergleich eher konservativ, was bedeutet, dass dort i.d.R. Informatik zu 90% als Mathematik stattfindet.

Wobei ich gerade mal auf der Homepage einer TU9 (das sind die deutschen Elite-Universitäten für Informatik) war und gesehen habe, dass es dort inzwischen auch schon ein Software Projekt gibt. 😉

Informatik am KIT

Es gibt also Fortschritte!

Solche Projekte basieren nach meinem (bisherigen) Kenntnisstand aber auf Eigeninitative der Studenten. Mir ist zumindest kein universitärer Informatikstudiengang bekannt, wo solche Projekte verpflichtend im Studienplan vorgeschrieben sind.
Vielleicht sind die Unis da aber auch inzwischen moderner geworden. Da lasse ich mich gern eines Besseres belehren.

Was ich meinte, sind Semester- oder semesterübergreifende Software-Projekte, wo eine Gruppe mit bis zu 5 Leuten eine Software nach einem Vorgehensmodell mit allen Phasen durchführen muss und jenes Projekt ist dann verpflichtend für alle Studenten des jeweiligen Studienganges. Am Ende wird dann die Dokumentation, die Durchführung und die fertige Software durch den Professoren bewertet und eine entsprechende Note vergeben.

Diese Art von Projekten ist mir nur von Fachhochschulen bekannt.

Und als einer der gelgentlich Lebensläufe durcharbeiten muss:
Was ich bei den Studierten als Gefahr sehe: er kann das Studium zwar erfolgreich abgeschlossen haben, hats aber nur gemacht weil er nicht wusste was er sonst tun hätte sollen. Und dann hat man einen relativ teueren eingebildeten Noob da sitzen (passierte nicht nur einmal).

Das kenne ich. Solche Bewerbungsgespräche habe ich auch schon erlebt. Das liegt aber oft daran, dass man an den Unis nie "wirklich" programmiert. Da hackt man eher abgefahrene Algorithmen in Haskell oder wenn man Glück hat, sind es auch etwas modernere Sprachen wie C/C++.

Die Jungs denken dann natürlich, das sei Programmierung oder Gipfel der Entwicklung, aber eine richtige Anwendungssoftware haben sie nie geschrieben. Deshalb ist ein Uni-Studium auch weit entfernt von einer Programmierausbildung.

Bei uns werden deshalb auch immer mehr FH-Absolventen eingestellt. Die lernen zwar auch noch relativ viel Theorie, müssen diese aber auch praktisch umsetzen und wenigstens mal die andere oder andere Anwendungssoftware schreiben. Die lassen sich meist auch schneller einarbeiten und produktiv einsetzen, bilden daher irgendwo das Mittel zwischen Fachinformatiker und Uni-Absolvent.

Ich hatte in meiner Uni-Ausbildung zum Glück Veranstaltungen zum Thema OOP und Software Architektur. Als ich dann mein erstes Projekt hatte, wo ich selbst mehr Verantwortung übernehmen sollte, habe ich natürlich die Anwendung so geschrieben bzw. die anderen Entwickler immer dazu angewiesenen, die SOLID-Prinzipien, Separate of Concerns, Patterns usw. nach allen Regeln der Theorie umzusetzen.

Irgendwann kam dann der Chef-Entwickler auf mich und fragte wörtlich: "Haben Sie eigentlich noch alle Tassen im Schrank?" Die Anwendung sei zwar ganz toll designed, aber ich wäre nun nicht mehr an der Hochschule und in der Praxis könne man es sich (zeitlich) nicht leisten, so zu arbeiten. Das hat mich natürlich erstmal sehr frustriert. Aber in der Tat sieht man oft mehr "Quick and Dirty", als einem lieb ist.

Ich habe Probleme bei Strings mit einer Länge von ca. 30 Zeichen bekommen.

Iterativ funktionuggelt das einwandfrei. 😁

Aber das ist das schöne an dieser Art von Algorithmen: genial einfach.*

* nur draufkommen muss man. Das ist der schwierigere Teil davon 😃){gray}

(
Habe diesen Alogrithmus im Studium nie kennengelernt, obwohl der eigentlich wesentlich inuitiver als der rekursive ist. Immerhin was dazu gelernt!

Danke, letzterer war, was ich gesucht habe.

Ärgerlich, dass einem sowas nicht selbst einfällt. 8[

Hat jemand eine Idee, wie man die Permutationen iterativ generieren kann? Leider bekommt ja schon bei relativ kurzen Strings einen StackOverFlow. X(

Ja, es gibt auch Informatik-Studiengänge, wo man überhaupt nicht programmiert und nur irgendwelche Dijkstra- und Ford-Fulkerson-Algorithmen lernt, Unfug über Turing-Maschinen oder das Pumping-Lemma rauf und runter beweisen soll. Da fragt man sich als Studenten nur "WZF?", aber später weiß man zu schätzen, was man dort gelernt hat.
Es gibt natürlich viele Informatiker, die den Absprung in die praktische Welt nicht schaffen und dann im Beruf einfach nur Graupen bleiben.

Auf der anderen Seite ist Programmierer/Codierer/Anwendungsentwickler der 100% Vollzeit-Programmier, der das Design und die Spezifikationen in Lines of Code umsetzt.

Ok, das kann man missverstehen, nehme ich deshalb auch zurück.

Das Problem ist, dass die Begriffe Software Ingenieur, Software Architekt, Software Entwickler, Programmier, Codierer oder Anwendungsentwickler oft sehr schwammig gebraucht werden.

Was ich damit meinte war auch eher, dass die Gefahr tendenziell zunimmt als studierter Informatiker am Ende nicht vollzeit zu programmieren. Der Bau-Ingenieur oder Architekt wird auch eher selten selbst die Maurerkelle schwingen, was nicht heitß, dass das nicht vorkommt.

Das hängt vermutlich auch von der Firmengröße ab. In kleineren und mittelständischen Unternehmen ist es eher üblich, dass man sehr ganzheitlich eingesetzt wird - unabhängig davon, ob man studiert hat oder nicht.

Ich arbeite bei einem der größten deutschen Software Hersteller und hier werden z.B. ausschließlich studierte Informatiker eingestellt (was natürlich in der extremen Form auch Quatsch ist).

Programmierung ist meiner Ansicht nach für den studierten Informatiker eher ein Tool ähnlich wie Mathematik, das er bei Bedarf einsetzen können sollte. Der Fachinformatiker ist ein Programmierspezialist und meiner Erfahrung nach in seiner Kompetenz diesbezüglich oft überlegen.

Ich denke, der Einsatzweck beider unterscheidet sich:

Als studierter Informatiker arbeite ich als Software Ingenieur und Programmierung macht nur etwa 25% meiner Arbeitszeit aus. Den Rest der Zeit fliege ich zu Kunden, mache dort Requirements Engneering, male Geschäftsprozesse und designe/spezifiere die Systeme. Manchmal bin ich auch Tester und schreibe Test Cases und Äquivalenzklassen, diskutiere mit Kunden über Defects oder automatisiere.

Das heißt, der studierte Informatiker wird in der Software Entwicklung eher als Allrounder eingesetzt. Auf der anderen Seite ist Programmierer/Codierer/Anwendungsentwickler der 100% Vollzeit-Programmier, der das Design und die Spezifikationen in Lines of Code umsetzt.

Wer wirklich zu 100% Programmierer sein will, sollte meiner Meinung nach Fachinformatiker werden.

Insofern sehe ich nicht, dass sich durch Kenntnis des verblüffenden Beispiels etwas grundsätzlich an der üblichen Verwendung von volatile geändert hat.

Da hast du nicht ganz unrecht. Vielleicht habe ich mich auch zu sehr durch die Ausführungen verunsichern lassen. Er schreibt ja:

This presents a strong case for avoiding volatile: even if you understand the subtlety in this example, will other developers working on your code also understand it?

Für mich klang das so wie die Vererbungswarnung oder das Nicht-Verwenden von Go-To und seinen Derivaten. Ich habe durchaus in meinen Projekten mit Entwicklern zu tun, die noch weniger Ahnung haben als (ja, gibt es g) und da wäre so eine Regel wie "verwende besser locks anstatt volatile und du bist immer auf der sicheren Seite" eine schöne Sache gewesen. Die Welt ist leider und natürlich nicht so einfach und wie du schon richtig schriebst, verfolgen beide Konzepte unterschiedliche Aspekte der Synchronisierung.

klar ist das richtig. Du kannst gerne in die Doku schauen. Wieso bist du da anderer Meinung?

Ich beziehe mich auf:

The MSDN documentation states that use of the volatile keyword ensures that the most up-to-date value is present in the field at all times. This is incorrect, since as we’ve seen, a write followed by a read can be reordered.
...

Threading in C#: volatile

Das habe ich getan. Bei mir terminiert es.

Dann bedingt das wahrscheinlich unsere (vermutlich) unterschiedliche Hardware.

Wenn die Runtime schlau ist (und das hoffen wir mal), wird sie alle (gemeinsamen) Variablen, auf die innerhalb der lock-Blöcke zugegriffen wird, implizit als volatile betrachten.

Findet Zugriff erst dann statt, wäre das eine plausible Erklärung.

für mich ist das kein "entweder oder" sondern das sind zwei unterschiedliche Sprachmittel, die jeweils ihren eigenen Zweck haben. lock verhindert den gleichzeitigen Zugriff (und damit potenzielle Inkonsistenzen bei nicht atomaren Typen), wogegen volatile dafür sorgt, dass der jeweils aktuelle Wert einer Variablen verwendet wird, auch dann, wenn er der Wert im Cache des eigenen Threads steht und er durch einen anderen Thread im Hauptspeicher geändert wurde. Da beides mit Synchronisation zu tun hat, ergänzt sich beides, mehr aber auch nicht.

Das dachte ich auch immer, ist aber so nicht richtig.

Das Problem terminiert bei mir auch ohne volatile. Wenn eine Variable nicht als volatile deklariert ist, bedeutet das nicht, dass nicht zwangsläufig, dass nie der richtige Wert geliefert wird, sondern nur, dass nicht sichergestellt ist, dass bei jedem Zugriff immer der aktuellste Wert verwendet wird.

Man muss das Programm im als Release ohne Debug ausführen, damit die Optimierung zur Geltung kommt.

PS: Wenn ich das lock in das Innere der While-Schleife setze, terminiert das Programm. Allerdings weiß ich nicht, warum.

Danke für eure Tipps!

Ich werde diese mal evaluieren.

Hallo,

nach dem ich mich noch mal intensiver mit dem Thema beschäftigt habe, hakt es bei mir ein wenig.

Was ich bisher dachte, was volatile bedeutet: Ich sorge dafür, dass eine Variable stets den aktuellen Wert hat. Also galt für mich immer, es ist dann geeignet, wenn ein Thread eine Variable liest und ein anderer diese schreibt.

Klingt erst mal ganz plausibel, oder? Nee, alles Quatsch.

Ich habe mich dann eines besseren belehrt und bin zu dem Schluss gekommen, mir die Best Practice Regel aufzuerlegen: "Favour lock over volatile".

Nun dieses Beispiel, dass ich von der Thread-Page habe:

        
static void Main(string[] args)
        {
            bool complete = false;

            var t = new Thread(() =>
            {
                bool toggle = false;
                
                while (!complete)
                {
                    toggle = !toggle;
                }
            });
            
            t.Start();
            Thread.Sleep(1000);
            complete = true;

            t.Join();         
        }
 

Völlig einleuchtend ist, dass dieses Programm niemals terminiert, wenn ich kein volatile verwende.

Aber wo und warum setze ich nun den Lock? Das bereitet mir irgendwie Kopfzerbrechen.

Danke!

Hallo,

ich suche nach einer Umgebung, mit der ich automatische GUI Tests erstellen und durchführen kann. Ich weiß, dass es im VS 2010 so eine Möglichkeit gibt. Das ist zwar ein sehr nützliches Tool, aber nicht das, was ich suche.

Meine Anforderungen sind:

1. Es soll kein Record and Play-System sein.
2. Es sollte skriptbasiert sein und die GUI tatsächlich starten und bedienen.
3. Es soll von unabhängigen Testern (also nicht den Entwicklern selbst) durchgeführt werden.

Vielen Dank!

Ja, so würd ich das auch nicht machen, aber das sagt ja nichts darüber aus, dass Data Binding schlecht wäre.

Ok, war vielleicht etwas übertrieben formuliert, aber das ist - wenn ich das richtig verstanden habe - was der TE hier vor hat.

DataBinding im Sinne des Threades hier meint, ich lege meinen SQLDataAdapter direkt an das Steuerlement.

Beispiel:

  SqlConnection con = new SqlConnection( @"...");
  SqlCommand cmd = new SqlCommand(
          "SELECT ProductName, UnitPrice, UnitsInStock FROM Products", con);
  DataSet ds = new DataSet();
  SqlDataAdapter da = new SqlDataAdapter(cmd);
  da.Fill(ds);
  listBox1.DataContext = ds;

Toll, oder? Nee, ganz großer Mist.

Normalerweise schreibt man einen Data Mapper (Martin Fowler) und greift über die GUI auf die Repositorys in der Business Schicht zu, damit man ein sauberes Separates of Concerns hat. Ich bin deshalb auch kein großer Freund von Data Binding.

Sowas habe ich noch nie gesehen. Wenn du schon mit Klassen arbeitest, würde ich das anders machen.

Beispiel:

public abstract class DemoBase
    {
        protected Thread _thread;
        protected bool _stop;

        protected abstract void doRun();

        public DemoBase()
        {

        }

        public void Start() {
            _stop = false;

            ThreadStart del = doRun;

            _thread = new Thread(del);
            _thread.Start();
        }

        public void Stop() {
            _stop = true;
            if (_thread != null && _thread.ThreadState == ThreadState.Running)
                _thread.Join();
        }
    }

    class Run1 : DemoBase
    {

       protected override void doRun()
        {
            while (!_stop)
            {
                Console.Write("1");
                Thread.Sleep(100);
            }
        }
    }

    class Run2 : DemoBase
    {
        protected override void doRun()
        {
            while (!_stop)
            {
                Console.Write("2");
                Thread.Sleep(100);
            }
        }
    }

Aber das sind wohl eher Basics, weswegen der Thread vermutlich in Kürze geschlossen wird.

Oder einfach die vorhanden Komponententests aus dem Visual Studio nutzen.

Dazu auch: CollectionAsserts