mit dem +OK hab ich die Erfahrung gemacht, da kann auch was anderes kommen als die Anzahl der Oktets, z.B. +OK message follows. Aber stimmt, die Sache mit dem Punkt in einer extra Zeile ist ne gute Idee, danke

Hallo zusammen,

ich hab gerade ein Problem mit Emails. Ich kann nicht genug davon bekommen, oder besser gesagt ich weiß nicht, wann die Email zu Ende ist, bzw. ob ich noch auf was warten sollte. Der Zugriff ist SSL-verschlüsselt mit Pop3-Protokoll, da kann ich ja praktischerweise auch LIST n schicken und kriege die Größe der Mail in Byte. Jetzt hab ich am Stream einen Streamreader dran hängen um nicht mit den einzelnen Bytes arbeiten zu müssen, weiß aber deshalb nicht, wie ich dann messen kann, wieviele Bytes jetzt schon angekommen sind. Momentan ist es entweder so, dass die Antworten abgeschnitten werden (und wesentliche Sachen wie das Datum im Header dann halt fehlen) oder eben es ist schon alles ausgelesen und ich erwarte aber das noch mehr da ist, also Endlosschleife.

Die andere Seite sind irgendwelche Top-Kommandos, wo ich gleich gar nicht weiß, wie viel jetzt kommt.

Wie krieg ich also raus, ob ich noch was zu erwarten habe und kann idealerweise den Streamreader weiterverwenden.

Vielen Dank schon mal...

cool. Wenn das klappt, dann gibt es eine umweltfreundliche Lösung auf das Energieproblem, nur würde das halt das globale-Erwärmung-Problem im wahrsten Sinne des Wortes anheizen. Aber ich glaub wir kommen vom Thema ab...

man kann auch jedes mal das Rad mit Hilfe von Factorys neu erfinden.

Besser, standardkonformer und einfacher (weil für diverse Typen schon im Framework definiert) gehts aber mit Convertern:

TypeConverter c = TypeDescriptor.GetConverter(t);
if (c.CanConvertFrom(typeof(string)))
 return c.ConvertFrom(input);
else
 //Pech gehabt, geht nicht
 throw new NotSupportedException();

Ohne weiteres zutun werden jetzt schon Int16, Int32, Int32, Double, Decimal, sämtliche Enums, Boolean, DateTime, Point, Size, Rectangle u.v.m. unterstützt. Und wenn jetzt jemand seine ganz eigene Klasse, die du zur Compilezeit nicht kennst, erstellen will, dann brauch er nur einen TypeConverter schreiben und das sollte er eh tun, wenn es sinnvoll ist.

@Omit:
Von Wasserstoffspeicher halte ich ehrlich gesagt wenig, weil ich käme mir blöd vor eine fahrende Bombe rumzufahren. Gut, in gewissem Sinne sind heutige Autos das auch, aber bei Wasserstofftanks würde ja schon ein Leck reichen, der Wasserstoff würde sich irgendwo ausreichend erhitzen und hochgehen. Meiner Meinung nach Brennstoffzele ja, unbedingt, aber keine Wasserstoff-Brennstoffzelle. Was sonst ist ne gute Frage, zumal keinen Stoff dieser Welt haben wir mehr als Wasserstoff, da wär es schon sinnvoll, den auch einzusetzen, aber ich glaube nicht dran.

Außerdem denk ich, ist Atomstrom nur bedingt eine langfristige Lösung, besser würd ich finden, wenn man ein Fusionskraftwerk in die Wege bringen würde. Brennstoff dazu ist ja wieder genug da, außerdem würde das den Helium-Mangel beheben...

Aber was den Atomstrom angeht geb ich dir vollkommen Recht: Lieber 100 neue Anlagen, als 1 alte (sowjetische).

int getRandomNumber()
{
    return 4; //chosen by fair dice roll
                 // guaranteed to be random
}

//edit: Orginal hier.

MSI Notebook
Turion X2 TL-60 (2x2,0Ghz)
2Gb RAM
160Gb HDD
ATI HD 2400
15,4"

Angenommen, ich will einem Objekt, was eine Size-Property bereitstellt eine neue Höhe verpassen, dann ist ja klar, dass sowas

obj.Size.Height = newHeight;

nicht zum Ziel führt (teilweise merkt der Compiler das sogar und meckert rum). Also muss man die Struktur erstmal in einer Variablen zwischenspeichern:

Size s = obj.Size;
s.Height = newHeight;
obj.Size = s;

Das setzt aber voraus, dass Size mutable ist. Aber es geht ja bei einer so simplen Struktur auch deutlich einfacher, ohne zusätzliche Variable und ohne unnötige Voraussetzungen, ob Size jetzt mutable oder nicht ist:

obj.Size = new Size(obj.Size.Width, newHeight);

Ich frage mich lediglich, warum man dann nicht gleich alle Strukturen, die nur zwei Eigenschaften haben, als immutable implementiert hat. Weil das eigentliche Problem ist, dass man, wenn die Struktur mutable ist, auch über die Variante ganz oben nachdenken könnte, und die folgt zwangsläufig zu einem Bug.

//edit: schließenden CSHARP-Tag vergessen

ich gehe davon aus, dass der Benzinpreis sich in den nächsten 10-20 Jahren real mindestens verzehnfachen wird

Das würde ich nicht denken. Bis jetzt sollte der Ölvorrat schon dreimal oder mehr aufgebraucht worden sein und immer hat man noch ein Feld gefunden. Sibirien hat man bislang noch ganz wenig auf Ölvorkommen untersucht und die haben ja erst neulich ein paar Blasen Methan da entdeckt, und wo Methan ist, da ist in der Regel auch Öl.

Ich glaube nicht, dass sich der Spritpreis verzehnfacht, aber er wird in 10-20 sicherlich real ein vielfaches Kosten (meine Vermutungen gehen eher drei-bis vierfache). Außerdem hoffe ich ja doch, dass man in 10-20 Jahren schon vernünftige Elektroautos bauen kann, die man zur Not immernoch mit Atomstrom betreiben könnte. Ich mein, der Volt z.B. hat ja jetzt eine Reichweite von 80km rein elektrisch. Wenn man das auf 300km pushen könnte, dann würde das wahrscheinlich für die allermeisten Fahrten reichen - zumindest für den Personenverkehr.

du könntest auch einfach alle Methoden ausführen und in der jeweils ersten Zeile der Methoden sagen, dass die sich beenden sollen, wenn das übergebene Objekt null ist. Das würde diese Methoden gleichzeitig robuster machen.

Alternativ kannst du natürlich auch ewig lange ineinander verschachtelte if-Schleifen machen.

Sinnvoll würde ich auch finden, wenn die Methoden einen Boolean Rückgabewert hätten, der angibt, ob das Ganze was gebracht hat oder nicht. Damit kannst du den ganzen Scheiß in eine einzige if-Schleife setzen.

Nimm doch \w, da sind die Umlaute mit drin, und hau bei Bedarf das, was du nicht brauchst, wieder raus, ohne Zahlen also beispielsweise [\w^\d].

Du kannst natürlich nicht von jetzt auf gleich dir alle Autos weg denken ohne dabei die ÖPNV-Systeme anzupassen, das würde kein ÖPNV-System verkraften.

Was ich so als die größten Probleme dabei erachte sind zum einen, dass es imho nicht ausreicht, die bestehenden Systeme einfach mit mehr Bussen, Straßenbahnen oder U-Bahnen auszustatten, sondern dass da noch heftige logistische Probleme dazu kommen die Menschen schnell genug von den Haltestellen weg zu kriegen um diese nicht komplett zu überfüllen.

Aber selbst wenn man wirklich den kompletten Personenverkehr öffentlich machen kann, dann ist es mir immernoch ein Rätsel, wie man den "persönlichen Güterverkehr", also z.B. den wöchentlichen Großeinkauf, in öffentliche Verkehrsmittel kriegt.

Aber wie sieht es mit boxed Int aus:
int? a = 0;
Sieht für mich auch immutable aus.

Hm, also meiner Auffassung nach ist boxed int schon mal was ganz anderes als int?. Boxed int wäre eher sowas:

Object a = 0;

also die Zuweisung einer ValueType-Konstante (0) zu einer Variable eines Typs, der nicht von ValueType erbt, wodurch für diese Konstante Speicher auf dem Heap reserviert werden muss, während

int? a = 0;

eine Zuweisung der 0 zu einer Nullable<int> Struktur ist, die ganz ähnlich zu int von ValueType abgeleitet ist und der Begriff immutable damit Definitionssache ist. Nach untenstehender Definition wäre int? immutable, ja.

Aber erstmal zu mutable und immutable: Man kann immutable ja auch definieren als alles, was mit dem hübschen Attribut ImmutableObjectAttribute markiert ist - mit der Folge, dass man alles, was in der mscorlib steht schon mal vorweg ausklammert.

Meine Definition für mutable wäre die folgende: Eine Klasse heißt mutable, wenn sie als nicht vererbbar gekennzeichnet ist, nicht abstrakt ist und mindestens eine nicht statische, öffentliche Methode existiert, für die Parameter existieren, sodass diese Methode mindestens ein Feld (und damit den inneren Zustand des Objekts) derselben Instanz verändert. Nach IL-Sinn sind allerdings auch Property-Setter als Methoden zulässig.

Leider kann man die Implementierung von String im Reflector nicht sehen, aber anhand der Tatsache, dass keine öffentliche Methode von String dieselbe String-Instanz verändert sondern wenn schon denn schon eine neue String-Instanz zurückgibt, kann man schon sagen, dass String immutable ist. Bei Int16, Int32, Int64 und wie sie alle heißen sieht die Sache nicht anders aus, auch die sind immutable.

Interessanterweise sind aber nicht alle von ValueType erbenden Objekte immutable. Alle Enums sind immutable und alle in der mscorlib definierten Zahlendatentypen auch - aber System.Drawing.Size aus der System.Drawing ist beispielsweise mutable, allerdings sehe ich nicht wirklich einen Grund dafür, aber auch keinen dagegen (außer vielleicht, dass es erstmal verwirend ist).

Ach ja und

Es wird mit += oder so, kein neuer Bereich auf dem Heap allokiert

Doch, mit += wird neuer Speicher allokiert, da wie herbivore in seinem Beitrag auch geschrieben hat a += b zu a = a + b umgesetzt wird.

Man kann Variablennamen auslesen, der Reflector kann es ja auch, aber ich kenne keinen anderen Weg als den, den auch der Reflector geht: Ab in die Methode und dann das Byte-Array namens IL-Code auslesen. Viel Spaß dabei 🙂

Also ich hab auf meinem Laptop auch Vista (war vorinstalliert), und ich muss sagen, Vista hat bei mir ein paar kleinere Spinnereien, die ärgerlichste davon ist, das Strg+V im Explorer nicht funktioniert. Abstürze? Naja, der Explorer pre-SP1 kann Verknüpfungen mit gelöschtem Verknüpfungsziel nicht und hat sich immer aufgehangen. Systemabstürze hab ich noch nie erlebt, auch vor SP1 nicht (was ich erst vorgestern oder so draufgespielt hab). Auch so Ladezeiten bin ich voll und ganz zufrieden, der Rechner startet für gewöhnlich in unter einer Minute, absolut OK so.

Den Mehrbenutzerbetrieb find ich so in Vsta aber richtig klasse, bin normalerweise als Standardbenutzer drin (es gibt auch ein undoc feature, wie man vista einstellen kann, dass automatisch ein benutzer geladen wird und man den anmeldebildschirm nicht sieht) und wann immer was installiert wird und der meint admin-rechte zu benötigen kommt halt dann die abfrage nach dem admin-Paswort und der Prozess läuft als Admin weiter. Das hat tw. lustige Nebenwirkungen, weil ich beispielsweise bei der Firefox-Installation den nachher gleich starten lassen hab, den ausführlich konfiguriert hab - und nachher gemerkt hab, dass der die ganze Zeit als admin läuft und ich den für den admin-Account konfiguriert hatte.

Ich glaube den größten Fehler, den man bei der Rechnerkonfiguration für Vista machen kann, ist eine onBoard Grafik. Genau die ist aber Standard auf Business-Rechnern. Wenn ich mir Vista anschaue, dann erkenne ich an einigen Stellen, dass die wahrscheinlich WPF benutzt haben (Vista kommt ja auch standardmäßig mit .NET 3.0). Wenn dem so ist, dann greift Vista beim rendern auf die Grafikkarte und DurectX 9 zurück. Wenn der Onboardchip das nicht kann (er wirds wahrscheinlich nicht wirklich hinkriegen), dann muss das halt softwaregerenderet werden, und das ist verdammt teuer...

@EasyRider:

Ich würde als erstes mal die Zeile

diff = end.Millisecond - start.Millisecond;

mit

diff = (end - start).TotalMilliseconds;

ersetzen und diff double deklarieren. Grund: Sei start von der Zeit her 1s 980ms und end 2s 30ms, dann sollte bei diff dann 30-980, also -950s drinstehen.

@MrSparkle:

Hm, ich würde an deiner Stelle noch freqFactor in einer Property zugänglich machen, weil es mal interessant zu wissen ist, in welcher Genauigkeit das System so arbeitet. Bei mir (Amd-Dualcorelaptop mit 32bit Vista Sp1) kam eine Genauigkeit von 7*10^-8 s raus - was zwar noch lange nicht nanosekundengenau ist, aber mit einer Genauigkeit von 70ns kann man ganz gut leben glaub' ich. Wäre nur noch die Frage wie zuverlässig die Genauigkeit hinsichtlich ihrer Konstanz ist. Du gehst jetzt einfach davon aus, dass sie das ist, ich frage mich aber, ob du das so einfach machen kannst.

da ich jetzt auch angefangen habe in Karlsruhe Info zu studieren: Gibts den Ideensalon noch?

Ja, leider das gleiche.

Aber auch die Sache mit dem SSL kommt ja alles viel später. Klar müssen da Zertifikate ausgetauscht werden und ein Handshake muss ausgehandelt werden und was weiß ich nicht alles. Aber erstmal muss die Verbindung doch da sein.

Ich hatte es ja mal am laufen und hab seitdem eigentlich nichts verändert. Kann höchstens sein, dass Google sich jetzt nicht mehr ansprechen lassen will, aber zum einen kann ich mir das nicht vorstellen, zum anderen macht er mit GMX den selben Ärger. Meine eigene Personal Firewall kann es nicht sein, weil als ich die ausgestellt hab gings auch nicht besser, Router-Firewall hätte früher auch angeschlagen, tat sie aber nicht. Leider hab ich den Code von der ersten Testvariante nicht mehr da, sonst könnt ich ja einfach Code vergleichen.

Vielleicht will 1&1 nicht, dass die Leute Gmail benutzen, zumal das in Deutschland ja nicht einmal Gmail heißen darf... 🤔 X(

/edit: Grad mal probiert mit Emailprogramm: Windows Mail will mir Gmail auch nicht abfragen, also scheint es wirklich ein Problem außerhalb des Codes zu sein

Ich steh gerade echt auf dem Schlauch, zumal das Thema Netzwerkprotokolle für mich absolutes Neuland ist, aber bei

TcpClient tcp = new TcpClient("mail.google.com",995);

sollteman doch eigentlich meinen, dass es da wenig gibt, was nicht funktionieren könnte, zumal Google ja doch schon recht zuverlässige Server hat und Port 995 der Standardport für SSL-Pop3 ist. Es kommt aber nach einer Weile folgende SocketException:

Ein Verbindungsversuch ist fehlgeschlagen, da die Gegenstelle nach einer bestimmten Zeitspanne nicht richtig reagiert hat, oder die hergestellte Verbindung war fehlerhaft, da der verbundene Host nicht reagiert hat 209.85.137.18:995

Gut, OK, klingt nach Firewall, die den Port blockiert, aber genau das ist nicht der Fall. Ich setzte einfach nur die Windows-Firewall ein, hab da auch schon probiert explizit den Port 995 zu erlauben oder die Firewall gleich ganz abzuschalten, leider ohne Erfolg.

Danke schonmal im Voraus

@JAck30lena:
Was ist denn daran schwer? File|Open 🙂 wie auch sonst?
Zumindest meine Version (5.1.1.0) kann man ohne weiteres die exe kopieren und mit einer ausgeführten exe die andere reflektieren. Man muss erstmal suchen, bis man die Klassen gefunden hat (zwei von drei Namensräumen nur mit Schnittstellen und Enums), aber dann...

Die Frage war ja nach der Definition, nicht nach der Verwendung 🙂
Aber du hast Recht, der sauber definierte Delegate hat in dem Codeschnipsel keine Verwendung.

Naja, wenn du dich durch die Klassen im Namensraum System.Reflection durchhangelst, dann hat die Klasse MethodBody heißt die glaub' ich eine Methode, die den IL-Code als ByteArray zurückgibt.

Testcode zum auslesen des ILs für die GetType-Methode

typeof(object).GetType.GetMethod("GetType").GetMethodBody.GetILAsByteArray()

Ich hab Mono nie benutzt, aber da sollten die Klassen ähnlich sein und Mono sollte in der Lage sein beliebige CLR-Assemblies einzulesen.

Ja und dann darfst du dich durch die Dokumentation von IL arbeiten und versuchen aus diesem ByteArray schlau zu werden.🙂

das mir der ansatz fehlt die arrays ins masterarray zu schreiben 😕

aber genau das machst du doch schon.

arrayMaster[0] = array1;  
            arrayMaster[1] = array2;  
            arrayMaster[2] = array3;  
  

Arrays sind immer Referenztypen, d.h., in dem Masterarray stehen jetzt drei Referenzen auf die jeweiligen untergeordneten Arrays.

Equals so zu überschreiben halte ich für eine schlechte Idee, weil man zwei Personen mit gleichem Namen dann nur noch mit Object.ReferenceEquals auseinanderhalten kann, was verdammt unintuitiv ist und damit Bugs heraufbeschwört.

Was kann man denn mit deinem Konverter alles konvertieren? Ich würde nämlich vermuten, dem Designer zu wenig. Der Designer will meist eine Konvertierungsmöglichkeit von und nach string und System.ComponentModel.Design.Serialization.InstanceDescriptor!

Naja, alles was Mdi heißt finde ich kann man mit der DockPanel Suite von Weifen Luo sehr einfach aufpeppen...

Danke für den Tip. GetMethods hat mir auch verraten, dass int gar keine Methoden hat, solange an nicht angibt, dass man die öffentlichen Methoden haben will...

Die Methode System.Int32.GetType konnte nicht gefunden werden.

bei

typeof(int).InvokeMember("GetType", Reflection.BindingFlags.Instance | Reflection.BindingFlags.InvokeMethod, null, 1, Type.EmptyTypes);

Ich meine, Int32 deklariert die Methode nicht, aber sollte InvokeMethod nicht eigentlich auch über die vererbten Methoden drübergehen? Ich steh grad bisschen auf dem Schlauch...

eben ein solche konkretes Objekt nicht true liefern würde, weil eine Klasse keine Unterklasse von sich selbst ist?

genau das meinte ich 🙂

Der Name impliziert das zumindest, ich habs aber nicht geprüft. Aber in jedem Fall geht IsSubclassOf nicht über die Schnittstellen. Was allerdings ganz klar gegen IsAssignableOf spricht ist die Tatsache, dass man sehr leicht Gefahr läuft die beiden Type-Objekte, die man da braucht, zu verwechseln, weil man es intuitiv falsch macht 😦. Für mich ist es der Inbegriff der Tatsache, dass Namenskonventionen manchmal auch nach hinten losgehen können...

Was du im Übrigen auch machen kannst, ist statt dem XmlSerializer (dem übrigens das Serializable-Attribut egal sein sollte) den System.Runtime.Serialization.Formatters.Soap.SoapFormatter (so oder so ähnlich, hat in jedem Fall eine eigene Assembly) benutzen, der erzeugt auch Xml und kommt glaube ich sogar mit zirkulären Verweisen zurecht, ABER du kannst das Aussehen der Xml-Datei in keinster Weise beeinflussen...

Type.IsSubclassOf funktioniert solange, wie die Basisklasse abstrakt ist. Wenn du dich aber irgendwann dafür entscheiden solltest, die Basisklasse nicht mehr abstrakt zu machen, oder aber du machst das was jetzt die abstrakte Basisklasse ist zu einer Schnittstelle, dann wäre Type.IsAssignableOf das Mittel der Wahl.

Letztenendes ist als Type.IsSubclassOf die performantere, Type.IsAssignableOf die allgemeinere und damit wartungssicherere Lösung.

Naja, ich weiß der Fall wird in der Praxis nie und nimmer eintreten, aber wofür ist man sonst Theoretiker 🙂

Es gibt ja Einzelinstanzanwendungen, die also, wenn man sie mehr als einmal öffnet, entweder die übergebenen Kommandozeilenparmeter nur auslesen oder was auch immer machen, aber sich kein zweites mal öffnen. Wenn man nun bei so einer Anwendung Process.Start und Application.Exit macht, kann es, wenn man Pech hat, dazu kommen, dass das Abfangen der neuen Instanz vor dem letztendlichen schließen der eigenen Instanz passiert, und dann hätte man nur das eigene Programm geschlossen, ohne dass es neu gestartet würde.

Was im Normalfall wenn jemand vor dem Rechner sitzt ja nicht so das Problem ist, aber wenn ich mal weiterspinne und diesen Neustart eines möglicherweise wichtigen Programms auf einem Server nachts halb drei spielen lasse, dann kommen die Leute früh auf Arbeit und es geht nichts un die müssen erstmal den Admin wecken gehen.

Zugegebenermaßen, der Fall ist verdammt konstruiert.

Aber wie würde man das Lösen? Außer ein mächtigeren Hammer zu nehmen (Environment.Exit) kann man eigentlich nicht besonders viel dagegen tun, oder? Ausgenommen natürlich wichtige Programme nicht als Einzelinstanzkonsolenanwendung zu programmieren...

Wenn ich mit foreach über ein Objekt von Test2 gehe, dann springt der Haltepunkt bei der generischen IEnumerable<string> an, obwohl Test2 explizit IEnumerable implementiert.

public class Test1 : IEnumerable<string>
    {

        #region IEnumerable<string> Member

        public IEnumerator<string> GetEnumerator()
        {
            throw new NotImplementedException();
        }

        #endregion

        #region IEnumerable Member

        IEnumerator IEnumerable.GetEnumerator()
        {
            throw new NotImplementedException();
        }

        #endregion
    }

    public class Test2 : Test1, IEnumerable
    {

        #region IEnumerable Member

        IEnumerator IEnumerable.GetEnumerator()
        {
            throw new NotImplementedException();
        }

        #endregion
    }

Wenn ich dagegen eine x-beliebige Collection habe, brauch ich nur normal prüfen, ob die IEnumerable implementiert, caste drauf und dann hat der Compiler gar keine andere Chance als die nicht generische Variante aufzurufen, weil er selber nicht weiß, welches IEnumerable er sonst aufrufen soll.

Ich denke eher, dass der Compiler wenn die generische Variante machbar ist auf die generische Variante zurückgreift. Welche von den beiden jetzt explizit oder vererbt ist, wird dem Wurscht sein.

IEnumerable macht spziell dann Sinn, wenn eine Collection hat, von der man zwar weiß, dass es eine Collection ist, aber man weiß den Typ nicht und es ist enem eigentlich auch mehr oder weniger egal, man will aber möglichst einfach an die Elemente der Collection ran. Ich denke dabei an Klassen, die x-beliebige Inhalte serialisieren oder darstellen (z.B. XmlSerializer, wenn man denn einen eigenen schreiben wölte).

Hm, da ~ und ^ beide Int32-Operatoren sind, wird vor allem auch der Eingangswert als Int32 impliziert konvertiert, d.h., aus 01010101 wird dann 00000000000000000000000001010101. Das wiederum invertiert ist 11111111111111111111111110101010, was negativ sein dürfte und beim Konvertieren nach Byte schöne Konvertierungsfehler bringt. Die beste Variante wäre wohl, sich den Int32 per Bitconverter in ein Bytearray kloppen zu lassen und dann einfach nur das entsprechende Byte auszuwerten.

Welche .NET Versionen sind denn auf den Rechnern, bzw. vor allem welche SPs derselbigen?

Naja, vom Prinzip her geb ich meinen Vorrednern Recht, bleibt jetzt nur noch das Problem das ganze "einigermaßen sicher" zu machen.

Problem: Definiere "einigermaßen"...

Datenbanken sind da auch nur unter Umständen notwendig, weil man ja bei Highscores meistens immer nur die ersten zehn oder so speichert. Und das geht auch grad noch so ohne einer Datenbank im Backend.

Viel schwieriger ist es aber sicherzustellen, dass der Aufruf nicht gefaket ist. Alles, was du machen kannst, ist nur den Anfragen irgendeinen Sicherheitscode einzuimpfen (wie bei Bildern Wasserzeichen) und darauf hoffen, dass das keiner knackt.

Eigenschaftsfenster schließen, das jemand sowas tun würde, daran hab ich ja gar nicht gedacht. 🙂 Gibt jetzt ein Menüpunkt, mit dem man es wieder herzaubert, außerdem ist es nicht wirklich weg (schätze der Fehler war der, dass das Eigenschaftsfenster was anzeigen sollte, obwohl es das schon nicht mehr gab...).

Zur Bedienungb schreib ich gleich noch was in den ersten Post

Abhängig davon, was du mit den komplexen Zahlen machst kann es auch sinnvoll sein nicht die Koordinaten- sondern die Polarform der komplexen Zahlen zu speichern. In der Polarform lassen sich komplexe Zahlen deutlich einfacher multiplizieren und e^(ix) verkommt zum Witz (r=1 und phi=x). Einzig kompliziert ist die Addition (und damit logischerweise auch die Subtraktion). Aber das sind alles wieder Optimierungsideen...

Ja, das wäre es. (Auch wenn das Details sind, die mit der Mathematik nichts zu tun haben). Du kannst alternativ auch die Operatoren überladen, dann liest sich Code besser.

Ich kenne FFT nicht, aber warum geht ihr alle davon aus, dass g real und u imaginär ist? e^(-2Pii*k/n) ist nichts weiter als ein Vorzeichen. Das kann aber abhängig von k und n alles auf dem Einheitskreis sein. Bei k=0 oder k=n wäre das Vorzeichen z.B. ein + und zwar ein stinknormales reales +.

Am einfachsten ist glaub ich, wenn du die Textdatei ins Projekt mit einfügst, in den Eigenschaften auf Immer kopieren umstellst, dann hast du sie im gleichen Verzeichnis wie die .exe und ClickOnce integriert die Exe mit in das Setup. Bei Setup-Projekten zählt die Textdatei dann im Übrigen auch mit zur primären Ausgabe.

Ich hab auch nichts gefunden. Aber vielleicht hilfts ja wenn du die Controls ableitest und der abgeleiteten Klasse das DefaultEvent-Attribut mit auf den Weg gibst und einfach nichts einträgst.

Ich hab mal noch, damit es ein Puzzle zum Testen gibt eins angehängt, mit speziellem mycsharp-Motiv 🙂

Mist, am 3.9 war ich noch im Urlaub. Nächstes mal komm ich bestimmt...

Ist nich nur eine exe, weil als ich angefangen habe das Teil zu entwickeln war ich gerade in Irland, weshalb das Ding schonmal mehrsprachig ist (Deutsch und Englisch, mehr Sprachen kann ich nicht 🙂). Außerdem sind die ein paar Teile in Bibliotheken ausgelagert...

//edit: Aber von dieser bahnbrechenden Leistungsfähigkeit von ClickOnce bin ich hellauf begeistert 🙂 Naja, kann mir ja bald als Student die Professional ziehen...

hier noch ein Screenshot dazu...

Hallo zusammen,

na dann werd ich auch mal mein derzeitiges Projekt hier zum Testen zur Verfügung stellen. Es handelt sich um ein Programm, mit dem Logikpuzzle (die von P.M., wenn die jemand kennt) erstellt und gelöst werden können.

Im Moment beherrscht das Programm ein- und mehrfarbige Logik- und Chiffrier- sowie einfarbige Labyrinthpuzzle. Die anderen Rätseltypen will ich noch ergänzen, wobei ich als nächstes die Mosaikpuzzle anvisiert habe.

Ihr könnt's euch ja mal anschauen. Das Lösen der Rätsel funktioniert soweit, und da das Lösen nicht über SAT funktioniert, sondern genau so, wie man sie als Mensch auch Lösen würde, sind noch so'ne Nettigkeiten wie Punkte automatisch setzen und fertige Blöcke wegstreichen implementiert.

Zur Bedienung: Am Anfang sieht man ja erstmal herzlich wenig. Man hat eigentlich nur zwei Möglichkeiten, nämlich zum einen ein neues Puzzle zu erstellen (Datei|Neu) oder ein altes zu laden (Datei|Öffnen).

In jedem Fall öffnet sich dann ein Fenster mit dem neuem oder geladenen Puzzle, entweder im Entwurfs- oder Lösemodus. In jedem Fall kann man die Kästchen des Puzzles mit der Maus bearbeiten. Linksclick färbt das Kästchen in der aktuell ausgewählten Farbe (bei einfarbigen Puzzlen immer Schwarz, bei mehrfarbigen Puzzlen ist oben links eine Farbpalette), Rechtsclick macht einen Punkt in das jeweilige Feld, bzw. setzt es in den Urzustand zurück.

Man kann die Maus auch gedrückt halten und dann über das Puzzle fahren, dann werden alle Felder, über die man drübergefahren ist (mit gedrückter Maustaste) entsprechend gefärbt (oder entfärbt, wenn man das mit der rechten Maustaste macht).

Im Entwurfsmodus kann man außerdem noch den Namen, die Beschreibung und die zu verwendenden Farben des Puzzles bestimmen. Wenn man im Entwurfsmodus die Kästchen setzt, dann werden die Zahlen, die die entsprechenden Blöcke repräsentieren, immer aktuell gehalten. Sollte sich dazu das gesamte Puzzle vergrößern müssen (damit diese Zahlen alle hin passen), dann wird das Fenster automatisch vergrößert, sobald man die Maus losgelassen hat.

Ich freu mich schon auf die vernichtende Kritik 🙂

//edit: Attachment nochmals ausgetauscht

Das Bild ist schon ein Jahr alt, aber ich hab mich äußerlich nicht wirklich verändert. Und es ist auch im Urlaub 🙂

Naja, mir ist bisher nichts besseres eingefallen, aber euch ja vielleicht..

Situation ist die: Das Ganze ist Teil eines medizinischen Dokumentationsprogramms, bei dem natürlich medizinische Befunde in Unmengen produziert werden. Weil diese Befunde sich auch mal ändern können müssen, bzw. komplett neue kommen können müssen, hab ich das mit Berichten realisieren wollen. Da man bei den Reporting Services bei einmal veröffentlichten Berichten die Query aber nicht mehr ändern kann, musste ich das jetzt schon so machen, dass ich der Liste sage, dass sie ihren Inhalt nach einem Berichtsparameter filtern soll, wobei ich da schon ziemliche Performancekosten auf mich nehme wenn diese Filter optional sein sollen (weil Blutbildbefunde nach Patient oder Blutbild gefiltert werden sollen). Gedacht ist für diesen Fall wahrscheinlich eine programmatische Nutzung der Reporting Services, bei denen man eben doch mal kurz im Bericht die Query verändert. Der Weg scheidet aber für mich aus, weil die Leute, die das dann machen sind zwar Dokumentare (bzw. im Großteil Dokumentarinnen, aber egal) oder sogar Biometriker, die zwar wissen wie Datenbank geschrieben wird, aber deren Programmierkünste vielleicht noch zum notdürftigen Zusammenschrauben von Access-Datenbanken ausreichen.

Aber es wundert mich einfach, weil es eben in der Vorschaufunktion im Visual Studio (die Uniklinik hat noch Whidbey) tadellos funktioniert, sobald ich das Ding aber bereitstelle sind die beiden Parameter verschwunden. Und auch nur die beiden Parameter, die mir wirklich wichtig sind, die anderen beiden gibt's ja noch und auch nach denen wird gefiltert (Von-Datum, Bis-Datum).

Naja, ich hatte schon kurz überlegt, ob ich mir mittels PDFSharp ein eigenes Berichtssystem zum direkten PDF-Export zusammenbastle, aber ich werd mir auf alle Fälle mal fyiReporting und die Engine von #develop mal anschaun, Danke für den Link.