Hi, danke für deine Antwort. Also du meinst, ich soll einfach den gesammten Fehler bzw. die gesammte Log-File in XML serialisieren und dann das XML als string in die Datenbank eintragen? Muss ich mal ausprobieren, danke dir

Hallo zusammen,
ich bin gerade dabei, eine Logging-Library zu programmieren, mit der es auch möglich sein soll, Fehler über das Aufrufen eines PHP-Skripts in eine Datenbank einzutragen. Dabei sollen die wichtigsten Eigenschaften des aufgetretenen Fehlers in eine Log-File eingetragen werden und danach die Logfile in die Datenbank gespeichert werden. Jeder Entry in der Log-File ist als Objekt einfach nur eine Klasse mit einer Liste von Properties. Jetzt zu meinem Problem:
In die Datenbank kann ich später nur bestimmte Datentypen eintragen. Daher habe ich mir gedacht, dass ich die Klasse Property einfach generisch mache und bspw. nur die Datentypen Int, Double und String erlaube (nur als Beispiel). Leider bekomme ich dann diese Meldung:> Fehlermeldung:

'double' ist keine gültige Einschränkung. Ein Typ, der als Einschränkung verwendet wird, muss eine Schnittstelle, eine nicht versiegelte Klasse oder ein Typparameter sein.

Liegt also daran, dass Double als sealed deklariert ist. Hat jemand eine Idee, wie ich mein Vorhaben trotzdem umsetzen könnte?
mfg
Reign

Habe das gerade ausprobiert, es funktioniert tatsächlich, danke dafür 😉

@Chillic:
Wenn dem Anwender aber angezeigt wird "Das Programm funktioniert nicht mehr..." hilft ihm das glaube ich auch nicht viel weiter. Ich möchte in meinem Dialog dem Anwender auch nicht den exakten Fehler anzeigen, sondern nur eine ungefähre Umschreibung. Alle wichtigen Daten werden dann in die Datenbank eingetragen, sodass der Fehler schnellst möglich behoben werden kann.
Die Ursprungsfehlermeldung, die nicht behandelt wurde mir allen Daten habe ich ja noch im EventArgs gespeichert.

lg

Ich möchte eigentlich nur die Exceptions mit einem eigenen Dialog anzeigen lassen, die eben nicht behandelt wurden und das Programm dann natürlich beenden. (Da ich mir wie schon gesagt nicht sicher sein kann, ob das Programm danach noch in einem gültigen Zustand ist).
Ziel ist es, dem Anwender in diesem eigenen Dialog die Möglichkeit zu geben, den Fehler in eine Datenbank eintragen zu lassen.
Das heißt ich kann aber einfach in dem UnhandledExceptionEvent einen modalen Dialog anzeigen und das Programm dann beenden? Wird die Standardmeldung dann nicht trotzdem angezeigt? Naja, muss ich gleich mal testen, danke euch
lg

Hallo zusammen,
ich schreibe gerade eine Libary zum Loggen von Exceptions. Folgendes Problem ergibt sich dabei allerdings: Ich wollte dazu das Event AppDomain.CurrentDomain.UnhandledException abonnieren um die Exceptions zu loggen. Hier möchte ich nun aber nicht die standardmäßige Windows-Fehlermeldung bei nicht behandelten Exceptions anzeigen lassen, sondern möchte meinen eigenen Dialog anzeigen lassen, in dem der Anwender nur das nötigste erfährt. (Anwender können mit den angezeigten Informationen sowieso selten etwas anfangen). Leider kann ich in diesem Event aber das Event nicht mehr als handled makieren, das heißt in jedem Fall kommt die standard Fehlermeldung. Hat jemand eine Idee wie ich das umgehen könnte?
lg
Reignbeaux

RIP XNA
Ich weiß, dass man deshalb nicht automatisch XNA nicht mehr verwenden kann, allerdings möchte ich auch auf etwas setzen, was Zukunft hat. Ich werde mir nun aber erstmal SlimDX anschauen.
Danke euch
lg

Hallo zusammen,
ich wollte mal allgemein fragen, was ihr für simple 2D spiele in C# empfehlen könnt. XNA wird ja nicht mehr weiter entwickelt, weshalb ich darauf erstmal nicht setzen möchte. Windows Forms ist ja nun auch in die Jahre gekommen, also wäre z.B. WPF eine Variante, vor allem weil ich mich damit in letzter Zeit bereits im UI-Bereich beschäftigt habe. Allerdings ist die Frage: Reicht WPF für kleine 2D games aus? Gibt es Alternativen? Wie sieht es mit OpenGL aus? DirectX? Kann jemand noch andere Varianten empfehlen? Und zum Schluss würde mich noch rein aus Interesse interessieren, was zZ. für 3d Sachen zu bevorzugen ist?
lg

Danke, siehe mein edit oben.

Hallo zusammen,
ich beschäftige mich zur Zeit mit WPF und habe eine Frage zu den Bindungsmöglichkeiten. Gibt es bei den folgenden 3 Zuweisungen einer Ressource an ein Element Unterschiede, die man beachten sollte?
Oder sind es einfach nur andere, verkürzte Schreibweisen?

    <Window.Resources>
        <SolidColorBrush x:Key="Color_Red" Color="Red"></SolidColorBrush>
    </Window.Resources>

        <Label Name="lbl1">
            <Label.Background>
                <Binding Source="{StaticResource Color_Red}"></Binding>
            </Label.Background>
        </Label>

        <Label Name="lbl2" Background="{Binding Source={StaticResource Color_Red}}"></Label>

        <Label Name="lbl3" Background="{StaticResource Color_Red}"></Label>

Würde mich über eine Antwort freuen
lg

edit: Mir ist noch etwas aufgefallen: Wieso aktualisieren sich alle 3 Labels trotzdem, wenn ich Mode=OneWay bei allen 3 Bindungen angebe und ich den Background eines Labels ändere? Eigentlich sollte dann doch die Quelle, also die Ressource, nicht geändert werde, wenn sich der Background des Labels ändert, oder?

Peinlich.
Zwei mal das gleiche Stopwatchobjekt verwendet ><
Simpler kann es ja eigentlich nicht sein 😄
Aber dass der Unterschied so krass ist, hätte ich nicht gedacht.
Danke euch
lg
Reignbeaux

Hallo zusammen,
ich beschäftige mich in letzter Zeit mit rekursiven Programmalgorythmen, da ich diese Programmierart sehr interessant finde. Jetzt habe ich mir ein kleines Programm zum Sotieren von Zahlenwerten geschrieben.
Ein Mal eine Methode mit dem einfachen Bubblesort und eine Methode mit Mergesort, die die Liste zerlegt und dann wieder ineinander zusammenführt.
Das ganze funktioniert nach einigen Anlaufschwierigkeiten jetzt wunderbar, doch eines macht mich stutzig: Wenn ich die Zeit mit Stopwatch messe, ist Bubblesort immer ~10-100 Millisekunden schneller. (das ist eigentlich bei allen Größen von Arrays der Fall. Ich habe es schon mit 10-20000 Einträge großen Arrays probiert) Woran kann das liegen? Hier meine 2 Varianten:

        
        public static void Bubblesort<T>(ref T[] values) where T : IComparable
        {
            bool sortiert = false;
            int switchs = 0;
            while (sortiert == false)
            {
                switchs = 0;
                for (int i = 0; i < values.Length; i++)
                {
                    if (i < values.Length - 1)
                    {
                        if (values[i].CompareTo(values[i + 1]) > 0)
                        {
                            switchs++;
                            T a = values[i];
                            T b = values[i + 1];
                            values[i] = b;
                            values[i + 1] = a;
                        }
                    }
                }
                if (switchs == 0)
                    sortiert = true;
                else
                    sortiert = false;
            }
        }

        public static int[] Mergesort(int[] zahlen)
        {
            if (zahlen.Length > 1)
            {
                int[] teil1 = new int[0];
                int[] teil2 = new int[0];
                Teilen(zahlen, ref teil1, ref teil2);
                return Merge(Mergesort(teil1), Mergesort(teil2));
            }
            else
            {
                return new int[1] { zahlen[0] };
            }
        }

        public static void Teilen(int[] zahlen, ref int[] zahlen1, ref int[] zahlen2)
        {
            int Mitte = Convert.ToInt32(zahlen.Length / 2);
            zahlen1 = new int[Mitte];
            zahlen2 = new int[zahlen.Length - Mitte];

            for (int i = 0; i < zahlen1.Length; i++)
            {
                zahlen1[i] = zahlen[i];
            }

            for (int i = Mitte; i < zahlen.Length; i++)
            {
                zahlen2[i - Mitte] = zahlen[i];
            }
        }

        public static int[] Merge(int[] zahlen1, int[] zahlen2)
        {
            int[] Menge = new int[zahlen1.Length + zahlen2.Length];
            int index1 = 0;
            int index2 = 0;
            int indexgesamt = 0;
            while (index1 < zahlen1.Length && index2 < zahlen2.Length)
            {
                if (zahlen1[index1] < zahlen2[index2])
                {
                    Menge[indexgesamt] = zahlen1[index1];
                    index1++;
                }
                else
                {
                    Menge[indexgesamt] = zahlen2[index2];
                    index2++;
                }
                indexgesamt++;
            }

            while (index1 < zahlen1.Length)
            {
                Menge[indexgesamt] = zahlen1[index1];
                index1++;
                indexgesamt++;
            }

            while (index2 < zahlen2.Length)
            {
                Menge[indexgesamt] = zahlen2[index2];
                index2++;
                indexgesamt++;
            }

            return Menge;
        }

PS: Die Mergesort-Variante ist noch nicht generisch, sie kann nur mit Int arbeiten, da es so beim Erstellen der Methoden übersichtlicher war und ich am Ende keine Lust mehr hatte das ganze zu ändern 😄 (faul wie wir Menschen sind...)
Würde mich freuen wenn mir jemand helfen könnte und mir zeigt, ob und wo ich etwas unperformant gemacht habe.
lg Reignbeaux

Hallo,
ich befasse mich in letzter Zeit mit C# und da kommt mir oft, auch wenn ich eigene Programme schreibe, um etwas, was ich neu erlernt habe, zu testen, folgende Frage auf:
Es gibt ja die Möglichkeit, eigene, benutzerdefinierte Exceptions zu erstellen, in dem man seine Klasse einfach von Exception beerbt. Doch wann sollte man das verwenden? Ein kleines Beispiel:
Einem integer Feld in einer speziellen Klasse wird über den set-Zweig einer Eigenschaftsmethode ein Wert zugewiesen der negativ ist, es sollen aber nur positive Werte erlaubt sein. Wie würdet ihr das machen? Eine normale Exception werfen mit dem Text "Keine negativen Werte erlaubt", oder eine eigene Exception erstellen "InvalidAssignment"? Wo liegen die Vorteile?
Und eine weiter Sache, die mich im Bezug auf Exceptions auch interessiert:
Ich lese mit einem StreamReader eine Datei aus:
Sollte man dabei nur auf eine Standard "Exception" prüfen, oder alle Exceptions die dabei auftreten können einzeln behandeln? Und wenn alle einzeln behandeln die Antwort wäre, wo kann ich denn überhaupt alle Ausnahmen, die in einer Klasse das Frameworks auftreten können, nachschlagen?
Ich denke mal, dass es hierbei auch auf die Vorlieben des Programmierers ankommt, allerdings möchte ich mir keinen schlechten Stil angewöhnen 😉
(und Exceptions in Programmen sind nunmal sehr ärgerlich, sodass man versuchen sollte diese bestmöglichst und richtig zu behandeln)
lg
Reignbeaux