Laden...

Forenbeiträge von Tarion Ingesamt 381 Beiträge

28.05.2010 - 12:11 Uhr

Damit gehts:


Encoding encoding = Encoding.GetEncoding(1252);

28.05.2010 - 12:08 Uhr

Wie konvertiere ich bytes in einen String so das ich sie auch wieder zurück konvertieren kann?

Das hier geht leider nicht:


Encoding encoding = new ASCIIEncoding();
byte[] bytes = new byte[] { 138 };
string asString = encoding.GetString(bytes);
byte[] asBytes = encoding.GetBytes(asString);

asBytes = 63

28.05.2010 - 11:48 Uhr

Auch wenn der Thread alt ist. Hier die Lösung ohne sich um die letzten 3 Posts kümmern zu müssen.

Ein weiterer Fehler ist das Encoding und eine Verify methode hab ich auch noch drauf gelegt:


public string CreateSignature(string text, string privateKey)
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(privateKey);
            
            RSAPKCS1SignatureFormatter rsaFormatter = new RSAPKCS1SignatureFormatter(rsa);
            rsaFormatter.SetHashAlgorithm("SHA1");



            Encoding encoding = Encoding.GetEncoding(1252);
            SHA1Managed sha1 = new SHA1Managed();

            byte[] valueAsHash = sha1.ComputeHash(encoding.GetBytes(text));
            byte[] signedValue = rsaFormatter.CreateSignature(valueAsHash);

            return encoding.GetString(signedValue);
        }

        public bool ValidateSignature(string text, string sig, string publicKey)
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(publicKey);

            RSAPKCS1SignatureDeformatter rsaDeformatter = new RSAPKCS1SignatureDeformatter(rsa);
            rsaDeformatter.SetHashAlgorithm("SHA1");

            Encoding encoding = Encoding.GetEncoding(1252);
            SHA1Managed sha1 = new SHA1Managed();

            byte[] valueToHash = sha1.ComputeHash(encoding.GetBytes(text));
            byte[] signature = encoding.GetBytes(sig);

            return rsaDeformatter.VerifySignature(valueToHash, signature);
        }

27.05.2010 - 22:15 Uhr

Problem gelöst? Ich sitze gerade am selben Problem.

26.05.2010 - 10:38 Uhr

Im Wesentlichen muss der DI-Container ja nur Singletons unterstüzen und schon kann er beides. So hab ich es vor kurzem realisiert.


ICustomer = container.Create<ICustomer>();

Wenn etwas erstellt werden soll und Abhängigkeiten hat, dann werden die Abhängigkeiten über Properties vom vorher Konfigurierten DI-Container gesetzt? Oder holen sich die erzeugten Objekte (hier der ICustomer) dann einfach ihre Abhängigkeiten aus dem container?

Edit: Ich sehe grade das diese Frage auch in deinem anderen Post auftaucht und hier wohl keine größere Disskusion bedarf.

25.05.2010 - 15:13 Uhr

Das mit dem ower übergeben funktioniert auch nicht, grade getestet.

Show() statt ShowDialog wird wohl wirklich das Beste sein. Dann muss ich ds close nur über nen Event handlen. Naja nen kleiner umweg aber wohl der einzige Weg.

Lösung:


public void AskNext()
        {
            if (questions.Count <= 0 || asking) return;
            asking = true;
            Question question = questions.Dequeue();

            IAskQuestionDialog dialog = Dialog.GetDialog<IAskQuestionDialog>();
            dialog.Question = question;

            dialog.FormClosed += (s, e) =>
            {
                switch (dialog.DialogResult)
                {
                    case DialogResult.Abort: // Timeout
                        break;
                    case DialogResult.OK: // got Answer
                        if (dialog.Answer != null)
                        {
                            if (AnswerReady != null)
                            {
                                AnswerReady.Invoke(this, new AnswerPacketEventArgs(new AnswerPacket(dialog.Answer.Uid, dialog.Answer.Text)));
                            }
                        }
                        else
                        {
                            Logger.Log("dialog.Answer was null after DialogResult.OK", LogLevel.Error);
                        }
                        break;
                    default: // Closed by user
                        break;
                }

                asking = false;
                AskNext();
            };

            dialog.Show();
        }

Klappt super, und ist weniger aufwändig als ich dachte 😃

25.05.2010 - 14:58 Uhr

Die Hauptgui soll ja auch blockieren.
Es geht nur darum eine weitere Form zu haben die nicht blockiert.

Vielleicht geht das über das Handle an welches der Dialog gebunden ist? Dann muss ich mir das nur noch an der stelle holen an dem der Dialog gezeigt wird.

25.05.2010 - 14:47 Uhr

Das lässt sich sonst auch sehr gut über normale Sockets realisieren. Siehe TcpClient.
Ich hab das mit dem Remoting in 2 Richtungen auch schonmal aufgegeben und mich für Sockets entschieden.

25.05.2010 - 14:42 Uhr

Moin,
ich habe eine WinForms anwendung die eine zusätzliche Form (mit einem Button) zeigt.
Wenn jetzt ein Dialog auf geht (ShowDialog()) blockiert nicht nur die haupt gui sondern auch meine Button form. Dort soll man aber noch den Button drücken können.
Wie relaisiere ich das?

18.05.2010 - 12:14 Uhr

Rekursiv ohne die Indices zu tracken:


static void Find(string x, Array arr)
        {
            foreach (var v in arr)
            {
                if (v is Array)
                {
                    find(x, (Array)v);
                }
                else if ((string)v == x)
                {
                    Console.WriteLine("found");
                    break;
                }
            }
        }

Das Tracken könnte man auch noch einbauen, wenn man sich rekursionstiefe und anzahl der iterationen pro tiefe speichert.

Edit: Schneller wird mit ner angepassten Datenstruktur und optimierter Suche (Z.b. Binäre suche in einem Baum)

18.05.2010 - 11:49 Uhr

Man kann auch in einem laufenden Callback myTimer.Dispose() aufrufen. Ansonsten ist ein TimerCallback auch nur eine Methode die man über return verlässt.

Gefragt war nach dem beenden des Timers. In jedem all sollte das Problem nun wohl geklärt sein 😉

Gruß, Tarion

18.05.2010 - 11:20 Uhr

@herbivore
Ja das waren auch so meine Überlegungen.
Ich hab jetzt doch wieder nen IConsole interace in der Gui welches ein LineAdded event wirft. Damit kann man dann die rtb über appendText() erweitern. Auch das nach unten Scrollen lässt sich so leichter implementieren.

18.05.2010 - 11:17 Uhr
myTimer.Dispose();

Sollte es auch geben wenn ich mich nicht irre.

17.05.2010 - 22:12 Uhr

Hi,
ich hab ne RichTextBox (RTB) und will die als eine art Console in meiner Form verwenden. Nun hatte ich die Idee die Text property per DataBinding an ein Objekt zu binden.

Ich glaube das beste zum füllen einer RTB ist über AppendText() wie sieht es mit längeren Texten aus wenn man das ganze per DataBinding macht?

15.05.2010 - 11:26 Uhr

Sieht gut aus. Die Möglichkeit ein neues Spiel zu starten ohne alles neu eingeben zu müssen / das programm neu starten zu müssen wäre noch schön, aber war auch nicht explizit verlangt.

Schönes Spiel für zwischendurch 😉

Dann darfst du jetzt.

13.05.2010 - 15:47 Uhr

Ist jetzt nichts aufwändiges, aber ein nettes Spielzeug wenn es fertig ist:

Gebaut werden soll ein Russisch Roulette.
Es gibt einen Revolver mit 6 Schächten und einer Kugel.
Wer an der Reihe ist, muss entweder abdrücken oder die Trommel drehen und dann abdrücken.
Dann wird der Revolver weiter geben. Wer abdrückt und die Kugel erwischt, hat verloren.

Jetzt soll das Ganze für einen Spieler sein und der Gegenspieler ist Computergesteuert.
Ein zufälliger Spieler fängt an.

Besondere Anforderungen:

  • Der Computer soll Logisch handeln, also nicht rein zufällig drehen / Schießen. Beispiel: Nach 5 Schüssel wäre es unklug nicht zu drehen.

Optional, nicht erforderlich für die Lösung:

  • Man kann sich die Anzahl der Gegner selber aussuchen.
  • Falls es nicht zu lang wird, kann auch eine WinForms Anwendung geschrieben werden.

Viel Spaß, ich freu mich auf das Programm 😉

Edit:
Ja natürlich muss man immer auch schießen. 😛

11.05.2010 - 17:37 Uhr

Sodala, hab ne Lösung.

Edit 1:
Lösung geht für beliebig große Bäume.
Meine Tests bezogen sich zwar nur aus Ausbalancierte Bäume, aber das sollte dann auch für jeden Anderen funktionieren.

Edit 2:
Hier die Lösung.
Ist auch für die Extremen Bäume: nur links oder nur Rechts Knoten getestet.


private class Enumerator : IEnumerator<T>
        {
            private Tree<T> root;
            private Tree<T> current;

            private Tree<T> last;
            private Tree<T> totalLast;

            public Enumerator(Tree<T> root)
            {
                this.root = root;
                Reset();
            }

            #region private Functions

            /// <summary>
            /// Try to move the current to the right direction.
            /// </summary>
            /// <returns>True if moved</returns>
            private bool MoveOne()
            {
                // Noch nichts ausgegeben -> Nach links gehen
                if (last == null)
                {
                    if (current.Left != null)
                    {
                        current = current.Left;
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
                // Wir waren schon irgendwo -> Richtung bestimmen
                else
                {
                    // Hier waren wir grade -> nach rechts oder oben gehen
                    if (last == current)
                    {
                        // Nach rechts gehen wenn möglich
                        if (current.Right != null)
                        {
                            current = current.Right;
                            return true;
                        }
                        else // Sonst nach oben 
                        {
                            current = current.Parent;
                            return true;
                        }
                    }

                    // Wir kommen von rechts-unten (last is right of current) -> Weiter nach oben
                    if (IsRightOf(last, current))
                    {
                        Debug.Assert(current.Parent != null, "Error in the Tree");
                        current = current.Parent;
                        return true;
                    }

                    // Wir können nach Links und kommen von oben -> nach links gehen
                    if (current.Left != null && IsChildOf(current, last))
                    {
                        current = current.Left;
                        return true;
                    }

                    // Sonstige Fälle ohne Bewegung -> Ausgabe
                    // Z.b.
                    // Wir waren grade beim linken Kind. (last == current.Left)

                    return false;
                }
            }

            /// <summary>
            /// True if a is child of b
            /// </summary>
            /// <param name="a"></param>
            /// <param name="b"></param>
            /// <returns></returns>
            private bool IsChildOf(Tree<T> a, Tree<T> b)
            {
                // Suche von a nach oben bis b gefunde nwird
                Tree<T> finder = a;

                while (finder.Parent != null)
                {
                    finder = finder.Parent;
                    if (b == finder)
                    {
                        return true;
                    }
                }
                return false;
            }

            /// <summary>
            /// True if a is right of b
            /// </summary>
            /// <returns></returns>
            private bool IsRightOf(Tree<T> a, Tree<T> b)
            {
                Tree<T> finder = b;

                while (finder.Right != null)
                {
                    finder = finder.Right;
                    if (a == finder)
                    {
                        return true;
                    }
                }
                return false;
            }

            #endregion


            #region IEnumerator<T> & IEnumerator Members

            public T Current
            {
                get { return current.Value; }
            }

            object System.Collections.IEnumerator.Current
            {
                get { return this.Current; }
            }

            public bool MoveNext()
            {
                if (last == totalLast) return false;

                while (MoveOne()) ;

                last = current;
                return true;
            }

            public void Reset()
            {
                current = root;
                last = null;
                SetTotalLast();
            }

            private void SetTotalLast()
            {
                totalLast = root;
                while (totalLast.Right != null)
                {
                    totalLast = totalLast.Right;
                }
            }

            #endregion

            #region IDisposable Members

            public void Dispose()
            {
            }

            #endregion
        }
    

10.05.2010 - 22:52 Uhr

Siehe: 1.1.1

Grade zu diesem Problem gibt es im Internet mehr als Genug Beispiele.

Der Ansatz mit den UserControls ist der richtige Weg.

Setze dir ein Panel auf die Form
Auf dem Button event kannst du dann folgendes tun:


panel1.Controls.Clear();
panel1.Controls.Add(new MyUserControl);

MyUserControl kannst du dir in VS als UserControl erstelen und mit dem Designer wie eine Form editieren.

Edit:
windowsformfrage scheint sich wohl mit seinem 1. Post auf WinForms zu beziehen 😉 Dafür gibt es aber auch ein eigenes Unterforum.

10.05.2010 - 21:32 Uhr

Klingt wirklich sehr nach Splines. Da gibt es Methoden für wann und wie man die in welchem Fall lösen kann.
Die genaue Theorie hab ich nicht im Kopf da muss ich wohl passen. Am besten du suchst dir mal achliteratur zum Thema Spline Interpolation.

10.05.2010 - 21:20 Uhr

Bewegliche Daten in statischen Variablen zu halten ist genauso schlimm wie Goto.
Du solltest Dir evtl mal wirklich etwas zu Architektur oder OOP durchsehen.

Ich weiß das man das nicht in einer statischen Klasse realisiert und stimme euch da zu.
Jedoch geht es in meinem Beispiel nicht um das Model, sondern um das DataBinding. In diesem Fall habe ich den schnellsten Weg genommen um von 2 GUI's auf 1 Dataset zu zugreifen. Das ist über eine Statische Property sehr anschaulich.
In dem Beispiel geht es nicht um die spätere Erweiterbarkeit dieses Beispiels, sondern alleine darum zu zeigen, dass die Synchronisation eines DataSets wenn 2 Forms darauf per DataBinding zugreifen durchaus funktioniert.
Anders soll dieses Beispiel auch nicht aufgefasst werden. Es ist **keine **Ausgangsbasis für größere Projekte.

Und nebenbei war es für mich ein großer Lernerfolg 😉

10.05.2010 - 20:33 Uhr

Das mit dem Leseproblem stimmt allerdings. Ich finde die Implementierung unabhängig von der Richtigkeit bezüglich der Aufgabenstellung dennoch sehr elegant, da sie fast ganz ohne Zusatzspeicher auskommt.

Dann stellt sich mir aber wieder die Frage ob es lösbar ist ohne sich für jeden Knoten eine Information zu speichern. (z.B. ob der Knoten schon besucht wurde)
Es ist ja gefordert keine Enumaration zu benutzten schließt das dann auch arrays aus?

10.05.2010 - 20:24 Uhr

Ich habe auch meistens einen MainController ähnlich zu deinem.
Jedoch würde ich im Konstrukror nur die Initialisierung machen und dann in einer blockierenden funktion Run() vom MainController Application.Run(_mainForm) aurufen.

In der Program.cs kannst du dir das Application.Run() dann auch sparen.

Und ist das mit dem Application.Exit() im Event ist nicht nötig lass doch den Controller direkt Application.Exit() aufrufen. Oder eben noch einfacher durch Schließen der Form das ende der Run() Funktion erreichen. Dann ist auch ende.

Ich habe bei dem Ansatz aber nie mehr als einen Controller gebraucht.
Ich kann au jeden Fall sagen das aus deinem Ansatz ganz anständige Programme wachsen können (Aus eigener Erfahrung 😃 )

Edit:
Es lohnt sich mehr teile / Schnittstellen des Models an die GUI zu geben und mit Databinding zu arbeiten, als 101 Events für x Datenänderungen im Controller zu bearbeiten.

10.05.2010 - 17:05 Uhr

Ich muss zugeben, ich hab mir den Algorithmus nicht selbst ausgedacht. Er ist bekannt als Morris Traversal.
Die Implementierung stammt jedoch komplett von mir.


private class Enumerator : IEnumerator<T>
        {
            private Tree<T> root;
            private Tree<T> current;
            private bool running;

            public Enumerator(Tree<T> root)
            {
                this.root = root;
                Reset();
            }

            #region IEnumerator<T> Members

            public T Current
            {
                get { return current.Value; }
            }

            #endregion

            #region IEnumerator Members

            object System.Collections.IEnumerator.Current
            {
                get { return this.Current; }
            }

            /// <summary>
            /// Morris Traversal
            /// </summary>
            /// <returns></returns>
            public bool MoveNext()
            {
                // skip this the first time
                if (running)
                {
                    current = current.Right;
                }
                else running = true;

                while (true)
                {
                    // if current is null, we are done.
                    if (current == null)
                        return false;

                    if (current.Left == null)
                    {
                        // Print Current if left is empty
                        return true;
                    }
                    else
                    {
                        // Find the inorder predecessor of current
                        Tree<T> pre;
                        pre = current.Left;
                        while (pre.Right != null && pre.Right != current)
                            pre = pre.Right;

                        // Make current as right child of its inorder predecessor
                        if (pre.Right == null)
                        {
                            pre.Right = current;
                            current = current.Left;
                        }
                        else
                        {
                            // Revert the changes to restore the original tree: fix the right child of predecssor
                            pre.Right = null;
                            
                            // Print Current
                            return true;
                        }
                    }
                }
            }

            public void Reset()
            {
                current = root;
                running = false;
            }

            #endregion

            #region IDisposable Members

            public void Dispose()
            {
            }

            #endregion
        }

09.05.2010 - 16:32 Uhr

Nein, ich bilde auch Klassen ab. Diese Klassen haben als Values aber nicht nur Int / String etc. sondern auch DiceValues. Wie "1d6+5".

09.05.2010 - 16:29 Uhr

Seid doch mal etwas kreativ 😃

Wenn es nur eine ist die in der Konsole angezeigt wird aber aus Primzahlen berechnet ist.
Oder eine kleine Gui die von Google ein zufälliges zum Muttertag passendes Bild anzeigt.

Ich will nicht zu viele Ideen nehmen.. 😉

09.05.2010 - 15:14 Uhr

Weil heute Muttertag ist, wollte ich mal die Aufgabe in den Raum schmeißen ein kleines Programm für alle Mütter dieser Welt zu schreiben. Es sollte im Rahmen des Programmierspiels sein, also in einen Post passen.

Über das Schönste Programm / die Schönste Idee rund um das Thema Muttertag kann dann morgen abgestimmt werden.

Liebe Grüße, auch an alle Mütter,
Tarion

09.05.2010 - 15:08 Uhr

Ich speichere doch auch integer in meinen Objekten und zeige die an. Wenn ich den int ändere wird er eben ersetzt, genauso wie ier bei meinem Struct. Es ist nunmal ein wertetyp und kein Refferenztyp, dann sollte das doch auch genauso gehen.
Aus meinem Code wird auch deutlich das ich ein neues Struct erstelle und damit nicht wie mit einem Objekt umgehe, sondern eben wie mit einem Wert.

09.05.2010 - 15:05 Uhr

Die Frage geht sehr in Richtung 1.1.1

08.05.2010 - 14:20 Uhr

Im Datagridview:


private void weaponsDataGridView_CellParsing(object sender, DataGridViewCellParsingEventArgs e)
        {

                if (e.DesiredType == typeof(DiceValue))
                {
                    e.Value = new DiceValue((String)e.Value);
                    e.ParsingApplied = true;
                }
            
        }
08.05.2010 - 14:10 Uhr

Ich habe einen DataGridView in dem ich per DataBinding auch ein eigenes Struct anzeige.
Die Anzeige funktioniert gut. Es wird vom Struct ja nur .ToString() aufgerufen. Jetzt will ich aber einen gegeben String den man im DataGridView eingibt zurück zu meinem Struct convertieren. Wo implementiere ich das?

Bisher hat mein Struct nur einen Constuctor der einen String nimmt.

07.05.2010 - 14:10 Uhr

no, da muss doch jemand System.Windows.Forms.Cursor.Hide() aufgerufen haben?

Jap sagte ich ja bereits.

07.05.2010 - 14:02 Uhr

Erledigt. Manchmal liegen Fehler auch mal anderswo als erwartzet 😉 Es wurde tatsächlich Cursor.Hide() aufgerufen und vergessen wieder rückgängig zu machen.

07.05.2010 - 13:25 Uhr

Ich habe das Problem, dass auf meinen Forms der Mauszeiger nicht sichtbar ist.

Ich glaube das es keine Probleme mehr mit den Threads gibt. Kein InvokeRequired ist true und alles scheint aus dem reichtigen Thread zu kommen.

Das Programm ist per Netzwerk mit einem Server verbunden. Nach dem Verbinden geht alles. Wenn ich nun einen Disconnect habe und er sich neu verbindet tritt das Problem auf.
Ich kann hier nicht alle Zusammenhänge auflisten, aber ich suche nach einem Ansatz das besser zu debuggen.

Die Maus kann auf den Forms benutzt werden, sie ist nur eben unsichtbar.

04.05.2010 - 18:36 Uhr

Ein großer Vorteil ist noch das sowas geht:


void MyFunc() {
int myLocalInt = 5;
Load += (s, e) => { _rect = new DrawingObject(myLocalInt); };
}

04.05.2010 - 17:28 Uhr

s.BeginnReceive();

Startet einen Asynchronen Receive. Sprich: Dein Code läuft weiter aber irgendwo wartet ein Thread darauf das Daten ankommen.

Du übergibst dort ein Delegate der aufgerufen wird wenn tatsächlich Daten ankommen. Du wartest also Passiv ohne das die CPU Last hoch geht.
Das ist wie ein Event. (Observer pattern)
Bekommst du deine Daten musst du selbst verständlich wissen, was du erwartest und es ist meistens notwendig die Länge der Daten der nächsten Nachricht voraus zu senden.

Wenn man nur strings verschiebt kann man auch auf 0-Bytes warten, dann braucht man keine Länge vorweg und bei festen Strukturen reicht vll eine ID womit dann die Länge der Struktur bekannt ist.

04.05.2010 - 17:15 Uhr

Ich kann dir da leider auch keine Detaillösung geben, aber es klingt auch irgendwie nach linearem Ausgleichsproblem.
Hast du die Funktionen f nach deiner RWA? (Das geht in nen Bereich von dem ich nicht so viel Ahnung habe)

03.05.2010 - 23:10 Uhr

Ne eigene Sprache für Bilderkennung wäre sicherlich interessant. Die kann ja nach C# oder c kompiliert werden und vorhandene Bibliotheken für die eigentlichen Routinen nutzen. Aber in sich eben darauf optimiert sein möglichst einfach das gewünschte aus einem Bild zu filtern.

03.05.2010 - 23:01 Uhr

Ich muss da nochmal mit eigenen Worten drüber gehen 😉

Du hast n Stützstellen P_i mit i in [0..n]
Die Stützstellen haben die 0. Ableitung gegeben (Oder eine beliebige andere?)
Zwischen 2 Stützstellen ist eine Funktion definiert. Z.b. ein Polynom 3. Grades?

Das nennt man dann Splines. Im Falle von Polynomen 3. Grades sind es Kubische Splines. (Ich hoffe ich vertue mich grad nicht mit der "3." Ableitung)

Du musst dafür ein Lineares Gleichungssystem lösen, das wird wohl über-bestimmt sein wie du selbst sagst, d.h. es gibt werte die du dir "aussuchen" darfst. Da muss nichts optimiert werden, da darfst du dann frei wählen 😃

03.05.2010 - 22:39 Uhr

Dann sollte das Interface in einer Library liegen die von deiner Control Library auch verlinkt wird, oder direkt mit in der Control Library. Ansonsten wirst du das Interface nicht implementieren können.

Beispiele für so spezielle Vorhaben wirst du nur schwer finden. Du kannst nur viel ausprobieren und auf konkretere Probleme stoßen, die sich dann auch wieder leichter fragen / lösen lassen.

Mich würde interessieren wie dein IObservalbe interface aussieht. Vom Framework gibt es INotifyPropertyChanged.

03.05.2010 - 21:31 Uhr

Wieso nicht? Oder habe ich die Frage falsch verstanden?

http://msdn.microsoft.com/en-us/library/dxkwh6zw.aspx

Begins to asynchronously receive data from a connected Socket.

Und gegen CPU Last beim Threading ist Thread.Sleep(50)

03.05.2010 - 19:29 Uhr

Asynchron:


s.BeginReceive(...);

Sonst in die while(true) ein Thread.Sleep(50) zum CPU sparen.

03.05.2010 - 19:08 Uhr
  1. Wird der Thread automatisch beendet wenn die timeConsuming() Methode
    beendet wurde oder muss ich da selber eingreifen?

Jap. Wird beendet.

  1. Was kann ich tun um in der Form1 auf die Beendigung des Threads zu reagieren?
    Genügt es nach der timeConsuming() ein Event zu werfen?

Du kannst das Event werfen und in der Form1 fangen. Dann musst du allerdings in den Thread der Form1 wechseln:


void Event_FromThread(object sender, EventArgs e) {
if (this.InvokeRequired) {
// Invoke ein MethodInvoker der ein dynamisch generiertes Delegate erhällt welche diese Funktion (dann im GUI Thread) aufruft.
this.Invoke(new MethodInvoker(delegate() { Event_FormThread(sender, e); }));
return;
}
// Code der ausgeführt wird
}

Code ist frei getippt und kann eventuell Fehler enthalten.

03.05.2010 - 09:50 Uhr

Hab dir mal ne PM zukommen lassen. Vielleicht hast du ja Interesse.

03.05.2010 - 09:31 Uhr

So abwegig finde ich das feature jetzt auch nicht. Würd es aber eher zu "nice to have" stellen.

02.05.2010 - 20:13 Uhr

Es wird aus gleichem Grund gelehrt, wesshalb ein E-Techniker auch wissen muss wie Strom generiert wird, obwohl er es nicht selber implementieren muss. Man muss eben die Grund lagen von dem kennen was man benutzen will. Nur weil jeder Student Compilerbau hört, wird nicht von jedem erwartet einen Compiler zu schrieben, jedoch sehr wohl zu verstehen was hinter der Programmierung passiert.
Zwischencodes, Ablauf von Compiliervorgängen, etc..

Wir haben als Uniprojekt mal ein kleines Programm geschrieben, welches eine eigene Scriptsprache parsen musste und entsprechend Befehle ausgeführt hat. Das war auch schon eine art kleiner Compiler und an dieser stelle auch notwendig selbst zu schreiben.

Eine neue Sprache erfinden halte ich auch für unsinn. Und wenn sollte man sich ein Anwendungsfall raussuchen der sinnvoll ist. Siehe: DSL (das von oben)

Gruß, Tarion (Mit kaputter F Taste an seinem Laptop)

01.05.2010 - 16:43 Uhr

registriere den EventHandler nicht nur für das Panel, sondern auch für alle Kind-Elemente.

Geht recht simpel:


void RegisterRecursive(Control control) {
	// Hier den Eventhandler für contol.WhatEver registieren.
	foreach(Control c in control.Controls) {
		RegisterRecursive(c);
	}
}

01.05.2010 - 16:39 Uhr

Hab mich endlich mal mit Datenbanken und DataBindings beschäftigt und einige Erfolge gehabt, hier mein Resultat.

Die Lösung für eine Anwendung hab ich. Eigentlich wie man es erwartet.

Das Problem mit 2 Anwendungen auf einer Datenbank wird hier nicht gelöst.

Kleine Erklärung:
DataManager ist als Statische Klasse realisiert und stellt alle Nötigen Datenklassen bereit, sowie eine Update Funktion.

Das DataSet, sowie der DataTableAdapter sind mit dem Designer erstellt und beinhalten den Code für die Datenbankverbindung, CRUD Befehle, AutoInc für die ID und die Schemainformation der DB.
Eventuell noch etwas von dem ich grade nichts weiß 😉

Die Forms beinhalten nur eine DataSource welche an die DataTable vom DataManager gebunden werden. Ändert sich etwas an der DataTable wird alles in der Anwendung aktualisiert.

Ich hoffe das hilft dem einen oder anderem. Der Code kann frei verwendet werden, wenn er woanders veröffentlicht wird, bitte ich auf mich / diesen Post zu referenzieren.

Gruß, Tarion

01.05.2010 - 14:56 Uhr

In diesem Fall gibt es verschiedene Ansätze.
Wenn ein Programm auf die Tabelle zugreift, wird diese Gepserrt. Es gibt verschiedene Sperren. Exclusive: Niemand kann lesen / schrieben oder shared: andere Verbindungen haben nur Lesezugriff. Die Sperren sollte die Datenbank können. Dabei muss man sich allerdings auch einige Gedanken über mögliche Deadlocks machen.

Wenn beide Programm auf die DB zugreifen können und Schreibzugriff haben, sollte vor dem Schreiben überprüft werden ob sich die DB geändert hat. Eventuell ein Tiemstamp in der DB speichern (TableXLastCahnged), oder wirklich nochmal alle geänderten Daten abfragen und die Konsistenz prüfen.
Den Timestamp aber natürlich niemals mit lokaler Zeit eines Rechners vergleichen 😉

Alle 10 Sekunden updaten reicht nicht wenn 5 Sek zwischen Änderung von Programm A und Änderung von Programm B liegen. In diesem Fall überschreibt Programm B die Änderung von Programm A ohne Notiz davon zu nehmen.

Das Ursprüngliche Problem, also 2 Forms eines Programms synchronisieren, lässt sich natürlich auch Programm intern lösen. Aber da hab ich leider auch noch zu Wenig Erfahrung mit DataBindings.