Also bis zu cdrs Fast Forward bringt mein selbstgeschriebenes Programm die Antwort fast sofort.
Interessant dabei ist: Ich weiß ganz genau, dass in dem Programm ein Fehler ist, aber es bringt bisher trotzdem die richtigen Ergebnisse 😁

Also ich finds ne nette Idee.

Meine Lösung: 95623164 = 22337131717101

Mein Algorithmus: Die Faktoren 2 und 3 erkennt man mit dem bloßen Auge, die 17 war dann geraten (Glück), die 101 dann offensichtlich, und der Rest trivial 😜

Und meine neue Zahl ist:

611003021

Ich hoffe ich hab alle Regeln richtig verstanden 😁
Und ich hoffe das Ergebniss meiner Zahl ist auch so schön, hab sie von meiner Maus abgetippt.

Hast du den Code der Klasse? Klingt so als ob das Event vom Interface explizit implementiert wurde, und so was ganz anderes macht. Ansonsten mal mit dem Reflector schauen.

Hmm, hätte jetzt gedacht DarKlajid hätte ziemlich genau das gesagt 😁

@AtzeX

Es gibt den Wahlspruch (den ich nicht mehr wörtlich zusammenbekomme), dass man erst versuchen sollte mit Komponenten zu arbeiten, statt mit Vererbung.

Was du beschreibst klingt nach einer monolithischen Klasse. Viel zu umfangreich und allmächtig um praktikabel zu sein. Versuch die Funktionen in Klassen zu separieren, und baue diese Klassen als (notfalls zusammenarbeitende) Komponenten in einer Klasse zusammen.

Was für eine Anwendung ist das? Windows.Forms oder Konsole?

Oh je, ich bin recht schwer zu beeindrucken.

Ich bin mehr Theoretiker und durch speziellen Code für spezielle Probleme nicht so richtig zu begeistern.

Interessant fand ich den Thread, der sich mit aspektorientierter Programmierung befasste. Dort ging es grob darum, dass man das TypeLoad-Event abfängt, den Typen nach Attributen scannt, und dann aus den Attributen Code erzeugt. Leider find ich das grad nicht wieder, ich hoffe ich habs nicht geträumt, oder mit ner anderen Seite verwechselt. 8)

Das Zeichen für das "leere Wort" (leere Zeichenkette) ist übrigens Epsilon nicht Lambda 😉

Nur werden die Möglichkeiten in der Realität nicht genutzt.

Zum Beispiel das Argument, dass ganz oben auf jeder JIT Liste steht:

• Man kann spezielle Maschinenbefehle nutzen, statt sich auf den kleinsten gemeinsamen Befehlssatz zu beschränken und so mehr Aufgaben in einem Zyklus erledigen.

Tatsache ist, dass der .NET JIT das nicht umsetzt. Es werden nichtmal MMX oder SSE Befehle benutzt, einfach weil die Codeanalyse so schwierig ist.

Die Theorie ist ja schön und gut. Die Praxis steht aber auf einem anderen Blatt. Und ich denke in unserem Kontext der Compiler-Benutzer ist die Praxis entscheidender. Das mag sich ja in der Zukunft noch ändern, aber bisher ist es genau so.

Ich find JIT ja auch ganz toll. Wenn das zu einer weitverbreiteten Lösung wird, können die CPU Hersteller ganz neue Wege wagen und die x86 Architektur absägen. Aber ich würde es nicht bar jeder Realität in den Himmel loben.

EDIT: Sorry, meinte SSE nicht SSH. Habs korregiert.

Weiß nicht, aber ich hab den Eindruck du bist da irgendwelchen Werbesprüchen auf den Leim gegangen.
Deine Erwartungen an JIT sind zumindest meilenweit von der Realität entfernt.
Der JIT Compiler von .NET erstellt z.B. den Maschinencode beim ersten Aufruf der Methode (seit Programmstart). Und danach nie mehr. Bei dir klingt das irgendwie danach, als ob er in bestimmten Intervallen das Programm analysiert und neu kompiliert.

Das halte ich für sehr spekulativ. Welche Informationen hat man denn zur Laufzeit, die man zur Installationszeit nicht hat?
Ok, es könnte jemand die Festplatte in einen anderen Computer stecken...

#Develop benutzt afaik NGen bei der Installation um die Startzeit zu reduzieren. Auch NGen muss ja direkt auf dem Computer ausgeführt werden, wo das Programm dann laufen soll.

Original von Programmierhans
8bit = byte
16bit = short
32bit = int

diese sind signed

ein u vornedran = unsigned

byte is unsigned, und sbyte ist signed 😜

Aber das ganze zeigt wieder sehr schön, warum typedefs böse sind 😉

Es gilt die Regel: Alle Namen die irgendwie für andere Assemblies sichtbar sind (also public, protected) dürfen sich nicht nur durch Groß-/Kleinschreibung voneinander unterscheiden. Das liegt daran, dass die Assemblies sprachunabhängig sind, und nicht alle Sprachen die Groß-/Kleinschreibung unterscheiden, wie VB z.B.

Das beantwortet eigentlich die meisten deiner Fragen.

Ich würde sagen setz mal am Anfang einen Breakpoint und geh dann schrittweise durch.

Original von Therion
Hm, muss doch den umständlichen Weg gehn, da ich den Operator == auch nicht mit generischen Typen überladen kann. Ich habe Doch Vektoren die wiederrum Vektoren usw enthalten können als Einträge. Habe das auch probiert, aber er mag bei == keine generischen Ausdrücke. Natürlich gibt es die Methode == aus Objects schon, aber diese testet ja nur ob die Objekte gleich sind, aber bei Vektoren muss ich die Einträge miteinander vergleichen.

Du musst nur die Equals Funktion überschreiben. Dort testest du, ob das andere Objekt ein Vektor vom gleichen Typ ist. Wenn ja, dann casten. Und dann durch die einzelnen Elemente iterieren und vergleichen.

Für Gleichheit braucht man doch garnicht den umständlichen Weg gehen.
Dafür kannst du ja festen Code benutzen, weil ja jedes Objekt den == Operator hat.

Ansonsten mal eine Testklasse erstellen und compilieren, und dann mit ILdasm (oder dem Reflector im IL Sprachmodus) das Ergebnis anschauen. Da sind dann die Namen der Funktionen alle ordnungsgemäß umgesetzt.

Hier etwas Aktuelles zu dem Thema.

Das heißt aber nur, dass die heimliche Durchsuchung mit der aktuellen Gesetzeslage unzulässig ist.

Ich würde bei sowas einfach mit dem Debugger mal schrittweise durchgehen und schauen was passiert. Der Debugger wird von Anfängern viel zu selten benutzt, deswegen nochmal der Hinweis:

Breakpoint setzen und dann in einzelnen Schritten das Programm ausführen und beobachten.

Das ist imo Äquivalent zu Nullable<int>.

Hat also wirklich keinen anderen Effekt, als auf null setzen zu können, da Nullable<T> ebenfalls ein struct ist.

Original von Bundesstrasse
Habe doch hier die Bedingung, dass er nur dann was ausgeben darf, wenn ich einen Wert für c einsetzte, der kleiner als d ist oder?

Genau das Gegenteil ist richtig. Continue verlässt den aktuellen Schleifendurchlauf und geht zum nächsten. Wäre ja doch irgendwo ziemlicher Quatsch den Befehl andersrum einzubauen.

Da fallen mir gleich viele Varianten ein. Die gefällt mir glaub ich am Besten:

class c
{
     private int address;
     private AutoResetEvent threadSignal = new AutoResetEvent( true );
     public void blubb(int address)
    {
         threadSignal.WaitOne();
         this.address = address;
         Thread t = new Thread(new ThreadStart(this.GetAddress));
         t.Start();
    }

    public void GetAddress()
   {
          int adr = this.address;
          threadSignal.Set();
          //ganz viel code
   }
}

AutoResetEvent ist auch eine Möglichkeit um Threads zu synchronisieren. Es kennt zwei Zustände: gesetzt (true) und nicht gesetzt (false). WaitOne blockiert, wenn es nicht gesetzt ist und gibt frei, wenn es gesetzt ist. Außerdem, weil es ein AutoResetEvent ist, wird es nach WaitOne automatisch zurückgesetzt.

Initialisiert ist es mit true, d.h. das erste WaitOne wird einfach durchgelassen. Dann steht es aber sofort auf false, das nächste WaitOne würde also hängen bleiben. In der GetAddress Methode sobald die Adresse gesichert wurde, wieder auf true gesetzt und der nächste Thread könnte gestartet werden.

Das ist zumindest ein prinzipieller Bauplan, der funktionieren müsste.

Allerdings gibt es tatsächlich im Framework 2.0 eine Möglichkeit auch einen Parameter zu übergeben. Einfach mal in der MSDN die Überladung der Start Methode anschauen.

In deinem konkreten Fall würde ich überlegen nicht vieleicht ThreadPool zu verwenden. Der geht schonender mit den Threads um und ist wie gemacht für kleinere öfters vorkommende Aufgaben. D.h. du hast eine Obergrenze an aktiven Threads, so dass dein Programm durch häufiges aufrufen dieser Funktion nicht zusammenbricht, weil zu viele Threads parallel laufen. Und es spart Overhead bei der Threaderzeugung. Die passende Methode heißt QueueUserWorkItem.

Original von Borg
Mit Hilfe von where.

public class Vector<T> where T: long, float, double, decimal  

Nur dann ist garantiert, dass für jeden erlaubten Typ eine Operation + definiert ist. Desweiteren macht ein Vektor von String oder Button auch kaum Sinn...

Diese Constraints funktionieren auch nicht. Abgesehen davon, dass man von diesen Typen nicht erben kann und sie somit prinzipiell nicht für Constraints in Frage kommen, sind die Constraints auch immer UND verknüpft.

Es gibt in C# keinen Weg das hinzubekommen. Generics sind eben doch was anderes als Templates. Bei C++ Templates wird einfach implizit angenommen, dass es die Funktionen die man verwendet schon für diese Typen geben wird.
Bei C# Generics läuft es andersrum, da legt man fest für welche Typen der Generic definiert ist, und kann dann auch nur diese Funktionen verwenden. Das hängt imo auch mit Reflection zusammen.

Und das macht eben diese Sachen leider unmöglich. Es gibt kein Interface für mathematische Operationen, die Operatoren selbst sind sogar statische Funktionen. Es wäre wirklich schön, wenn es neben IComparable auch sowas wie IArithmetic geben würde.

Du hättest höchstens die Chance in der Klasse selbst über Templates zu gehen und darin erst die Addition auszuführen. Das heißt, dass dort Code zur Laufzeit geschrieben wird, wenn der Konkrete Typparameter bekannt ist.

Bei der Exception solltest du vieleicht ein simples throw; in Erwägung ziehen. Durch throw e; wird der Stacktrace neu aufgebaut, das heißt du kannst den Fehler nur genau bis zu der Funktion zurückverfolgen, die throw e; aufgerufen hat. Alles weiter verschachtelte geht verloren. Durch throw; kannst du im catch-Block Fehlerbehandlung machen, die Exception weiter nach unten reichen, und der komplette Stacktrace bleibt erhalten. Wenn du aber keine Behandlung im catch-Block machst, kannst du ihn auch gleich komplett weglassen.

Original von Nordwald
Die Einsparung von Speicher in diesem Bereich ist kaum eine Fingerkrümung Wert und sollte wahrgenommen werden.

Das ist eben ein Trugschluss. Du wirst mit sehr großer Wahrscheinlichkeit eben garnichts einsparen. Dafür legst du im Zweifelsfall noch drauf, weil 32 Bit Prozessoren mit 32 Bit Werten besser umgehen können als mit 16 Bit Werten.
Und dann schlägt höchstwahrscheinlich noch das schon beschriebene Alignment zu.
Außerdem kann eh nicht weniger als 4 KB Speicher angefordert werden. Die Chancen sind also sehr hoch, dass das Programm eh schon einen Verschnitt hat und noch reichlich unbelegten Speicher übrig hat. Reichlich zumindest wenn wir int mit short vergleichen.
Mit viel Glück erreichst du einen Vorteil bei Datenstrukturen, aber bei lokalen Variablen ist das sehr zweifelhaft. Und von diesen Datenstrukturen brauchst du dann auch schon mehrere hundert um auch nur eine Page mehr zu belegen. Von nem signifikanten Wert wie 1 MB mal ganz zu schweigen.

Eigentlich wie du schon sagtest, die Einsparung ist kaum eine Fingerkrümung wert.

Ich glaube es geht eher darum eine eigene Sprache hinzuzufügen als irgendwas als Script ausführen zu lassen.

Die simpelste Variant wäre wohl einen Übersetzer von der neuen Sprache zu MSIL zu schreiben. Das MSIL könnte man dann zu einer .NET Assembly übersetzen lassen. Damit hätte man dann vollständige Sprachintegration. Man könnte Assemblies der neuen Sprache in .NET benutzen, und andere .NET Assemblies in dieser neuen Sprache verwenden.

Zu dem Thema ist wirklich schwer etwas zu finden. Die Suchbegriffe die mir dazu einfallen sind auch zu generell um was passendes rauszufinden.

Das .NET Framework hat zwar in relativ kurzer Zeit einen großen Sprachumfang erhalten, aber nahezu alle Initiative geht von Microsoft aus.

Es geht auch, wenn du für die Plugins eine eigene AppDomain anlegst. Es muss lediglich das richtige Verzeichnis für das Auflösen der Referenzen gesetzt sein. Bei der AppDomain die beim Programmstart entsteht, ist das imo immer der Ordner, in dem die ausführbare Datei liegt.

Ich finde das liegt im Auge des Betrachters. Es ist keine Zeitverschwendung, wenn es einem irgendwas gibt. Aber das lässt sich nicht verallgemeinern.

Jeder hat eben seine eigenen Hobbies und eigentlich alle sind im Grunde Zeitverschwendung. Nur wenn man persönlich was davon mitnehmen kann, macht man das gerne und dann bringts einem auch was.

Weiß nicht ob das bei euch auch so ist, aber meine Hobbies helfen mir mich zu konzentrieren. Quasi das Hirn mal auf anderen Regionen ackern lassen und andere erstmal erholen. Und dann von einem neuen Blickwinkel ausgeruht wieder an anspruchsvollere Aufgaben.

Ich persönlich bin auch kein Party Animal. Ich hab an Saufgelagen kaum Spaß. Ich trinke selten viel, meist dann wenn mich die Situation ankotzt und ich keinen Spaß habe 😉
Computerspiele machen mich inzwischen auch nicht mehr so an. Es fesselt mich nicht mehr so wie früher, ich spiel meist nur noch kleine Spielchen für zwischendurch. Bin nicht sicher, aber ich glaube zum Teil haben sich auch die Computerspiele verändert 😉
Welches neuere Spiel kann es denn wirklich mit einem Monkey Island oder einem Quake (je nach Geschmack) aufnehmen? Früher war das echt noch was neues, da kamen Spiele raus, die es so noch nie gegeben hat. Heute hat man fast alle Varianten schonmal gesehen, das meiste sind sogar simple Neuauflagen alter Titel, nur wenige Perlen stechen hervor.

Dafür pflege ich jetzt andere Hobbies. Ganz auf Zerstreuung zu verzichten und immer Zielorientiert zu handeln, macht einen imo auf Dauer kaputt und auch weniger Leistungsfähig. Aber wobei man sich entspannt, kann man schwer allgemein fassen. Manche entspannen sich auf ner Party, manche bei nem Kreuzworträtsel.

Nein 😁

Wenn du das Datum gegeben hast und testen willst ob es der letzte jeweilige Wochentag ist, musst du nur 7 Tage draufrechnen und Testen, ob sich der Monat verändert hat.

Stimmt ja auch, das geht nicht.

Form1 ist ein Form. Aber Form ist kein Form1.

So wie ein Hund ein Tier ist, aber ein Tier ist kein Hund.

Dier 4. kann aber auch der letzte sein 🤔

Original von norman_timo
ich habe meines Wissens nicht gesagt, dass ich Software klaue, oder? Nein, es ging mir lediglich um die allgemeine Aussage, dass bei der Menge OEM und dass Windows so "günstig" sei, es kein Bedarf gäbe, es zu klauen.

Schon dabei von Bedarf zu reden, halte ich für fragwürdig. Entweder die Software ist es wert gekauft zu werden, oder nicht. Alternativen in Form von Klauen sind einfach indiskutabel.

Ich weiß nicht ob du das machst und möchte auch nicht drüber mutmaßen. Aber mich stört es einfach, dass du das hier rechtfertigst.

Findest du es nicht auch etwas widersprüchlich einerseits zu sagen, du baust deine PCs lieber selber, weil es billiger ist, und andererseits zu sagen, bei den selbstgebauten PCs ist kein Windows dabei und das wird dann zu teuer?

Hier in dem Thread geht es um die konkreten Maßnahmen die Microsoft in Vista trifft. Und du beschreibst "es trifft dich hart" lediglich im Kontext des Preises. Da bleibt leider kein anderer Schluss übrig als zu glauben, dass du dich von der Kopierschutzwirkung mehr getroffen fühlst als von den hier eigentlich kritisierten Wirkungen zum Thema legale Benutzbarkeit.

@norman_timo

Deine selbstgestellten Anforderungen entschuldigen nicht, dass du Software klaust.

Das Problem an der Sache ist eben, dass es völlig unwirksam gegen Raubkopierer ist und die legalen Besitzer viel härter trifft.
Ich will nicht, dass Microsoft einen meiner Treiber abschalten kann. Das geht die garnichts an was ich sonst noch auf meinem PC installiere und was für Hardware ich habe usw.

Aber wenn man das Betriebssystem legal benutzen will, wird man dazu genötigt. Sobald man das irgendwie rauspatcht, ist es schon wieder illegal.

Imo ist das ein ganzzahliges Optimierungsproblem und damit NP-schwer. Also wird ein "cleveres Durchprobieren" nicht um Klassen schlechter sein als ein optimales Lösungsverfahren.
Weil ganzzahlige Optimierung NP-schwer ist, muss dieses Problem hier nicht auch unbedingt NP-schwer sein. Aber für mich sieht es doch ähnlich genug aus, um das erstmal anzunehmen. Außerdem sind die meisten interessanten Rätsel NP-schwer 😁

Man muss nur die Zeilen- und Spaltensummen als Schranken verstehen, und für zwei Teile einer Flasche die Schranke einfügen, dass das obere Teil höchstens so viel enthält wie das Teil direkt darunter. Dann ist es nur noch formale Umformarbeit das ganze als ganzzahliges lineares Maximierungsproblem sauber auszuformulieren.

Wenn man die Zeilen und Spaltensummen als Gleichungssystem betrachtet und lösen will (z.B. über gaußsche Eliminationsverfahren), bekommt man einen ganzen Raum möglicher Lösungen. Da muss man dann erstmal alle rausfinden, die ganzzahlig sind (was mit ggT gut möglich sein müsste), und dann alle finden, die die Schwerkraftsbedingung erfüllen.

Sehr interessant, ich werds nur wohl nicht so schnell anwenden können, weil ich fast nie mit GUI arbeite. Aber ich hab den Link mal jemandem geschickt, der wohl eher was damit anfangen kann 😁

Mir sind nur ein paar Satzkonstrukte aufgefallen, die etwas sehr deutsch wirken.

Nur mal zwei Beispiele an denen ich ins Grübeln kam:

The interested should read the source code.

Worth mentioning is the Attributes property.

Ich bin nicht sicher, ob man das im Englischen so machen sollte. Im Zweifelsfall würde ich immer auf einen simplen Subjekt-Prädikat-Objekt Aufbau zurückgreifen, damit liegt man eigentlich nie falsch.

Fachlich ist mir nichts aufgefallen. Wie gesagt hab ich mit GUI nicht viel zu tun. Es fehlen höchstens noch ein paar Sticheleien gegen Microsoft für die schlechte Doku wenns darum geht das .NET Framework zu erweitern 😁 Wenn man anfängt und von einer Klasse im Framework erbt, stößt man sehr schnell auf Lücken in der sonst guten Doku.

Ok habs jetzt eben nochmal durchgetestet. Dein Fehler ist nur, dass du den TcpChannel ohne Port erstellst. Ich hätte jetzt auch gedacht, dass er sich dann automatisch einen nimmt.
Also benutz einfach new TcpChannel( 0 ) und es sollte funktionieren, und er sollte sich selbst einen freien Port suchen.

Leider findet man nirgends etwas über deren Finanzierung. Da bin ich doch eher mistrauisch.

Das Server und Client in der Exception darf man nicht auf die Struktur des Programms übertragen. Für das Framework ist der Sender ein Client und der Empfänger ein Server, egal wie du das bei dir benennst.

Dein Server öffnet ja bereits einen Channel, auf dem dann die Daten empfangen werden. Aber dein Client öffnet seinerseits keinen Channel, auf dem der Server ihm etwas schicken könnte. Die Aktionen gehen also bloß in eine Richtung: Client -> Server

Damit das auch in die andere Richtung klappt, musst du auch auf dem Client einen Channel registrieren. Das müsste dann schon ausreichen.

Ich würde eigentlich als sehr gute Ergänzung IronPython vorschlagen. Damit kann man die .NET Bibliotheken benutzen und man kann IronPython wunderbar leicht in einem .NET Programm als Scriptsprache einsetzen.
Außerdem sind die Listengeneratoren eine Art Perview auf manches, was in C# 3.0 kommt.

Am Ende ist es eigentlich ziemlich unspannend eine Sprache zu lernen. Syntax ist wirklich kein Problem, und Bibliotheken kann sich eh keiner merken, da ist es wichtiger zu wissen, wo man ordentliche Informationen dazu findet.
Deswegen würde ich eher dazu raten Sprachen anzuschauen, die andere Konzepte als C# haben. Wenn du erstmal viele dieser verschiedenen Konzepte kennst, hast du auch kein Problem mehr eine völlig unbekannte Sprache zu lernen. Deswegen würde ich Java erstmal liegen lassen, mit dem arbeitet es sich recht ähnlich zu C#.

Nur um das nochmal festzuhalten, ein Cast ist keine Konvertierung.
Casts wandeln in der Regel nur in Typen um, die das Objekt ohnehin schon hat. Und das Objekt bleibt das Selbe. Eine Konvertierung erzeugt ein neues Objekt mit einem ganz anderen Typ aus den Informationen des ursprünglichen Objekts.

Du willst den Typ ja komplett Wechseln, also suchst du eine Konvertierung. Convert sollte da auch der passende Suchbegriff sein.

Und der generische Parameter ist hier auch völlig falsch eingesetzt. Generics sollten nicht den Polymorphismus ersetzen. Der würde hier völlig ausreichen.

Es gibt genau 4 Fälle in denen man zu einer generischen Methode greifen sollte:

1. Der Typ wird für einen Rückgabewert benutzt, das erspart casten
2. Man erstellt in der Methode eine Instanz von dem Typ ( new T() )
3. Man muss typeof(T) aufrufen. Hier ist aber Vorsicht geboten. Wenn ein Parameter diesen generischen Typ benutzt ist es besser sich dort über parameter.GetType() den Typ zu holen, weil man da garantiert den echten Typ bekommt. Mit typeof(T) bekommt man bei falscher Benutzung eventuell nur eine Basisklasse, und damit vieleicht nicht die besten Informationen. (Wobei das ja auch Absicht sein könnte...)
   Außerdem sollte man mit typeof nicht den is Operator nachbauen.
4. Man ruft selbst wieder generische Methoden auf, die den Typ brauchen.

Alles andere lässt sich über Polymorphismus (inklusive dem is Operator) äquivalent lösen und spart den Overhead von Generics. Zumindest fällt mir kein weiterer Grund ein, warum eine Funktion generisch sein sollte.

Gibts dafür auch einen Grund?

hm... abseits von VS und C# was vieleicht nicht jeder kennt:

7zip
IronPython (extrem nützlich zum Testen von .NET dlls und zum Rechnen mit verflucht großen Zahlen 😛)
IcoFX (ziemlich cool für Icons)
NSIS (mächtige Installationen erstellen)

Und alles legal 😉

Ich würde nur anmerken, dass du den Umweg über ToString() nicht brauchst. Frag die Farbe direkt ab:

if( farge == Farbe.rot )
...

oder mach gleich ein switch:

switch( farbe )
{
    case Farbe.rot:
        ...
        break;

    case Farbe.gruen:
        ...
        break;
}

Und nicht auszudenken was so eine "kostenlose" Software tatsächlich kostet, wenn man mal ein Problem damit hat. Wenn man z.B. ein halbes Jahr falsch rechnet und man am Jahresabschluss merkt, dass Geld fehlt.

Es ist ein weit verbreiteter Irrtum, dass kostenlose Software nichts kostet. Das gilt eigentlich nur im Hobby Bereich.

Das Hauptargument, was einem aber keiner von den älteren, erfahrenen Kollegen glauben wird, ist die enorm hohe Produktivität.

Die wird erreicht, indem man unnötige Komplexität wegnimmt (z.B. Pointer, Memorymanagement) und eine sehr umfangreiche und sehr gut dokumentierte Bibliothek hat.
Außerdem wird das durch die sehr guten IDEs und Hilftools unterstützt. Z.B. NUnit und seine Freunde und die Tools für die XML Dokumentation. Delphi kann da wirklich garnicht mithalten. Java kann aber ähnliche Dinge aufweisen, viele der .NET Programme sind von Java inspiriert.

Das glaubt einem nie jemand, der es nicht selbst probiert hat. Aber wer es ernsthaft probiert hat, wird zustimmen.

Java ist eine bedenkenswerte Alternative. Im Bereich GUI eher nicht, aber ansonsten ist es imo auf Augenhöhe.

Nicht gerade leicht.

Schau mal in Wikipedia unter Normalverteilung. Da steht weiter unten wie man normalverteilte Zufallsvariablen simulieren kann.

Gleichverteilte Zufallsvariablen liefert die Random Klasse.

EDIT: Iridium hat einen NormalGenerator der den Box-Muller Algorithmus implementiert.

Wie wärs denn mit nem Mastermind? Das sollte sich auch leicht auf Konsole umsetzen lassen. Entweder benutzt du bunte Zeichen in der Konsole, oder noch einfacher, schreibst die Farben aus, bzw. Abkürzungen für die Farben.

Wechselgeld ist aber auch ne gute Übung. Div/Mod ist bei Prüfungen sehr beliebt.

Ich versteh es noch nicht so recht.

Das Problem was ich dabei habe ist, dass die Objekte ja auf Anfrage erstellt werden. Das heißt du willst im Prinzip nen Ablauf in der Art:

1. Anfragen
2. Warten bis Anfrage fertig
3. Verarbeiten

Das ist ja genau der Ablauf, wenn du das ganze in einem einzigen Thread laufen lassen würdest. Ich verstehe nicht so recht warum das Bearbeiten der Anfrage in nem anderen Thread laufen muss, wenn der anfragende Thread in der Zeit eh nur wartet.

Oder alternativ willst du vieleicht, dass ein Thread eine Anfrage erzeugt und dann was ganz anderes macht. Du erzeugst dann einen Thread, der die Daten holt. Aber genau dieser Thread der die Daten geholt hat, kann doch im Anschluss gleich verarbeiten.

Oder dein Problem bei der Sache ist lediglich, dass durch dumme Zufälle plötzlich zu viele Threads aktiv sind, dann benutze einfach den ThreadPool. Wenn du die Threads mit dem ThreadPool erzeugst, löst sich das Problem. Der lässt nur eine bestimmte Anzahl an Threads gleichzeitig zu. Wenn mehr angefragt werden, steckt er die völlig selbstständig in eine Queue. Wenn du nicht den kompletten ThreadPool damit verstopfen willst, müsstest du aber noch bisschen was mehr tun.

Oder du willst, dass Thread 1 die Anfrage stellt, von Thread 2 ein Objekt erzeugt wird, und Thread 1 die wieder verarbeitet, und Thread 1 in der Zeit wo Thread 2 arbeitet selbst noch was ganz anderes machen soll. Da gibt es keine andere Lösung als regelmäßig abfragen, ob was fertig ist. Du kannst einen Thread nicht unterbrechen und ganz woanders fortsetzen lassen.
Entweder warten und nichts tun, oder ständig prüfen. Dazu gibt es keine Alternativen.

Also irgendwie hab ich auch noch Zweifel, dass ich das richtig verstanden habe.

Du hast also 2 asynchrone Aktivitäten:

1. In der einen werden irgendwie Objekte erzeugt (Erzeuger)
2. In der anderen werden irgendwie die Objekte verarbeitet (Verbraucher)

Und du willst vermeiden, dass die Verbraucher die ganze Zeit nachschauen ob etwas da ist (busy waiting)

Außerdem gibt es mehrere unterschiedliche Verbraucher, die jeweils auch nach unterschiedlichen Datenarten anfragen.

Haut das soweit erstmal hin?

Bei unterschiedlichen Sprachen hat das Datum unter umständen auch unterschiedliches Format.

Bei uns ist es normal zuerst den Tag zu nennen, dann den Monat. In den USA sieht das wieder ganz anders aus.
1.7. würde in beiden Fällen verstanden, aber unterschiedlich.
15.7. würde in dem einen Fall einen Fehler verursachen, in dem anderen nicht.

Du hast 2 Möglichkeiten:

1. Du konvertierst den Text explizit mit einer Funktion im SQL von einem ganz bestimmten Format. Da du dort explizit das Format angibst, wird immer das gleiche verwendet.

2. Statt das Datum in die SQL Abfrage zu schreiben, benutzt du SqlParameter.

PS das ist nicht von der Version des Visual Studios abhängig, sondern von der Version des SQL Servers.

Vielfalt ist besser als Einfallt. Die neuen Sprachen lernen doch alle voneinander.

Ein paar der D Features hab ich mir für C# schon gewünscht.
Covarianz steht da ganz oben auf der Liste.
Function Literals wären auch nett. Man kann das gleiche ja mit Reflection erreichen, aber ein direkter und typsicherer Weg wäre besser.
Adopter könnte ich im Moment auch sinnvoll einsetzen.

An manchen Dingen sehe ich aber bei D einen Feature Overkill. Zum Beispiel Dinge die einem das Lesen von Programmen schwerer macht, als es beim Schreiben nützt. Beispielsweise Lazy Evaluation of Function Arguments.

Und diese Masse an Features wird auch dafür sorgen, dass sich D als systemnahe Programmiersprache nicht durchsetzen wird. Das sorgt ja schon in vielen Fällen dafür, dass C nicht von C++ abgelöst wird.

Den Typ kannst du natürlich nicht so direkt verwenden. Du kannst nur z.B. alles in eine Variable vom Typ object speichern, und musst dann alle Methoden und Properties über Reflection aufrufen.