Hmm, wer auch immer darauf besteht, dem kannst du auch gleich das Zitat um die Ohren hauen. 😉 Und dann auch gleich fragen warum auf der ArrayList bestanden wird.

Mach die Klasse Note public.

edit: Weils mir gerade auffällt. Falls du vorhast ArrayList zu verwenden zitiere ich mal herbivore: "ArrayList gehört in die Mottenkiste und sollte wie alle untypisierten Collections aus System.Collections nicht mehr benutzt werden. Verwende stattdessen List<T> und alle anderen typisierten Collections aus System.Collections.Generic."

Schau dir mal den WindowTabifier an.

Ich stehe vor folgendem Problem und weis nicht so recht wie ich das GUI gestalten soll, um nicht überladen zu wirken, möglichst usability-freundlich zu sein und die wichtigen infos auf einen Blick zu erkennen.

Es gibt eine Tabelle mit Zahlungseingängen und eine mit offenen Beträgen. Die Tabellen stehen in einer m:n Beziehung.
Der User wählt, dass er zb alle Zahlungen sehen will, die noch nicht zugewiesen wurden, oder eben Zahlungen die bereits zugewiesen wurden.

Ich habe mir gedacht einfach 2 Datagridviews nebeneinander anzuzeigen. Die Zahlungen werden per Drag&Drop zugeordnet, wobei es auch möglich sein muss Teilzahlungen zuzuordnen. Um das ganze dann visuell darzustellen sollen Pfeile angezeigt werden.

Nur je mehr ich darüber nachdenke umso weniger gefällt mir die Idee. Evtl wirkt das ganze dann überladen mit den Pfeilen.
Fällt euch deshalb etwas passendes ein um das benutzerfreundlich zu gestalten und visuell darzustellen?

Crossposts sind nicht gerade die feine Art.

Vielen Dank. Das Problem ist gelöst. talla brachte mich auf die richtige Spur.
So klappts nun:

        XmlDocument doc = new XmlDocument();
        doc.LoadXml(xml);

        //Create an XmlNamespaceManager for resolving namespaces.
        XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
        nsmgr.AddNamespace("default", "http://www.ecb.int/vocabulary/2002-08-01/eurofxref");
        nsmgr.AddNamespace("gesmes", "http://www.gesmes.org/xml/2002-08-01");

        XmlNode n = doc.DocumentElement.SelectSingleNode("//gesmes:Envelope/default:Cube/default:Cube/default:Cube[@currency='USD']", nsmgr);

Das Geheimnis ist folgende Zeile:

nsmgr.AddNamespace("default", "http://www.ecb.int/vocabulary/2002-08-01/eurofxref");

Einfach für den Default-Namespace ein frei-wählbares Präfix vergeben.

Ich versuche mittels XPath von folgendem Dokument die Umrechnungskurse auszulesen.

Ich kann die Knoten mit Namespace problemlos auslesen nur die ohne, also die Cube Nodes nicht.

Folgendes klappt wunderbar:

        XmlDocument doc = new XmlDocument();
        doc.LoadXml(data);

        XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
        nsmgr.AddNamespace("gesmes", "http://www.gesmes.org/xml/2002-08-01");

        XmlNode n1 = doc.DocumentElement.SelectSingleNode("//gesmes:Envelope/gesmes:Sender", nsmgr);

Nur sobald ich versuche auf ein Cube Element zuzugreifen geht es nicht:

XmlNode n2 = doc.DocumentElement.SelectSingleNode("//gesmes:Envelope/Cube/Cube/Cube[@currency='USD']", nsmgr);

Ich kann ja nichtmal auf den ersten Knoten zugreifen:

XmlNode n3 = doc.DocumentElement.SelectSingleNode("//gesmes:Envelope/Cube", nsmgr);

Wie schaffe ich es die Umrechnungskurse mittels XPath auszulesen?

Hi

static wäre das Äquivalent.

Wobei das ja eigentlich keine schlechte Idee wäre.
Dank IntelliSense sehe ich ja welche Exceptions zb vom StreamReader geworfen werden. Jetzt könnte VS ja gleich den entsprechenden try catch Block einfügen, der diese Exceptions fängt.

Ich würde die as Variante verwenden:

        private void pictureBox_Click(object sender, EventArgs e)
        {          
             PictureBox pictureBox = sender as PictureBox;
             if (pictureBox != null)
             {
                string filename = pictureBox.Name;

                MessageBox.Show(filename);
             }
        }

Grad in nem anderen Forum entdeckt:

private void NewFile()
{
    if (Directory.Exists(@"C:\Windows\_NOTIZEN_\"))
    {
        
    }
    else
    {
    // Specify a "currently active folder"
    string activeDir = @"C:\Windows\";

    //Create a new subfolder under the current active folder
    string newPath = System.IO.Path.Combine(activeDir, "_NOTIZEN_");

    // Create the subfolder
    System.IO.Directory.CreateDirectory(newPath);        
    }
    
    if (File.Exists(@"C:\Windows\_NOTIZEN_\Notizen.txt"))
    {
        
    }
    else
    {
        if (File.Exists(@"C:\Windows\_NOTIZEN_\"))
        {
            StreamWriter sw1 = new StreamWriter(@"C:\Windows\_NOTIZEN_\");
            StreamWriter sw = new StreamWriter(@"C:\Windows\_NOTIZEN_\Notizen.txt");
            sw.Close();			
        }       
    }        
}

Die Idee, bei allen einfach mal anzuklopfen hatte ich auch schon, nur wusste ned wie. Mit Broadcast-Paketen hab ich nochnie gearbeitet.

Wie versendet man welche? Beim Socket muss man ja immer ne Ip , also einen einzelenen Empfänger angeben.
Das ist beim Broadcast auch so, nur sendest du an die Broadcast-IP des Subnetzes bzw am einfachsten an 255.255.255.255.

> findest du ein passendes Snippet.

Ich würde einen Broadcast beim Starten des Programmes schicken bzw in periodischen Abständen. Sobald Sie sich "gefunden" haben kannst du ja die Verbindung aufbauen.

Ich würde zu einem 14" raten, da hast du meiner Meinung nach das Optimum aus Portabilität(nicht zu schwer zum herumschleppen für Uni und Co, und gleich schwer bzw nur minimal schwerer als 13"), Bildschirmauflösung und -größe.
Ich hab mir damals für Studium ein IBM Thinkpad T61 in 14,1" zugelegt und war vollstens zufrieden damit.

Warum verwendest du nicht gleich Serialisierung? Das Ganze dann gleich generisch: hier

Was mit gerade auffällt.
Ich würde die do-while Schleife auf eine while ändern. Sonst erhältst du unter Umständen ein NullReferenceException bei line.Contains(suchstring)

Irgendwie erinnert mich das an AntMe. Eventuell kannst du da ja ein paar Ideen gewinnen.

Da du dich in hibernate auskennst, nimm doch einfach die Portierung nhibernate 😉

Hier findest du eine Übersicht über die GUI Toolkits.
Ich habe selbst schon mit wx.net unter MacOS X gearbeitet. Wie gesagt hat man natives Look&Feel. Das einzige was etwas nervig ist sind die Sizer. Unter Windows.Forms ist das schnell mit Dock und Anchor erledigt. Mit Sizer kann das etwas ausarten, va am Anfang etwas kompiziert imho.
Aber sobald man sich da eingearbeitet hat, klappt das dann.

Nimm einfach File.AppenAllText() und das Problem ist gelöst.

Equals wird wohl das einfachste sein und um sicher zu gehen, dass es sich um Enums handelt würde ich folgendes machen:

public static bool AreEqual<T>(T enum1, T enum2) where T : struct, IConvertible
{
    if (!typeof(T).IsEnum) 
      throw new ArgumentException("T must be an enumerated type");

    return enum1.Equals(enum2);
}

Nimm am besten TagLib#. Damit kannst du so ziemlich alles und jeden taggen. 😉

Aber erhält man nicht bereits mittels Queue.Synchronized() eine synchronisierte Queue. Wozu also eine selbst basteln?

Also daran kanns nicht gelegen haben, denn der FileShare Parameter nur für das nachfolgende Öffnen/schreiben der Datei verantwortlich ist. Also wenn der Gameserver die Datei bereits geöffnet hat, dann sollte trotzdem die Exception fliegen.
siehe FileShare-Enumeration

Ermöglicht das nachfolgende Öffnen der Datei zum Lesen oder Schreiben.

Es hat vermutlich deshalb funktioniert, da dein Prozess die Datei zuerst geöffnet hat und dank FileShare es der Server dann ebenfalls konnte.

Du musst den sender als CheckBox casten und dann mit dieser die Prüfung durchführen.
So wie ich das sehe, hast du mit deinem Programm nichts gutes vor.

Dazu gibt es einen Artikel auf Codeproject. Darin wird auch der von dir erwähnte AsyncOperationManager angesprochen.

Schau dir am besten den WindowTabifier an.

Ich würde das ganze mittels DateTime.Parse() und der passenden CultureInfo lösen.

Edit: Mittels Convert klappts auch, da man auch hier die passende CultureInfo angeben kann.

Du machst das dann folgendermaßen:

html.SubString(0, html.IndexOf("</div>"));

Der WindowTabifier dürfte genau das sein was du suchst.

Bisher habe ich es immer so gemacht, dass ich vorher mittels is geprüft habe und dann in den entsprechenden Typen gecastet habe. Z.B. um alle Textboxen eines Forms zu erhalten.
Jetzt habe ich mal die folgenden 3 Arten bzgl Performance/Zeit verglichen um alle Textboxen einer Form zu erhalten.

1. LINQ: War wie zu erwarten die langsamste Art
2. Prüfen mit is und dann casten. War nen Tick langsamer als 3.
3. Casten mittels as und dann Prüfung auf null

Jetzt frage ich mich welchen Sinn is noch macht. Man kann doch immer gleich mit as casten und dann auf null prüfen. Mir will kein Anwendungsfall für is einfallen.
In den FAQ wird erwähnt, dass die as Variante weniger Effizient wäre, was bei mir nicht der Fall war.

Eine weitere Möglichkeit wäre, dass du dir einen delegate mit der Signatur deiner Play Methode deklarierst und diesen dann asynchron aufrufst.

Man kann das ganze übrigens auch typesafe machen mittels anonyme delegates. somit spart man sich alles in ein objekt zu "stopfen".
eine weitere möglichkeit wären auch asynchrine delegates, da kann man beliebig mit out und ref paramtern hantieren.

Das sollte egal sein, da Windows bei dateinamen sowieso nicht zw Groß-Kleinschreibung unterscheidet.
Für Windows ist BLA.bla die selbe Datei wie bla.bla

Eigentlich schon nur war der sehr umständlich zu nutzen, da man den glaube ich erst selbst noch kompilieren musste. Weiters war er nicht in Monodevelop integriert, also nix mit Breakpoint setzen in der IDE. Das passierte alles noch oldschool via console ala gdb.

Ich würde das grundsätzlich anders lösen. Und zwar nicht jedes mal die Klasse danach fragen wie der Status ist, sondern die Klasse "sagt selbst"(also feuert ein Event) wenn es einen neuen Status gibt bzw der sich geändert hat.
So kommst du vom Polling weg.

Nur als kleine Info: Deine Schleife verursacht beim letzten Durchlauf eine IndexOutOfRange Exception, da am Index listView1.Items.Count kein Item vorhanden ist.

Also ich würde das folgendermaßen lösen, dass du das formclosing event von Form 2 dazu nutzt, das schließen abzubrechen mittels e.cancel und dann einfach this.Hide() aufrufst.
Weiters evtl noch die TopMost Eigenschaft auf true setzen damit es immer im Vordergrund ist.

Um zu erreichen, dass From2 minimiert wird wenn From1 minimiert wird einfach das Window.Owner Property setzen.

Also von DevCPP kann ich nur abraten. DevCPP war meiner Meinung nach nie wirklich gut und ist quasi immer noch im Beta Stadium. Die letzte Version wurde 2005 veröffentlicht.
Als die IDE erschienen ist gab es nur wenige freie Alternativen und so empfielt man es heute immer noch.
Ich würde zu Code::Blocks raten.

Viele fehlende, aber sehr nützliche Dinge(Properties(sollen ja in Java 7 kommen), Delegates, ...) wurden ja bereits genannt.
Aber es gibt in Java kein call by reference? Warum?

Ein klarer Fall für das Sieb des Eratosthenes

Ich hab mir damals dieses gekauft. Da hast du am Ende jedes Kapitels gleich ein paar Übungsaufgaben wo du das Gelernte anwenden kannst.

Ich würds mittels Dreieckstausch erledigen.

Mich würde mal interessieren wann ihr Objekte innerhalb einer Klasse erzeugt und ob es da so eine Art Guideline dafür gibt.
1: im Kontruktor

public class Foo
{
  Bar b;
  public Foo()
  {
    b = new Bar();
  }
}

2: bei der Deklaration

public class Foo
{
  Bar b = new Bar();
  public Foo()
  {
  }
}

Bringt eines der beiden Vorteile, oder ist es egal?

Hab mir vor einiger Zeit selbst mal so ein Tool programmiert. Inspiriert durch Launchy.
Ich find das System mit dem autoindexen genial. Naja jedenfalls war ich mit meinem Programm nie so zufrieden. Vielleicht werde ich das Projekt wiederbeleben und ne schickere GUI mittels WPF verpassen.

Das ist mittels Reflection kein Problem.
Du gehst alle elemente im xml durch und holst dir das passende Property

System.Reflection.PropertyInfo property = obj.GetType().GetProperty(propertyName);
property.SetValue(obj, value, null);

edit: Tjo zu langsam

Naja nicht ganz.
Ich habe das Encoding innerhalb meiner EncodeDisc Methode ja in einen eigenen Thread ausgelagert. Und durch die while Schleife(siehe meinen 1.Post) gewartet bis es fertig war. Durch die Application.DoEvents blockierte die Gui auch nicht.
Somit habe ich sozusagen ohne zu blockieren gewartet. 😉

Ich habe es übigens wie in diesem Artikel beschrieben mittels Subclassing Backgroundworker gelöst.
Das Encoding habe gleich in eine Klasse ausgelagert und diese erbt von Backgroundworker. Somit habe ich alle benötigten Features(GUI blockiert nicht und man wird über den Fortschritt des Encodens informiert)

Danke für die Antworten.
Da hatte ich offensichtlich den falschen Ansatz. Ich wollte erreichen, dass man die Methode EncodeDisc() aufruft und dann auf das Ergebnis wartet ohne das GUI zu blockieren.

Also der User klickt auf den Convert Button. Dann wird dieser disabled und die erwähnte Convert-Methode gestartet. Diese schreibt die Album und Track Information in ein XML und konvertiert die Tracks.
Das XML hat folgende Struktur:

<album>
<titel>testalbum<\titel>
<interpret>ich<\interpret>
...
<tracks>
<track>
<number>01<number>
<titel>track01<\titel>
...
<md5>acf412..<\md5>
<\track>
.
.
.
<\tracks>
<\album>

Klar ist das gut wenn mehrer Tracks parallel konvertiert werden.
Aber wenn ich das jetzt mittels Callback löse, dann habe ich ja im Callback keinerlei Info darüber welcher track gerade fertig konvertiert wurde und kann daher auch nicht das entsprechnde md5 node ins XML schreiben. Oder übersehe ich etwas?
Außerdem will ich den Convert button erst wieder enablen sobald der Konvertiervorgang abgeschlossen ist. In diesem Fall wird er ja sofort wieder enabled.

private void btEncode_Click(object sender, EventArgs e)
{
   this.btEncode.Enabled = false;
   EncodeDisc(src, dst, encodingparams);
   MessageBox.Show("Konvertierung fertig");
   this.btEncode.Enabled = true;       
}

Threadsynchronisierung wäre sicher eine Möglichkeit, aber im Prinzip kann ich mir den Aufwand ja mit meiner quick&dirty while Schleife sparen.