Ich hab immer noch eine alte Logitech Wireless Maus mit Kugel, Rad und 3 Tasten. Optische Mäuse mag ich nicht weil sie
* auf bunten Mauspads völlig unbrauchbar sind (zumindest die, die ich gesehen hab)
* auf einfarbigen Oberflächen gelegentlich den Mauszeiger quer über den Bildschirm katapultieren
* nachts immer leuchten
Nur das Logitech-Mausrad ist nicht so toll. Dreht manchmal nicht oben auf der "Kante" sondern im "Loch", manchmal auch gleich um 2 Schritte. Und der Klickweg der Radtaste ist so lang. Aber kabellos sollte meine Maus schon bleiben, Kabel stören bei Mäusen. Bei Tastaturen ist es egal, die bewegt man ja nicht so oft.

Hm, das Design gefällt mir. Aber so geht das in C# leider nicht. Vielleicht ein Denkanstoß: Wenn du die eigentliche Aktivität in einen anderen Thread verlegst (z.B. mit einem BackgroundWorker), kannst du dir vielleicht einen Wrapper schreiben, der den Worker startet (und dafür einen Delegate bekommt) und nach dem Start auch gleich mit einem weiteren Thread darauf aufpasst, um den Worker-Thread ggf. nach einer gewissen Zeit zu stoppen, wenn er noch läuft. Das Stoppen ist so ne Sache, das ist halt ne ziemlich "harte" Aktion. Wenn ich das richtig in Erinnerung habe, dann gelten die entsprechenden Methoden wie Thread.Suspend() in .NET 2.0 als veraltet. Aber möglich sollte es schon irgendwie sein, auch sich da ein nettes Interface für zu basteln.

Die MouseFilter-Komponente stellt Funktionen bereit, mit denen sich die Funktionsweise der Maus in Anwendungen beeinflussen lässt. Derzeit sind das folgende Funktionen:

Ausblenden des Mauszeigers nach Inaktivität

In Vollbild-Anwendungen kann es sinnvoll sein, den Mauszeiger bei Nichtbenutzung auszublenden. Dafür werden alle Windows-Nachrichten an die laufende Anwendung überwacht und der Mauszeiger nach einer Weile, in der die Maus nicht bewegt wurde, ausgeblendet. Wird die Maus bewegt, wird der Zeiger sofort wieder angezeigt, bis zur nächsten Inaktivität. Diese Funktion wird mit der Eigenschaft AutoHideCursor aktiviert. Außerdem werden die Ereignisse MouseHidden und MouseShown bereitgestellt, die über das Ausblenden bzw. Anzeigen des Mauszeigers benachrichtigen.

Weiterleiten der Mausrad-Eingaben an das Steuerelement unter dem Mauszeiger

Normalerweise werden Mausrad-Eingaben immer an das Steuerelement gesendet, das den Tastatur-Eingabefokus besitzt. Da das Rad aber an der Maus befestigt ist und nicht an der Tastatur, sollte es sich mehr nach der Position des Mauszeigers richten als nach dem Tastaturfokus. Aufgrund der Art und Weise wie Windows die entsprechenden Nachrichten versendet kann man allerdings nicht in inaktiven Fenstern scrollen, auch wenn der Cursor darüber steht. Diese Funktion wird mit der Eigenschaft DispatchMouseWheel aktiviert.

Allgemein genügt es, eine Instanz der MouseFilter-Komponente zu einem Fenster der Anwendung hinzuzufügen, um die Funktionen zu verwenden.

.NET Kompatibilität: 2.0

Download

Da diese Komponente eine Reihe von Hilfsklassen verwendet, die ich in meinen eigenen Anwendungen üblicherweise verwende, biete ich nur eine einfache Beispielanwendung zum Download an, die den gesamten benötigten Quelltext dieser Komponente enthält und gleichzeitig die Verwendung demonstriert. Die Dateien dieser Komponente befinden sich im Unclassified-Unterverzeichnis.

Homepage mit Download und ggf. neueren Versionen

Anlage zu diesem Beitrag: Quelltext der Beispielanwendung (Visual Studio 2005 C# Projekt, 18 kB, 15. September 2007)

Lizenz, Nutzungsbedingungen

Dieses Programm ist unter den Bedingungen der GNU General Public License (GPL), Version 2 oder neuer veröffentlicht.

Ich schätze mal, das alles ab 10 MB nicht mehr auf dem Handy installiert wird. 😉

Oh, stimmt. Der Thread ist schon wieder zu lang/alt. 😉

Ach ja, früher gab es Error-Codes. Das war eine Zahl, die hat der Entwickler dann in sein Error-Lookup-Programm eingetippt und dafür eine Fehlermeldung in seiner eigenen Systemsprache erhalten. (Das Programm hab ich mir letztens mal wieder aus der VC6-CD rausgezogen, kann man auch in .NET-Zeiten noch brauchen.)

Määh, noch eine Lizenzbestätigung. Was steht denn da drin, ich hab keine 2 Stunden Zeit, mir das alles durchzulesen. Hab leider nur nen gewöhnlichen Passport-Account, der reicht für Connect leider nicht ganz.

Hm, ja, denk schon. Ich will nur noch ne hübsche Komponente draus machen, dann landet das Teil in meinem Web-Labor. (Bei Bedarf auch als Kopie hier.)

Update: Link zur Komponentensammlung

Da diese Dropdown-Listen ein eigenes Fenster verwenden, das sich mit den üblichen Methoden zum Auflisten von Fenstern als solches finden lässt, habe ich jetzt auch einen Weg gefunden, die Präsenz und die Koordinaten dieses DropDown-Fensters zu ermitteln. Der Rest sollte einfach werden...

Wie gesagt, ich merke mir in einer eigenen Variable, ob die Event-Handler jetzt gerade ihre Arbeit tun sollen oder nicht.

Hier ein Ausschnitt der Form-Klasse mit allen relevanten Details:

partial class Form1 : Form
{
    bool updatingCombobox = false;   // Zustandsvariable

    private void InitialiseCombobox()
    {
        updatingCombobox = true;   // Ab hier nicht auf SelectionChanged-Ereignisse reagieren
        combobox1.SelectedIndex = 2;
        updatingCombobox = false;   // Ab hier wieder normal reagieren
    }

    // Event-Handler für die Combobox:
    private void combobox1_SelectionChanged(object sender, EventArgs e)
    {
        if (updatingCombobox) return;   // Nichts anfassen!

        MessageBox.Show("Auswahl wurde verändert");
    }
}

Dabei nutze ich die Tatsache aus, dass (in den meisten Fällen) die entsprechenden Ereignisse der Controls synchron ausgelöst werden, also zeitlich gesehen innerhalb der Änderung der Eigenschaft. Bevor ich diese Eigenschaft durch meinen Code ändere, sperre ich die Event-Handler und nachher geb ich sie wieder frei. Dadurch kommen mir meine eigenen Event-Handler nicht in die Quere. So einfach ist das.

Ich hab keine Ahnung, ob es dafür ein besseres Design Pattern gibt, so erscheint es mir eben intuitiv.

Ist ein Pascal-Integer denn auch 32 Bit lang? Waren Integers früher nicht mal nur 16 Bit? Zumindest in einer früheren VB-Version war das so und ich war dann mittelprächtig überrascht, warum ein Integer plötzlich so große Werte annehmen konnte, als die das geändert hatten. 😉

Falls du Einfluss auf den hast, der das Log erstellt, kannst du ja mal schauen, ob der seine CurrentCulture auch im Log speichern kann. Oder halt gleich z.B. das ISO-Datumsformat verwendet. 🙂 Das Problem ist z.T. auch, dass der Benutzer die Formate abweichend von den Culture-Vorgaben einstellen kann. So um die Jahrhundertwende herum wurde das kurze Datumsformat z.B. gerne auf vierstellige Jahreszahlen erweitert.

Lion, du warst doch mit dem "Noob" gar nicht gemeint. Ich glaub, du hast da was falsch verstanden, evtl. mangels Interpunktion im Beitrag... Es geht um Anfänger, die zufällig mehrere USB-Geräte haben. Es wurde nicht gesagt, dass alle mit mehreren USB-Geräten Anfänger wären. 🙂

Tja, dann kannst du immer noch auf das Medium draufschauen, welche Dateien dadrauf sind. Ein DCIM-Verzeichnis ist z.B. typisch für SD-Karten, die in Digitalkameras verwendet werden. Aber ganz sicher ist man damit nicht. Wenn's mehrere sind, musst du dem Benutzer eben sagen, dass er alle weiteren Geräte abstöpseln soll, oder eins aussucht.

PS: Du solltest mal die Punkt- und Komma-Tasten auf deiner Tastatur checken. Ich glaub, die sind kaputt.

Hi,

mich nervt das ganz sehr, dass man in .NET-Anwendungen mit dem Mausrad nur Dinge scrollen kann, die gerade den Eingabefokus besitzen. Entschuldigung, aber das ist doch Schmarrn! In jedem Web-Browser funktioniert es anders: Dort kann ich da scrollen, wo der Mauszeiger gerade drüber steht.

Diesen Thread hab ich zum Thema gefunden, ist aber ein bisschen ein anderes Thema und er ist sehr alt:
Panel mit Autoscroll - Mausrad mag mich nicht

Gestern hab ich mich des Problems angenommen, und eine bislang fast perfekte Lösung entwickelt. Es handelt sich um einen IMessageFilter, der die WM_MOUSEWHEEL-Nachrichten abfängt und an das richtige Control weiterleitet. Dazu wird die aktuelle Mauszeigerposition, die mit der Nachricht ankommt, ausgewertet und dann der Reihe nach das Control gesucht, das sich an dieser Stelle im aktiven Fenster befindet. Klappt wunderbar: Panels, DataGridViews in TabControls in SplitContainern und Multiline-Textboxen in Dialogfenstern lassen sich mit dem Mausrad scrollen, ohne dass sie den Fokus haben.

Leider hat die Sache einen Haken: Das Scrollen in aufgeklappten Comboboxen geht nicht mehr. Wenn ich mir die Debug-Meldungen ansehe, dann kommt die Nachricht beim Form an; an der Stelle, wo das Popup ist, findet das Form aber kein Child-Control (von den Koordinaten her) und deshalb kann die Nachricht auch nicht an die Combobox weitergeleitet werden. Jetzt müsste man irgendwie rausfinden, dass ein Popup offen ist, und welchem Control es gehört...

Ich hab den Quelltext inkl. Verwendungshinweis an diesen Beitrag gehängt. Vielleicht mag sich das mal jemand anschauen?

(MouseFilter.cs ist der eigentliche Code. WinApi_Windows.cs wird nicht komplett benötigt, aber ich war zu faul, das jetzt aufs Wesentliche zu kürzen, enthält eh nur WinApi-Deklarationen und Konstanten.)

Edit: Titel geändert
Edit 2: Anlage entfernt. Neue Version siehe Komponentensammlung (Link im Beitrag weiter unten)

Das wird insofern schwierig, weil das Format nicht eindeutig erkennbar ist. Ein und dieselbe Zeichenkette kann in einer Culture etwas völlig anderes als in einer anderen bedeuten. Vor allem Monat und Tag werden je nach Sprache gerne vertauscht.

Du kannst höchstens mit regulären Ausdrücken vorher analysieren und nach deinem Wissen erraten, was es sein könnte, wenn du z.B. nur Datumsformate aus einer begrenzten (und bekannten) Menge von Cultures verarbeiten willst.

Gar nicht. Jedenfalls hab ich jetzt einen USB-Stick und einen USB-SD-Card-Adapter mit eingestecker Karte an meinem PC hängen und ich kann mit keinem Bord-Werkzeug von Windows XP einen Unterschied zwischen beiden "USB-Massenspeichergeräten" entdecken. (Arbeitsplatz, Volume-Eigenschaften, Geräte-Manager, Datenträgerverwaltung) Außer der Volume-Größe und -Bezeichnung und dem Hardware-Namen ("USB DISK Pro USB Device" bzw. "USB2.0 CardReader SD USB Device") gibt es keinen Unterschied zwischen beiden Geräten.

Was willst du denn von der Karte auslesen? An die Daten, die dadrauf gespeichert sind, kommst du ganz normal über das Dateisystem ran. Das Volume Label müsste auch irgendwie mit den System.IO-Klassen gehen. Was gibt's dann noch alles zu lesen?

Wenn du in deinem Event-Handler wiederum die Auswahl der Combobox beeinflusst, wäre es vielleicht ratsam, die Ausführung dieser Event-Handler zu deaktivieren, während du mit deinem eigenen Code die Auswahl der Combobox veränderst. Ich mach sowas immer auf die Weise, dass ich eine Instanzvariable dafür definiere, die aussagt, ob ich gerade selbst an einem Control rumwerkel. Die setz ich dann vor meiner geplanten Änderung auf true und danach wieder auf false. Der Event-Handler, die auf eine Änderung des Controls reagiert, beendet sich aber sofort, wenn diese Variable gesetzt ist. So kommt mein Event-Handler meiner eigenen Änderung nicht in die Quere. Vielleicht hilft das in deinem Fall auch? (Code-Beispiel a.A.)

So eine "InvariantLanguageMessage", wie sie Microsoft vermutlich eher nennen würde, klingt schon interessant.

Wenn du mal ein bisschen mit dem .NET Reflector im Framework rumschaust, wirst du bald feststellen, dass dort intern Zeichenketten angegeben sind, die dem Resource Manager übergeben werden, um eine lokalisierte Fehlermeldung zu erhalten. Diese Zeichenketten sind oft halbwegs verständlich und könnten m.E. durchaus als Schlüssel verwendet werden. Zumindest kann man eine Exception, die man bei der Verwendung von Framework-Methoden erhält, im Quelltext gut wiederfinden und oft besser verstehen.

(Hab ich heute schon erwähnt, dass der .NET Reflector mein Lieblingswerkzeug ist? 🙂)

Ähm... Mausklick im Projektexplorer auf "Form1.cs" und <Entf>, <OK> und die Sache dürfte gegessen sein? Wenn man kein new Form1() mehr in der Main-Methode hat, braucht es auch niemand mehr.

Ich kann dir sagen, wo dein Fenster hekommt: In der Datei Program.cs (automatisch generiert bei Windows-Forms-Anwendungen) steht die Zeile Application.Run mit einer Instanz deines Forms drin. Ich weiß zwar nicht, was passiert, wenn man diese Main-Funktion einfach leerräumt und sein Programm da reinsetzt, aber prinzipiell sollte es einer fensterlosen Win32-(Nicht-Konsolen-)Anwendung recht nahe kommen.

Die Main-Funktion kannst du übrigens erweitern: Wenn du statt

static void Main()

einfach

static void Main(string[] args)

schreibst, hast du alle Kommandozeilenargumente in args enthalten. Alternativ kommst du auch über Environment.CommandLine and die komplette Kommandozeile, zum selbst Parsen.

Original von FZelle
Deine Begründung für deine Herangehensweise ist schlüssig, aber leider falsch.

Warum? Wenn SQLite nicht die Vorteile deines Verfahrens unterstützt, warum sollte ich mir dann die Mühe machen, es zu nutzen? Womöglich handle ich mir noch Nachteile ein, z.B. dass die Datenbank während der Programmausführung verschwindet.

Wenn es Regnet, sind Wolken da, aber wenn Wolken da sind, muss es nicht regnen.

Das ist mir jetzt zu abstrakt. Was willst du mir damit sagen?

Ich hab das gestern und heute auch versucht und bin zu dem gleichen Ergebnis gekommen. Wenn man sich mit dem .NET Reflector die Funktionsweise der entsprechenden Klassen anschaut, sieht man auch ganz genau, warum das nicht geht. Die Klasse NativeWindow, auf die am Ende alles rausläuft, hat eine Unterklasse WindowClass und die hat die Methode RegisterClass. Von außen ist das alles nicht zugänglich, aber das wird intern verwendet. RegisterClass unterscheidet nun, ob in den CreateParams ein className enthalten ist oder nicht. Wenn nicht, wird einer generiert, der aus "Window." und dem classStyle besteht. Wenn dagegen ein className angegeben ist, werden zunächst mit UnsafeNativeMethods.GetClassInfo() Informationen zur angegebenen Klasse abgerufen. Da diese Klasse nach unseren Vorstellungen ja noch nicht existiert, schlägt das fehl und es wird eine Win32Exception mit der Nachricht "Invalid Window Class Name" geworfen.

Das Verhalten dieser Klasse zu beeinflussen schätze ich als nicht machbar ein, denn es wird dort soviel Zeug erledigt und man müsste nur an einer einzigen Stelle mitten in der Funktion einen Feldwert ändern. Bei aller Reflection und anderen unsauberen Tricks glaube ich nicht, dass das geht.

Ich hab jetzt nämlich auch das Problem, dass ich statt Winamp meine eigene Anwendung verwende und die ebenso mit der Hauppauge-Fernbedienung steuern möchte. Diese Fernbedienung kann man konfigurieren und den FB-Tasten eben Tasten, AppCommands oder eigene Nachrichten an bestimmte Fenster zuordnen. Für manche Funktionen gibt es keinen MEDIA_*-Keycode, den man in RegisterHotkey angeben kann, AppCommands funktionieren nur, wenn das Fenster gerade aktiv ist, und zum Versenden eigener Nachrichten müsste man eine konstante Fensterklasse haben. Leider ist das mit .NET wirklich nicht möglich. Ich überleg mir jetzt, mit den WinApi-Funktionen ein eigenes Message-Fenster zu machen, das alle (oder bestimmte) Nachrichten einfach über eine Event-Schnittstelle rausgibt. So kann man sich auch für .NET-Anwendungen eine "Fenster-Adresse" zulegen, an die Nachrichten gesendet werden können. Mal schauen, wie aufwändig das wird. (Leere Fenster erstellen ging ja früher mit Win32-Anwendungen recht einfach...)

So, nun hab ich mich in der MSDN-Dokumentation mal durch das ADO.NET Verbindungspooling durchgelesen, und von Anfang an sehr den Eindruck bekommen, dass das bei jedem Datenprovider unterschiedlich gehandhabt wird. Da werden SQL Server, ODBC und Oracle genannt, die jeweils andere Fähigkeiten haben.

Also hab ich es mal ausprobiert. Für eine SqlConnection ist der ConnectionString-Parameter "Pooling" ja mit "true" vorbelegt. Da ich SQLite verwende, weiß ich nicht, ob es diesen Parameter gibt und welchen Vorgabewert er hat. Ob eine SQLite-Datenbank geöffnet ist, kann ich recht einfach feststellen, ob die Datei gesperrt ist. Ist die Datenbank geschlossen und kein Programm graif darauf zu, kann ich sie problemlos löschen oder bekomme eine exklusive Sperre darauf. Ist sie geöffnet, geht das nicht. Dann hab ich die Datenbank mit Close() wieder geschlossen, und die Datei war nicht mehr gesperrt. Auch nach Hinzufügen des o.g. Parameters war nicht zu beobachten, dass noch eine Verbindung zur Datenbank offen wäre.

Daraus schließe ich, dass SQLite kein Verbindungspooling unterstützt und dieses Muster der kurzen Datenbankverbindungen in diesem Fall nicht anwendbar ist. Ob das Öffnen einer SQLite-Datenbank zu messabren Verzögerungen führt, habe ich noch nicht getestet. Aber bis dahin bleib ich lieber dabei, die Verbindung zu halten, solange ich sie verwenden will, anstatt sie bei jeder einzelnen Datenbankoperation neu zu öffnen. Beim MS SQL Server mag sich das anders verhalten, aber für den hatte ich noch keine Anwendung.

Original von dechavue
Du müsstes es nichtmal selbst implementieren:
>

Aha, da kommen also die Anwendungen her, deren Progressbars zerstückelt und GRÜN sind, während alle anderen Progressbars im System am Stück und blau, orange oder irgendwas != GRÜN sind. Naja, was soll's.

Davon, dass jemand die Blöcke eines zerstückelten Fortschrittsbalken als separate Einheiten ansieht, hab ich noch nichts gehört. Das würde aber auch erfordern, dass man die Größe dieser Blöcke zuverlässig beeinflussen könnte, was mit Visually Styled Progressbars nicht geht.

Runder Startmenü-Button -> Meine Analyse: Du hast Windows Vista mit aktiviertem Aero-Design. Wenn die Fensterrahmen noch halb durchsichtig erscheinen und die Fenster einen leichten Schlagschatten haben, dann hast du Aero Glass aktiviert. Das ist die Vorgabe für Vista. Dabei gibt es keine zerstückelten Fortschrittsbalken. Bei Aero Glass gibt es nur pulsierende grüne Balken, die an einem Stück sind.

Lösungsvorschlag: Wenn du unbedingt eine zerstückelte Progressbar haben willst, mach dir ein CustomControl, das genau sowas zeichnet. Dann bist du diese pulsierende Animation los und kannst die Zerstückelung sogar noch frei konfigurieren. Dürfte nicht viel Aufwand sein, ein paar Properties und ein paar Zeilen Paint-Code sollten ausreichen.

Ich hab das Zune-Design für XP nochmal kurz getestet: Es gibt dort nur zerstückelte Progressbars. Ich hab eine Anwendung, die einen kontinuierlichen Balken anzeigen soll, das im Classic-Design auch tut, mit Visual Styles wird der aber auch wieder zerstückelt. Scheinbar muss man sich mit aktivierten Visual Styles genau an die eine Darstellungsform halten, ob man will oder nicht.

Einen Balken-Fortschrittsbalken, wenn ich das mal in eine einheitliche Sprache übersetzen darf?

Ich hab das angehängte Programm mal getestet (in einem XP-System, in dem Visual Styles aktiviert sind) und da ist die Zerstückelung zu sehen. Ob das hier verwendete Zune-Design aber überhaupt einen kontinuierlichen Balken anzeigen könnte, weiß ich nicht.

Ne, die Darstellung von Standard-Controls ist (außer bei WPF) immer Sache des Betriebssystems. Java und Qt machen ihren Kram komplett selbst (bei Java 1.6 bin ich mir nicht mehr sicher), aber .NET verwendet auch nur das Windows-API. Und dafür sind die normalen Windows-Einstellungen zuständig.

Mit WPF wurde das geändert, deshalb kann man dort alles beliebig designen, soweit ich die Tutorials verstanden habe. Aber das trifft ja hier glaub ich nicht zu.

Also wenn du in die Exe-Datei schreiben willst: Früher hat man das so gemacht, dass man sich einen eindeutigen Magic Key ausgedacht hat, hinter dem die angehängten Daten folgen. Die Exe-Datei kann dabei verlängert werden, das stört nicht. Die meisten Single-Exe-Installer und selbstentpackenden Archive dürften so funktionieren. Zur Laufzeit kannst du dann in deinem eigenen Executable nach diesem Magic Key suchen und im Anschluss die Daten lesen.

Aber warum musst du die Daten in der Programmdatei speichern? Zudem hat der Benutzer im Programmverzeichnis oft keine Schreibrechte. Leg doch im Anwendungsdatenverzeichnis (oder meineswegen auch im Programmverzeichnis, falls möglich) eine separate Datei dafür an.

Schade, hier stehen noch einige Behauptungen im Raum, die ich so nicht stehen lassen wollte. Kurz: Linux ist bei weitem nicht in jeder Disziplin besser als Windows. Ich sag nur: Oberfläche und Bedienbarkeit. Und wenn Microsoft einmal Recht hatte, denn mit der Werbung "alles ist möglich"!

Zurück zum Thema: Ich glaub das mit dem "Betriebssystem von Null weg" hat sich mittlerweile erledigt. 😉

Original von SteelWarrior
Achja ich hatte ja vor paar Tagen DSL gekündigt. Und wollte bei Telekom ein DSL Vertrag abschliessen. Die sagte mir dann: "Nein das geht nicht." Ich: "Wieso?" Telekom-Mitarbeiter: "Ihr DSL Anschluss ist von dem Reseller Partner noch nicht freigegeben". Ich:"Wie lange kann das dauern?" Telekom-Mitarbeiter: "eeeh, ca. 1 bis 6 Wochen" Ich: "@&%$?!"

Stimmt. Die Telekom ist scheinbar ihren eigenen Resellern machtlos ausgesetzt. Das darf zwar laut Antwort des Telekom-Vorstandes nicht sein, dass es hier zu solchen Verzögerungen kommt. Aber diese Antwort hat selbst noch sehr viel länger gedauert als ein DSL-Anschluss gedauert hätte. Deshalb sind wir Anfang des Jahres ja auch nicht zur Telekom gewechselt.

Prinzipiell scheint mir M-Net einen sehr guten Eindruck zu machen. Bislang verlief alles reibungslos, die Umstellung von 1&1-DSL ging innerhalb einer Stunde. Wo also lokale oder regionale Telefon-/DSL-Anbieter mit eigenem Netz verfügbar sind, würde ich vorzugsweise zu diesen gehen. Die anderen sind einfach schon zu groß. Die gehörten mal wieder von politischer Seite aufgespalten und in gegenseitige Konkurrenz gestellt.

Naja, also ich verwende jetzt auch schon seit einiger Zeit eine Klasse, die alle Datenbankfunktionen bereitstellt und in Anwendungsobjekte übersetzt. Diese Klasse bekommt im Konstruktor die nötigen Verbindungsinformationen mit und baut eine Verbindung auf. Die wird im Folgenden dann verwendet. Die Instanz der Datenbankklasse ist in MainForm als Instanzvariable enthalten. Funktioniert auch problemlos und performant, der Code ist klar aufgeteilt, einfach erweiterbar (neue DB-Analysen/Abfragen/Operationen können leicht eingefügt werden), kann ich sogesehen also auch empfehlen. Was ist jetzt "besser"?

Ich denke, es gibt hier viele Wege, das Ziel zu erreichen. Vielleicht ist für Disconnected DataSets das kurzzeitige Verbinden zur Datenquelle besser geeignet, weiß ich nicht, ich arbeite nur online auf Datenbanken, das erspart mir oft die aufwändige Synchronisation. Und wenn die Datenquelle erstmal weg ist, besteht eine größere Gefahr, dass sie nicht wiederkommt.

Was bedeutet denn nun konkret "auf Kurzlebigkeit ausgelegt"? Haben die Objekte Memory Leaks? Werden sie mit der Zeit instabil? Könnte ich alles nicht bestätigen. So ein Objekt funktioniert auch nach Stunden noch einwandfrei.

Also unter Vista hast du vermutlich keine Chance, diesen zerstückelten Fortschrittsbalken zu bekommen. Und im Classic-Design auch nicht. Das Classic-Design ist bei Windows XP und Vista nicht voreingestellt, du musst es also aktiv einstellen, um es überhaupt zu bekommen. Auf dem gleichen Weg (Systemsteuerung -> Anzeigeeigenschaften) kannst du auch wieder was anderes einstellen. Das Classic-Design erkennst du z.B. an der grauen Taskleiste und grauen Buttons im Fenster oben rechts, wo im XP-Luna-Design eine blaue Taskbar mit grünem Start-Button und unter Vista ein aus der Taskleiste herausragender Kreis als Start-Button angezeigt werden (das ist nicht Classic). Sind aber eigentlich Grundlagen der Windows-Benutzerkonfiguration, die man als Software-Entwickler kennen sollte. Also ggf. nochmal nachgoogeln...

Zum ersten Beitrag kann ich nur soviel anmerken:

Früher, in der Schule, hatte ich durchaus auch so meine Ideen, ein eigenes Betriebssystem zu schreiben. Es sollte "Universe" heißen, mit 64 oder besser 128 Bit arbeiten, und über eine dreidimensionale grafische Oberfläche verfügen, in der Verbindungen zu anderen Rechnern durch "Wurmlöcher" (natürlich inklusive der bekannten Visualisierung eines solchen) dargestellt werden. Man merkt schon, woher die Idee kommt... Von Betriebssystementwicklung hatten ich und mein Mitdenker noch überhaupt keine Ahnung.

Im Informatik-Studium hab ich dann u.a. die Vorlesung Betriebssysteme besucht. In der Übung war es dann unsere Aufgabe, in 2-3er-Teams nahezu von Grund auf (also ab direkt nach dem Bootloader-Assembler-Code) ein eigenes Betriebssystem zu entwerfen und implementieren. Gut, den Entwurf hat man uns mit der Aufgabenstellung weitgehend abgenommen, damit auch jeder das gleiche macht. Aber im Grunde war es unsere Aufgabe, C++-Klassen zu schreiben, die eine Coroutine, einen Thread oder einen Scheduler umsetzen. Das ganze lief dann zum Test auf einem alten 486er, gebootet von Diskette; während der Entwicklung wurde das System in Bochs auf dem Sun-Server getestet.

Es war ein riesiger Aufwand! In einem Semester, also etwa 3 Monaten und ca. 3-10 Stunden Arbeit pro Woche, sind wir dann soweit gekommen, dass man Texte auf dem Bildschirm ausgeben, mehrere Threads parallel laufen lassen (mit ganz einfachem Zeitscheiben-Scheduler) und auf Tastatureingaben reagieren konnte. Keine Speichermedien und Dateisysteme, keine Speicherverwaltung und Adressräume, keine Hardware außer Video-RAM und Tastatur, keine Grafikausgabe, kein Netzwerk, also eigentlich fast überhaupt nichts. Und auf dem Weg dorthin gab es bald mehr Fehlschläge als Erfolge, da man einen Betriebssystem-Kernal nunmal ganz schlecht debuggen kann. Wenn der PC einfach hängen bleibt, ist es oft kaum möglich herauszufinden warum. An "Universe" hab ich dann schon nicht mehr gedacht.

In den Semesterferien im Anschluss hab ich noch versucht, einen einfachen prioritätenbasierenden Scheduler zu schreiben, das hat dann aber nicht mehr funktioniert.

Was mich am allermeisten an Microsoft Windows XP stört, ist der IO-Scheduler. Der ist meiner subjektiven Erfahrung nach so grottenschlecht... Wenn ein Programm läuft, das 100% CPU macht und ein bisschen Platte, dann bleibt das sofort nahezu stehen (CPU-Last < 20%), wenn ein anderes Programm die Platte stark nutzt, z.B. beim Starten von VS.NET oder was ähnlich großem oder beim Kopieren großer Dateien. Hier hat glaub ich Linux eindeutig die Nase vorn. Zigtausend kleine Webseitendateien durchsucht man da in fast keiner Zeit (mit grep). An Linux wurde in den letzten Jahren aber auch sehr viel gemacht, was wohl zu großen Verbesserungen geführt hat. Von Microsoft kann ich das jetzt nicht behaupten. Es gab wohl einige Detailverbesserungen in Vista, aber viel wurde wieder gestrichen und verschoben. Die sind trotz ihrer Marktmacht einfach zu langsam. Ob der Scheduler in Vista deutlich besser ist, kann ich mangels Erfahrung nicht sagen, aber ich kann es mir auch nicht vorstellen. Wenn du dich also unbedingt an etwas sinnvollem betätigen willst, dann lern Computer 😁 (also v.a. auch von innen), dann lern Betriebssysteme, dann Assembler und dann geh zu Microsoft und mach denen einen ordentlichen Scheduler. Allein das wird vermutlich ein Jahr dauern, bis es stabil läuft, aber wir werden es dir danken! 🙂

Original von Pendi
Hast du den VisualStyle auf deinem Rechner aktiviert?

Das wär auch meine Vermutung: Du hast einfach das Classic-Design aktiviert. Zeig uns doch mal nen Screenshot, wie es momentan bei dir aussieht.

(Abgesehen davon ist meine persönliche Meinung, dass es diese Zerstückelung des Fortschrittsbalken nicht gebraucht hätte. Vermindert nur die Auflösung der Anzeige, gibt's in keinem anderen modernen System und ist auch in Vista wieder verschwunden - da pulsiert es dafür ganz grässlich...)

Z.B. indem man die eigentlichen Datenfelder private macht, und die logischen Felder dann mit public Properties verfügbar macht, in denen die entsprechenden Bits aus den privaten Datenfeldern rausgepult und reingerechnet werden.

class/struct SomeStruct
{
    private uint allBits;

    public int Field1
    {
        get { return (allBits >> 4) & 0xFF; }
        set { allBits |= (value & 0xFF) << 4; }
    }
}

(Ohne Garantie auf Lauffähigkeit...)

Naja, da die meisten Tool-Pötte, Farbmischer, Komponenten-Boxen und Projekt-Explorer heute senkrecht orientiert sind, und man diese gleichzeitig mit dem zu bearbeitenden Inhalt anzeigen möchte (ohne sie ständig über diesem aus- und einzuklappen), hat ein eher breiter Bildschirm schon gewisse Vorzüge. Mein Browser-Fenster hat trotz 5:4-Monitorformat eher Widescreen-Ausmaße, weil ich eben öfter mal die Lesezeichen-Sidebar einblende, um z.B. schnell die tägliche Ration Webforen abzuklappern. 🙂 (Bei diesem Forum, dem letzten in der Liste, muss ich die Bookmarks dann aber ausblenden, weil das Layout nicht in etwas weniger als XGA-Auflösung reinpasst.) Und zum Reinwerfen von interessanten Links in den "Programmierung/.NET"-Bookmark-Ordner ist es auch ganz gut.

Original von FZelle
Es behbt ausserdem noch das problem, das Globale Variablen selten
der OOP entsprechen.

Achso, und den Connection String geb ich bei jeder Datenbankfunktion dann als Literal ein? Weil globale Variablen, und seien sie nur Instanzvariablen eines Forms, sind ja böse™.

FZelle, führt ein ständiges Trennen und Neuaufbauen von Datenbank-Verbindungen nicht zu spürbaren Verzögerungen? Ich hab damit noch nicht viel Erfahrung, hab MySQL bisher nur in PHP verwendet und in .NET-WinForms-Anwendungen halte ich eine SQLite-Verbindung für die ganze Anwendung, was aber zu keinen Problemen führt. Ist eben einfacher, die Verbindung einmal zu öffnen und sich um eventuelle Fehler zu kümmern und sie danach immer verfügbar zu haben. Vielleicht ist SQLite aber auch was anderes als MySQL/Oracle/...

Das einzige Mal, wo ich MySQL in .NET gesehen hab, war in einer Projektarbeit in BWL, wo ein Doktorand oder so eine solche Anwendung geschrieben hat, die wir erweitern sollten. Im ersten Praxistest ist allerdings der MySQL-Server nach 10 Minuten zusammengebrochen, weil der Client massenhaft Verbindungen aufgebaut hat... Danach war das Projekt glaub ich zuende. 😉

Nicht immer. Hier steht wann und wieso:
http://blogs.msdn.com/jfoscoding/archive/2006/06/23/644336.aspx

(Nur der Vollständigkeit halber, ich bin grad über diesen Artikel gestolpert und da ist mir eingefallen, dass ich hier doch erst so nen Thread gesehen hab...)

In der Regel funktioniert das aber wie oben beschrieben.

Das geht ganz einfach. Definier dir in deinem StartDialog eine öffentliche Variable (Feld oder Property ist nicht so wichtig), in die du beim Drücken eines Buttons im StartDialog einen Wert schreibst, der über den gedrückten Button Auskunft gibt. Öffnen = 1, Neu = 2, usw. Wenn du den Dialog dann mit OK oder welchem Return-Code auch immer schließt, kannst du direkt nach dem ShowDialog-Aufruf dieses Feld aus dem Form-Objekt auslesen und entsprechend weiterarbeiten. Das Form ist nach dem Schließen zwar geschlossen, aber das Objekt und seine Felder sind ja noch da. Genauso funktioniert das z.B., wenn du mit einem Dialogfenster Daten bearbeiten willst: Hier kannst du die Textfelder oder andere Variablen im Edit-Form vor dem Anzeigen (also zwischen new und ShowDialog) vorbelegen und nach dem Schließen (nach ShowDialog) je nach Return-Code dann auslesen und ggf. speichern.

Falls es den Autor der Klasse noch interessiert: Das &-Zeichen sollte man möglichst auch austauschen. 😉 Und zwar, damit es nicht alle anderen Entities mit ersetzt, als allererste Operation, also vor allen anderen Ersetzungen. & wird in HTML/XML durch &amp; ersetzt.

Ansonsten sei erwähnt, dass diese Entities (abgesehen von den Sonderzeichen & < > und unter bestimmten Umständen auch ") nicht benötigt werden, wenn man in der HTML-/XML-Datei eine korrekte Angabe zum verwendeten Zeichensatz macht. Dafür gibt es sowas schließlich. Und wenn man UTF-8 als Zeichensatz verwendet und sich dann auch noch dran hält, kann man alle Zeichen der Welt ohne jede Umschreibung verwenden. Ich denke, diese Welt ist bereit für Unicode. 🙂

Und übrigens: So Entities wie &auml; sind in HTML definiert - nicht aber in XML in seiner Rohform. XML-Dateien, die sowas enthalten, werden einem vom Parser i.d.R. gleich um die Ohren geworfen! (Außer man schreibt sich eine passende DTD...)

Original von Peter Bucher
Nicht nur wegen der Benutzung von Frames, sondern vorallem weil dann kein DeepLink mehr möglich ist.

welche nicht zuletzt auch für so nebensächliche Dinge wie Lesezeichen (Bookmarks, Favoriten) benötigt werden... Aber genug davon. 😉

[EDIT]Abgeteilt von DataGridView Update geht nur einmal[/EDIT]

Original von FZelle
3.
In WindowsForms (...) ist es ziemlich schlechtes design
eine Verbindung für das gesammte Programm zu benutzen.

Weil?

Dass "kommentarlos schließen" kein beabsichtigtes Verhalten des VS ist, würde ich so nicht uneingeschränkt unterschreiben. 😉 Ist mir auch schon öfter mal vorgekommen, wenn eine meiner Komponenten nicht korrekt funktioniert hat und ich sie in dem anderen Form verwenden wollte.

Dass der Designer die Eigenschaften nicht alle speichert, dagegen kann man oft mit ein paar Attributen was tun. Z.B. das hier:

[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
[DefaultValue(true)]
public bool PropertyName
{
	get { ... }
	set { ... }
}

Anstelle des "Visible" im Argument gibt's noch zwei weitere Werte, die während der Eingabe zur Auswahl stehen. Die MSDN-Dokumentation zu DesignerSerializationVisibility weiß mehr darüber, was das alles bedeutet.

Du kannst Thread.Sleep(milliseconds) verwenden, aber beachte, dass in dieser Zeit keine Nachrichten verarbeitet werden, also z.B. auch das Fenster nicht neugezeichnet werden kann. Wenn die Anwendung mit einer Aktion nach einer bestimmten Zeit weitermachen soll, während dieser Pause aber auf Eingaben reagieren soll, kommst du um einen Timer nicht weit herum, ohne unschönen Code (z.B. mit Application.DoEvents in einer Schleife) zu schreiben. Die Sache mit dem Timer hab ich in meinem DelayedCall komfortabel gekapselt.

Edit: Dass keine Eingaben verarbeitet werden gilt natürlich nur, wenn du den UI-Thread anhältst, also das Sleep in einem gewöhnlichen Ereignis-Handler eines Forms ausführst. In Hintergrund-Threads ist das unproblematisch und Konsolenanwendungen oder Serverprogramme sind davon ähnlich wenig betroffen.

svenson, danke, die Links werd ich mir mal anschauen.

Rainbird, diese Änderung mit dem port=0 hab ich sehr früh schon eingebaut. Das hat glaub ich die Lage verbessert, insofern, dass diese beschriebene Exception verschwunden ist, aber ganz funktioniert es ja immer noch nicht. Hab momentan aber leider keine Zeit, den Code zu debuggen, das wird noch warten müssen.

Nagut, dann werd ich den Code bei Gelegenheit nochmal zerlegen, einen Testcase daraus ableiten und das ganze nochmal mit einem konkreten, nicht funktionierenden Beispiel hier zur Diskussion bringen. Bis dahin verwenden wir alle weiterhin .NET Remoting oder WCF und die Diskussion sollte vorerst erledigt sein...

"Kleine fertige Lösungen"? Ich hab diesen RemotingHelper irgendwo hier aus dem Forum verwendet. Und meine ersten Gehversuche mit .NET Remoting sahen so ähnlich aus, die diese Klasse von innen auch aussieht. Allzuviel gibt's da ja nicht dran einzustellen, ist halt nur viel Tipparbeit.