Zu den DSL-Geschwindigkeiten bei der Telekom-Konkurrenz gab's vor einer Weile in der c't nen Artikel. Kurzgefasst: Die Telekom verwendet eine fixe Einstellung der Geschwindigkeit. Damit das zuverlässig funktioniert, müssen die Leitungsanforderungen größer sein, daher trauen sie der Leitung nur geringere Geschwindigkeiten zu. Bei fast allen anderen Anbietern ist eine variable Aushandlung eingestellt. D.h., dass das DSL-Modem beim Verbinden selbst feststellt, ob die ausgemachte Datenrate funktioniert und dann ggf. damit runtergeht. Durch diese Sicherungsmethode kann man natürlich viel größere Geschwindigkeiten einstellen, und sollte es doch mal nicht gehen, weil die Nachbarn grad alle online sind und das Wetter schlecht ist, dann wird's halt langsamer. Diesen Unterschied kann ich nach den Angaben meiner FritzBox bestätigen.

Aber nur mal so zum Vergleich: Die Telekom hat unseren Anschluss noch nichtmal von 768/128 auf 1024/128 kbit/s angehoben, als das überall gemacht wurde, und bei M-net läuft er stabil bei 3000/512 kbit/s. Also scheint mir die Haltung der Telekom entschieden zu konservativ. Naja, sind deren Kunden, die sie nicht bedienen können und die sich was anderes suchen. Aber dann sollen sie nicht ständig die Fernsehkameras vollheulen.

Aha, schön. Die Threads hab ich bereits alle durch, und die vorgestellten Lösungen funktionieren bei mir nicht. Wenn der Remoting-Server dem Client nach dem Observer-Pattern eine Nachricht zukommen lassen will, dann hängt der Server-Aufruf, der das verursacht hat, für ca. 40 Sekunden in der Luft rum, bis er schließlich den Observer-Notify mit einer SocketException abbricht und das Programm weiterläuft. Das sieht mir nicht nach "problemlos" aus!

WCF = Remoting? Aha, mal reinschauen. Mit .NET 3.x hatte ich (mangels VS-Unterstützung) noch fast nichts zu tun...

Hallo,

ich will in meiner Anwendung das Drücken der Tasten Alt+Enter für eigene Zwecke abfangen. Wenn ich diese Tasten einfach im KeyDown-Ereignis des DataGridView abfrage, kommt sie dort nie an. Strg+Enter und Enter allein geht, nur Alt+Enter nicht. Das wird wohl das leidige Problem sein, dass manche Tasten einfach nicht als "InputKey" angesehen werden und deshalb nicht als würdig, ein KeyDown-Ereignis auszulösen. Glücklicherweise muss man nicht gleich das ganze DataGridView ableiten, um diese Entscheidung aufzuheben, im PreviewKeyDown-Ereignis kann man das genauso tun. Also hab ich dort folgenden Code eingefügt:

private void dataGridView1_PreviewKeyDown(object sender, PreviewKeyDownEventArgs e)
{
	if (e.KeyCode == Keys.Enter && e.Modifiers == Keys.Alt)
	{
		e.IsInputKey = true;
	}
}

Das führt dazu, dass ich Alt+Enter ganz normal im KeyDown-Ereignis behandeln kann. In meinem Fall soll dann für die ausgewählte(n) Zeile(n) ein neues Fenster zum Bearbeiten der Datensätze geöffnet werden.

So, funktioniert wunderbar. Nur gibt es jedes Mal, wenn ich Alt+Enter im Grid drücke, während das Fenster aufgeht, einen Piepton vom System. So einer als würde ich auf ein deaktiviertes Fenster klicken oder einen Menü-Hotkey drücken, den es nicht gibt. Bei den anderen Tasten passiert das nicht.

Kann man dem Programm dieses Piepsen abgewöhnen? Ich find das stört und seh keinen Grund warum sich das so gehören sollte.

Eine Alternative wäre sicherlich, alle Tastaturereignisse auf Prozessebene abzufangen und selbst zu verteilen. Das würde auch Probleme mit den Left/Right-Tasten in einem anderen Fenster lösen, die dort partout kein Ereignis auslösen wollen. Nur wäre das wieder recht aufwändig und ich denke, dass die Controls bitte auch so gemäß ihrer Spezifikation zu funktionieren haben.

Hallo,

dass .NET Remoting eine feine Sache ist, dürfte allen, die schonmal damit gearbeitet haben (und die dafür vielleicht auch eine der hier im Forum angebotenen Hilfestellungen/Komponenten verwendet haben) klar sein. Dass .NET Remoting über Rechnergrenzen aber mit Ereignissen überhaupt nicht klar kommt, wird den meisten, die es versucht haben, auch schon aufgefallen sein.

Dabei sehe ich darin kein prinzipielles Problem. Eigentlich müsste es wunderbar funktionieren. Das Instanziieren eines Objekts könnte eine TCP-Verbindung öffnen und das Aufrufen von Methoden sendet Nachrichten über diese Verbindung. Aber eine TCP-Verbindung kann ja Daten in beide Richtungen übertragen. Also kann das Remote-Objekt beim Auftreten des Ereignisses eine Nachricht an den Client zurücksenden, der auf diese reagiert und das Ereignis lokal auslöst. Mittels Reflection sollte sich dieses Verfahren ähnlich transparent umsetzen lassen, wie das .NET-eigene. Man würde halt den kompletten Prozess der Generierung eines Proxys und des passenden Gegenstücks sowie das Kommunikationsprotokoll und die Verbindungsverwaltung neu implementieren.

Sieht darin einer der hier anwesenden Experten ein unüberwindbares Problem? Funktioniert es aus mir noch unbekannten/unbewussten Gründen doch nicht so ohne Weiteres? Oder wäre nur der Aufwand zu groß?

http://blogs.simplifi.com/brucet/archive/2005/01/25/161.aspx (Teil 1)
http://blogs.simplifi.com/brucet/archive/2005/02/11/164.aspx (Teil 2, mit Download)

Hier nochwas aus der MSDN:
http://msdn2.microsoft.com/en-us/library/ms867196.aspx

Ich glaub ich hab die Antwort gefunden, warum das nicht ging.

http://msdn2.microsoft.com/en-us/library/ha5xt0d9.aspx beschreibt, dass das RowTemplate mitsamt dem Kontextmenü für jede neue Zeile geklont wird. Das könnt erklären, warum die Änderungen nicht beim (geklonten = andere Instanz) Kontextmenü angekommen sind. Scheinbar wurden die Ereignishandler aber mit geklont, denn die wurden ja noch aufgerufen.

Ich bin mit der Designer-Unterstützung eigentlich sehr gut zurechtgekommen, als ich das erste Mal mit dem DataGridView zu tun hatte. Ist recht straightforward, das Grid hat Zeilen (Rows), eine Zeile hat Zellen (Cells), eine Zelle hat einen Inhalt (Value). Die Formatierung lässt sich auf allen Ebenen festlegen und gilt, sofern nicht überschrieben, für alle tieferen Ebenen.

Zur interaktiven Bearbeitung der Daten und zu DataSources/DataSets kan ich nichts sagen, das hab ich noch nicht verwendet.

Ich hab in den letzten Tagen aber viel über die Performance des Grids gelernt und Methoden gefunden, die man das Grid für große Datenmengen richtig schnell bekommt. Darüber werde ich in Kürze wahrscheinlich einen kleinen Artikel verfassen.

Hm, scheinbar ist es keine sonderlich gute Idee, einzelnen Zeilen ein Kontextmenü zuzuweisen. Wenn man stattdessen dem ganzen DataGridView.ContextMenuStrip ein Kontextmenü zuweist, funktioniert es einwandfrei. Seltsam, aber an das DataGridView muss man sich wohl erstmal gewöhnen, damit es so tut wie man will. 😉

Hi,

ich kämpfe grade ganz massiv mit meinen ToolStripMenuItems aus einem ContextMenuStrip. Da sind verschiedene Befehle drin, die je nachdem, welche Einträge in der Liste ausgewählt sind, aktiviert oder deaktiviert werden müssen. Wenn keine oder mehrere Zeilen ausgewählt sind, darf "Bearbeiten" z.B. nicht zur Verfügung stehen.

Ob ich die Enabled-Eigenschaft des Menübefehls aber auf true oder false setze, interessiert das Menü rein gar nicht. Die Befehle sind immer entweder aktiviert oder deaktiviert, ich hab noch kein System dahinter gefunden. Während einer Programmausführung ändert sich der Zustand allerdings nie. Ich hab das Programm jetzt mit Debug-Ausgaben gespickt. Laut dem, was der Debugger sieht, ist alles in Ordnung. Beim Ändern der Auswahl (DataGridView.SelectionChanged) und beim Öffnen des Menüs (ContextMenuStrip.Opening) werden die Werte korrekt gesetzt bzw. sind korrekt gespeichert. Auch der letzte Zustand wie in ToolStripMenuItem.EnabledChanged gesehen ist richtig.

Seltsam ist, dass ToolStripMenuItem.EnabledChanged sehr oft aufgerufen wird, aber nicht durch meinen Code. Das Kontextmenü ist mit den Zeilen eines DataGridView verbunden. Jedes Mal, wenn der Inhalt einer Zeile verändert wird (aber nur einmal pro Zeile pro Durchlauf durch alle Zeilen), wird EnabledChanged ausgelöst. Keine Ahnung warum. Bei 6500 Zeilen macht das 6500 Aufrufe dieses Ereignisses. Alles sehr dubios.

Der Effekt ist aber, dass ich keinen Einfluss auf die Aktivierung eines Menübefehls habe. Der tut was er will. Wenn ich die Aktivierung im Designer voreinstelle, ist es oft auch zur Ausführungszeit noch so, selbst wenn der Wert schon ein paar Mal (nachweislich) überschrieben wurde. Mir scheint, dass das MenuItem hier mit seinem eigenen Zustand gewaltig durcheinander kommt.

In einer kleinen Testanwendung läuft dagegen alles perfekt. Ich kann den Wert 2000 Mal auf false setzen und auch danach wird jede Änderung von .Enabled korrekt auf dem Bildschirm dargestellt. Daher kann ich leider keinen Testcase zum Nachvollziehen anbieten.

Kann mir vielleicht trotzdem jemand helfen?

Hi Bibi,

vielleicht ist das DataGridView in diesem Fall ja die bessere Wahl. Das stellt eine Tabelle zur Verfügung, in der du genauso wie im ListView jede einzelne Zelle verändern kannst (sogar noch einfacher, wie ich finde) und in dem du auch einzelne Zellen (oder auch ganze Zeilen) auswählen kannst. Auch das Bearbeiten der Inhalte einzelner Zellen ist da schon eingebaut - mit Textfeldern, Checkboxen uvm. 🙂

Yves

Es scheint so als hätte ich die Ursachen gefunden.

1. Wenn einzelne Spalten den AutoSizeMode = AllCells gesetzt haben, dauert es sehr^3 lange. Stattdessen sollte man Fill oder DisplayedCells verwenden, das verursacht keine fühlbare Verzögerung. DisplayedCells richtet sich aber entgegen einer möglichen Vermutung nur nach den zum Zeitpunkt des Schreibens sichtbaren Zellen und wird beim Blättern nicht mehr aktualisiert. Das schränkt die Nützlichkeit dieser Option sehr ein.

2. Auf keinen Fall sollte man die Höhe der Zeilen irgendwie beeinflussen wollen. Das Setzen der Eigenschaft AutoSizeRowsMode auf etwas anderes als None, sowie das manuelle Setzen der Höhe jeder einzelnen Zeile beim Füllen der Tabelle verursachen lange Verzögerungen. Für wenige Zeilen mag man das noch hinnehmen können, aber bei 6500 Zeilen und 4-6 Spalten sind es schon ca. 10 s (im Debug-Modus). Die DefaultCellStyle.WrapMode-Eigenschaft wird dadurch ebenfalls uninteressant.

Was mich jetzt aber am allermeisten wurmt ist, dass es vor dem erstmaligen Anzeigen des DataGridView auf dem Bildschirm keinerlei Verzögerungen gibt. Die hier beschriebenen Probleme treten erst auf, wenn das Grid einmal sichtbar war, selbst wenn es dabei noch leer war und nach dem ersten Anzeigen und wieder Ausblenden dann erstmalig mit Daten gefüllt wird. Sehr dubios. Ich werd parallel mal im MSDN-Forum nachfragen, ob da jemand was näheres weiß.

Infragistics = teuer. Kommt für mich nur in den allerseltensten Fällen in Frage.

So, Test erfolgreich. Ohne die ganzen Width- und Alignment-Optionen ist das Grid ganz schnell, 6500 Zeilen in gefühlten < 1 s, das ist akzeptabel. Sonst dauert es ewig. Ich schau mal, ob ich die genaue Layout-Option finde, die dafür verantwortlich ist, oder ob es alle gemeinsam sind. Jemand ne Idee, wie man das Problem trotzdem umgehen kann? Sicherlich könnte man vor jedem Füllen der Liste das Control komplett neu erzeugen. Das macht dann allerdings die Designer-Unterstützung größtenteils zunichte.

Nein, die ersten 6500 Zeilen werden im Konstruktor des Forms geschrieben, da wird noch gar nichts angezeigt. Die anderen 450 Zeilen werden erst geschrieben und danach wird die TabPage, in der das zweite DataGridView liegt, aktiviert.

Es werden bereits alle vorherigen Zeilen gelöscht, also nichts angefügt. Die Funktionsweise des Programms ist in Ordnung, es dauert halt nur manchmal etwas sehr lange.

Der Code ist kein Hexenwerk. Hier ein Beispiel. Die Spalten sind bereits im Designer gesetzt und enthalten diverse Width- und Alignment-Einstellungen. Mal sehen, ob es ohne die schneller wird.

public void LoadData(List<Song> songs)
{
	Debug.WriteLine("SongsList.LoadData: " + songs.Count + " items");
	dataGridView1.RowCount = 0;   // Das hier beschleunigt wie gesagt das Löschen vieler Zeilen
	dataGridView1.RowCount = songs.Count;
	int i = 0;
	foreach (Song song in songs)
	{
		dataGridView1.Rows[i].Tag = song;
		dataGridView1.Rows[i].Cells[0].Value = i + 1;
		dataGridView1.Rows[i].Cells[1].Value = song.Artist;
		dataGridView1.Rows[i].Cells[2].Value = song.Title;
		dataGridView1.Rows[i].Cells[3].Value = song.Version;
		dataGridView1.Rows[i].Cells[4].Value = song.LengthFormatted;
		i++;
	}
	Debug.WriteLine("SongsList.LoadData - finished");
}

Hi,

ich habe vor kurzem auch das DataGridView entdeckt, und es löst tatsächlich einen Großteil meiner Probleme bzgl. der Anzeige von tabellarischen Daten. Nur leider hat es ganz massive Performance-Probleme, die ich mir nicht erklären kann.

Ich lade die Daten von Hand in das Grid, also ohne DataSource oder dergleichen. RowCount wird zunächst auf 0 (beschleunigt das Löschen vieler Zeilen enorm!) und dann auf die gewünschte Zeilenanzahl gesetzt, danach werden die Inhalte aller Zellen aus Listen und Arrays eingetragen. In dieser Anwendung erfolgt keine weitere Zellformatierung außer der anfangs (für dieses Grid) global eingestellten (Dinge wie Wrap=true, AutoSize=AllCells und Inhaltausrichtung).

Wenn ich zum ersten Mal Daten in das DataGridView schreibe, geht es sehr schnell. 6500 Zeilen in 0,5 Sekunden, 450 Zeilen in < 0,05 s. Alles kein Problem. Aber sobald das Grid dann einmal auf dem Bildschirm angezeigt wurde, dauert alles extrem lange. Für dieselben 450 Zeilen braucht es dann 12 Sekunden! Alle bekannten Tricks mit Hide/Show und SuspendLayout/ResumeLayout helfen nicht weiter. Ich verfüge nicht über Profiling-Werkzeuge, mit denen ich die genaue Quelle der Verzögerung suchen könnte.

Kennt jemand dieses Problem und weiß, wie man es lösen kann? Die anderen Lösungen, die ich hier im Forum gefunden habe, waren entweder nicht anwendbar oder haben SourceGrid empfohlen, das ich vorerst noch vermeiden wollte.

&quot; ist keine in XML integrierte Entität, die gehört zu HTML. Du kannst also einfach &quot; durch " oder &#x22; ersetzen, dann müsste es gehen. &quot; dagegen bedingungslos durch " zu ersetzen, kann dagegen zu Problemen führen.

Könnte auch sein, dass Strg+C usw. nicht als InputKey behandelt werden und deshalb nicht im KeyDown-Ereignis ankommen. Du kannst TextBox.IsInputKey überschreiben, um dieses Verhalten zu beeinflussen. Näheres dazu weiß die MSDN-Dokumentation.

Der Windows-Taskplaner kann genau das. Der startet ein Programm zu einer festgelegten Uhrzeit und kann den Rechner dazu auch aufwecken. Nur das Ausschalten erfordert einen zweiten Task, aber den kann man ja auch mit dem Taskplaner anlegen. PowerOff bietet sich für diese StandBy-Automatisierung an.

Wie man das ganze jetzt aber aus C# heraus steuert, weiß ich nicht auswendig. Vielleicht gibt's ja ein Task Scheduler API oder sowas.

0 dürfte wohl kein Handle sein, sondern ein Fehlercode, nehm ich an. Das sollte in der MSDN-Bibliothek aber beschrieben sein. Es gab glaub ich noch andere Fälle, in denen GetForegroundWindow nichts zurückliefert. Ich würde insbesondere mal mit Konsolenfenstern testen, ob das sinnvolle Werte rauskommen.

Ich habe Code, der erkennt, ob der Desktop gerade gesperrt ist. Vielleicht verhält der sich mit dem Secure Desktop ähnlich, ein gesperrter Desktop unter XP ist ja auch nichts anderes.

C++-Code:

bool CBehindTheWindowsDlg::isDesktopLocked(LPTSTR desktopName)
{
	bool isNowLocked = false;

	HDESK hDesktop = OpenDesktop(desktopName, 0, FALSE, DESKTOP_SWITCHDESKTOP);
	if (hDesktop)
	{
		isNowLocked = (SwitchDesktop(hDesktop) == FALSE);
		CloseDesktop(hDesktop);
		hDesktop = NULL;
	}

	return isNowLocked;
}

bool CBehindTheWindowsDlg::isWorkstationLocked()
{
	return isDesktopLocked(TEXT("default"));
}

Insgesamt glaube ich, dass du mit WinAPI-Funktionen hier weiter kommst, als mit .NET. Und WinAPI-Funktionen lassen sich in .NET- und VB6-Anwendungen gleichermaßen verwenden, sodass du für VB6 auch eine Lösung finden solltest - falls es die gibt.

Wir haben jetzt seit Jahren 1&1 DSL (zusätzlich zum T-Com-ISDN). Technisch gesehen gab's eigentlich keine Probleme mit dem Anschluss. Früher war es nicht immer stabil, aber zu uns ist die Leitung eben etwas länger... In letzter Zeit hat sich das aber gebessert. Allerdings bietet 1&1 Bestandskunden keine Tarifverbesserungen an. In der Vergangenheit kam es öfter mal vor, dass die Flatrate günstiger wurde. Bestandskunden wurde diese Anpassung erst nach Monaten in Aussicht gestellt, möglich war sie manchmal aber trotzdem nicht. Nur ein einziges Mal haben wir den Tarif aktualisiert, wobei allerdings auch gleich eine neue FritzBox WLAN rausgesprungen ist. 🙂

Wir wollten eigentlich Anfang des Jahres zur T-Com wechseln, da die ein interessantes All-in-One-Flatrate-Angebot gestartet hatten. Leider konnte man uns keine verlässlichen Aussagen zum Zeitrahmen der Umstellung machen. Letztlich wurden wir in einem T-Punkt vor Offline-Zeiten von mehreren Wochen gewarnt, woraufhin wir die 1&1-Kündigung widerrufen haben. Ein entsprechend böser Brief an den Telekom-Vorstand wurde nach mehreren Monaten beantwortet, mit dem Hinweis, dass solche Verzögerungen doch auf keinen Fall vorkommen dürften. Ah ja.

Jetzt wechseln wir zu Nefkom/M-Net, nachdem die endlich in unserem Ort verfügbar sind. Bislang hab ich auch in anderen Diskussionen dieser Art nur Gutes über den Laden gehört. Mal sehen, ob das auch stimmt. Momentan wurde die Umstellung wegen technischer Probleme von Anfang August auf Mitte September verschoben. Vielleicht liegt's dadran, dass jetzt viele wechseln wollen. 😉 Zudem bekommen wir dort statt 768/128 immerhin nen 3000/512er Anschluss für insgesamt weniger Geld!

(Interessant ist, dass wir in den letzten Wochen vermehrt von der T-Com angerufen und gefragt wurden, ob wir die neuesten Angebote schon kennen oder ob man bei uns noch etwas optimieren könnte. Von der Kündigung haben die scheinbar noch nichts mitbekommen. Auch rufen die gerne auf Nebennummern des Anschlusses an. Naja, das wird auch wieder aufhören.)

Original von apid0x
Ach du meine.... wie schafft man es seinen Desktop so vollzubekommen

copy "%userprofile%\Eigene Dateien*" "%userprofile%\Desktop&quot;

Naja, ich bastel grad an einem SQLite-Werkzeug, das auch bereits kennwortgeschützte SQLite-Datenbanken unterstützt. Ist aber noch nicht fertig. Daten können nur angezeigt aber nicht in der Tabelle verändert werden und die Manipulation des Datenschemas ist auch nur sehr rudimentär.

Abgesehen davon kommt die Verschlüsselung glaube ich auch auf die Implementierung an. SQLite.NET hat das glaub ich selbst implementiert, andere Programme können inkompatibel dazu sein. Sollte es da doch einen Standard geben, bitte ich um Korrektur.

Original von LukeGee
Wo hast du das Wallpaper her? Gefällt mir....

Die Datei heißt "Grass_Rainstorm_1600.jpg", da findet Google was zu. Weiß nicht, ob das die Quelle ist, wo ich es her hatte, kann schon sein.

Original von regen
Optimal währen natürlich 1920 und das 2x 🙂
oder sogar noch mehr.

So wie in der einen IBM-Werbung in der c't, wo jeder mindestens 50 Bildschirme und 20 Tastaturen an seinem Schreibtisch montiert hat und der Techniker mit seinem Einkaufswagen voller Bildschirme und Halterungen durch's Büro fährt. 😁 (Ich find grad keine URL zum Bild.) Ach ja, IBM-Werbungen sind immer noch die besten...

Ähm ja, wenn es dir nur darum geht, Winkel zwischen Grad/Minute/Sekunde und der Grad-Dezimal-Darstellung zu konvertieren, hat das nicht speziell was mit Geo[=Erde]-irgendwas zu tun, sondern ist stinknormale Winkelgeometrie und in jedem besseren Lexikon beschrieben. (Siehe ein Posting weiter oben.)

Ich hab in der Arbeit jetzt nen 18" (5:4), das ist besser als der 15" (4:3) vorher. Grade für Visual Studio ist XGA-Auflösung einfach zu klein. Der Azubi am PC nebenan hat allerdings zum vorhandenen 15" nur noch einen zusätzlich bekommen, also 2x 15". Und mich würd das ja so nerven, dass man Fenster immer noch nur so klein hat. Diese Bildschirmgrenze in der Mitte ist für so viele Dinge im Weg, Bildbearbeitung oder umfangreiche Webseiten sind nur 2 davon.

Ich hab hier daheim seit einiger Zeit einen 17" (5:4), der den 15" abgelöst hat. Eigentlich reicht die SXGA-Auflösung für die meisten Anwendungen gut aus. Aber da ich mir noch nicht sicher bin, ob ich meinen Fernseher* durch den PC-Bildschirm ersetzen will, schau ich immer schon auf die größeren TFTs. Da käme irgendwas zwischen 24 und 27" in Frage, die mit Full-HD-Auflösung und Widescreen gut für Videos sowie Bildbearbeitung und eigentlich auch so ziemlich alles andere (außer regelmäßigem Transport) geeignet sind.

Wer mehr Bildfläche braucht, will einen größeren Monitor haben, das ist klar. Aber je größer der Monitor wird, desto höher wird er wohl auch. Gerade bei der aktuellen TFT-Technologie ist aber die vertikale Farbstabilität so ein Haken: Bei Notebooks kann man besonders gut erkennen, dass die Farben heller werden, wenn man von oben draufschaut. Da mit steigender Höhe auch der Blickwinkelunterschied zunimmt, was zu unerwünschten Farbverläufen kommen kann, würde ich bei größeren Formaten ausschließlich Widescreen-Monitore empfehlen. Auch fällt es vielleicht einfacher, den Kopf nach links und rechts zu drehen, als hoch und runter zu schauen.

Falls in dieser Diskussionsrunde jemand mit den Bildschirmauflösungen rumrechnen möchte, hab ich da was passendes. 🙂http://beta.unclassified.de/projekte/displayresolution/

*) 16:9-Röhrenfernseher sind heute eigentlich sehr weit verbreitet, zumindest bei den CRT-Neugeräten. Und fast jede Grafikkarte hat zudem einen TV-Ausgang. Aber dass vielleicht mal irgend jemand dafür sorgt, dass man diese beiden Geräte auch sinnvoll miteinander verbinden kann? Da nur 4:3-Auflösungen unterstützt werden, kann man die Sache ja praktisch vergessen. Mein nVidia-Treiber weigert sich jedenfalls äußerst effektiv, 1024*576 einzustellen und gleichzeitig ein Bild auszugeben.

Der Internet Explorer zeichnet sich ja unter anderem durch diese grandiose Unterstützung von ActiveX-Programmen aus. Und nun gibt es da ja eine ActiveX-Version des Mozilla-Browsers... Naja, hat es schonmal jemand geschafft, das Mozilla-ActiveX im Internet Explorer zum Laufen zu bekommen? (Sozusagen IETab andersherum.) Dann könnte man endlich auch den letzten technophoben Menschen zeigen, wie schön die eigene Homepage tatsächlich ist! 😁

Ich hab immer ganz gern was zum Rausschauen auf meinem Desktop. Wenn ich ihn mal zu sehen kriege unter all den großen Fenstern, ist das auch ganz angenehm. Ich hab noch einige Landschaftsaufnahmen in meiner Sammlung (die meisten im Internet gefunden, ein paar selbst fotografiert), aber das Bild hier hab ich jetzt schon einige Zeit eingestellt.

Ansonsten ist mir das ganze Getheme unter XP irgendwie zu blöd. Es gibt einfach zu viele Anwendungen, die dabei noch hässlicher aussehen, als sie das im Classic-Design schon tun, also lass ich es lieber. Wie man vielleicht erkennen kann, mag ich's eher schlicht, die meisten Linien sind bereits aus der Taskleiste verschwunden. Sieht gleich viel übersichtlicher aus. 🙂

Der Desktop ist manchmal auch Zwischenlagerplatz für Dateien und auf die Schnelle aus dem Browser rausgezogene URLs. Wenn's zuviel wird, muss ich die URLs dann mal durchlesen oder in meine Lesezeichen einsortieren. Die heruntergeladenen Dateien landen aber alle in der "inbox", sonst wäre auf dem Desktop kein Platz mehr... Programme starte ich i.d.R. mit Launchy, mein Startmenü/Programme sieht dementsprechend verwildert aus.

(Die Größenbeschränkung auf 256 kB macht das Bild leider nicht gerade besser. JPEG2000, anyone?)

Ich hätte ja so gerne einen 27"-Bildschirm, der würde dann auch gleich als Fernseher taugen. (Besser als der 17" jetzt.) Aber für meinen alten Fernseher und den TFT hier krieg ich halt noch keinen neuen...

Original von egrath
/PS: Das ClearType von WPF hat nichts mit dem ClearType von Windows zu tun. Es wird ein eigener neuer Algorithmus und eine eigene Implementierung verwendet die von vielen Seiten Kritik eingefangen hat (da nicht die gleiche Qualität wie die Windows interne)

Scheinbar gibt's davon auch wieder mehrere Varianten. In den Anwendungen, die ich mit der Orcas beta schnell zusammengehackt hab, ist mir kein Unterschied zum XP-ClearType aufgefallen. Aber das Eigenschaften-Fenster (u.a.) im Orcas selbst sehen in der Tat sehr hässlich bis unleserlich aus.

Original von egrath
einen der grössten Nachteile von WPF (welcher auch meine negative Einstellung dazu erklärt) ist die Tatsache, dass es nicht möglich ist das ClearType-Antialising von Grafischen Komponenten abzuschalten - das alleine ist meines erachtens ein derzeitiges K.O. Kriterium für die ganze Sache.

Für dich vielleicht. Es soll aber auch Leute geben, die dieses Feature voller Freude seit Anbeginn von Windows XP verwenden, und dann soll es auch Leute geben, denen das völlig Wurscht ist, weil sie eh keinen Unterschied bemerken. Und irgendwo kann man bestimmt auch die Art des Text-/Grafik-Antialiasings beeinflussen. Den ClearType Tuner gab's auch nicht gleich zu Beginn.

Original von Noodles
Vista hat wohl eher eine sehr schlechte Verbeitung, was Unternehmen/Behörden usw. angeht.

Ach, das ändert sich in ein paar Jahren sicherlich auch, wenn der Vista-Nachfolger wieder x-mal verschoben wird... 😉

Original von Golo
Zulässige Attribute: Wird derzeit nicht geprüft. De facto sind sogar die Attributnamen egal, alles was zählt, ist die Reihenfolge.

Attributnamen? Sowas gibt's in "BBCode" doch gar nicht. Reihenfolge ich dann klar wichtig und das folgende ergibt sich automatisch.

Optionale Attribute: Werden derzeit nicht unterstützt.

Automatische Umsetzung: Derzeit nicht enthalten, sind ja keine BBCodes 😉.

Doch, das ist wichtig! In bestimmten Bereichen (z.B. dem Attribut des URL-Tags) dürfen nämlich nicht noch automatisch URLs übersetzt werden und in [ code]-Bereichen sollte man besser überhaupt keine Ersetzungen machen, die neue Elemente (wie Icons) einfügen oder Eingabezeichen aufessen (wie Kurzschreibweisen von Formatierungen).

Noch ein Hinweis: In HTML hat man es sich wegen der guten Lesbarkeit angeeignet, die Tags für Blockbereiche, wie <p> oder <blockquote> in eine eigene Zeile zu schreiben. Manche BBCode-Parser (allen voren der in diesem WBB2 verbaute) scheinen aber jedes einzelne Whitespace groß und breit in die Ausgabe zu übernehmen. Wenn man nach dem [/code] da nicht unmittelbar mit dem Text anfängt, riskiert man mehrere Leerzeilen. So wird es nur eine (!).

So ein BBCode-Parser ist eine sehr komplexe Angelegenheit, wenn man es richtig machen will. Viele damals vorhandene Systeme sind z.B. mit mehrfach geschachtelten Tags absolut nicht klargekommen und haben nachher alles durcheinander geworfen. (Einfaches Regex.Replace bzw. preg_replace tut es bei weitem nicht!) Das hab ich schon gemerkt, als ich vor vielen Jahren für mein PHP-Webforum einen eigenen BBCode-Parser geschrieben hab. Jetzt werden falsch geschachtelte Tags aber auch genau markiert. Das Syntax-Highlighting hab ich dabei übrigens aus einer externen Bibliothek "eingekauft". (Für zukünftige Entwicklungen werde ich von BBCode aber wieder Abstand nehmen... aber das tut in diesem Thread ja nichts zur Sache.)

Zeig doch mal Beispiele.

Folgender Code-Ausschnitt stammt aus meiner POP3-Client-Klasse, ist unvollständig, aber im Prinzip getestet und stabil. Sollte er während der Ausführung hängen bleiben, könnte die Kaspersky-Firewall dafür veranwortlich sein (bei mir blockiert sie .NET-ausgehandelte IMAP-TLS-Verbindungen 😦).

using System.Net.Security;
using System.Security;
using System.Security.Authentication;
using System.Security.Cryptography;
// Vielleicht fehlen noch welche

namespace...
{
	class ...
	{
		TcpClient tcpClient = null;
		Stream netStream = null;

		private void ConnectSocket(string host, int port)
		{
			// Open a raw TCP connection to that port
			try
			{
				tcpClient = new TcpClient(host, port);
			}
			catch (SocketException)
			{
				return;
			}
			netStream = tcpClient.GetStream();

			// Wait for the greeting server response
			string response = ProcessResponse();
			if (IsResponseOk(response))
			{
				sessionState = SessionState.Authorization;
				greetingMessage = response;
			}
			else
			{
				// Something went wrong
				Disconnect(false);
			}
		}

		private void StartTLS()
		{
			// We desire encryption and the server advertises TLS capability, now try to use it
			SendLine("STLS");
			string response = ProcessResponse();
			if (IsResponseOk(response))
			{
				// TLS command was accepted, negotiate TLS
				netStream = new SslStream(tcpClient.GetStream(), false, CheckTlsCertificate);
				(netStream as SslStream).AuthenticateAsClient(host,
					null,
					SslProtocols.Tls,
					false);
				// From now on we're using an encrypted TLS connection
				return;
			}
			else
			{
				// Server doesn't want to TLS although advertised
				throw new NotSupportedException("Server does not support encryption");
			}
		}

		private bool CheckTlsCertificate(Object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
		{
			// TODO: check server certificate
			return true;   // always accept for now
		}

		// Weitere Methoden, wie SendLine, ProcessResponse, etc.
	}
}

Ich vermisse noch ein paar gute Tutorials, die einem WPF nahebringen. Hab aber noch nicht sehr gut gesucht. Bislang hab ich eine 4-teilige MSDN-Webcast-Reihe von Dirk Primbs gefunden, der das mit Folien und recht holprigen Demos live zeigt. Die Videos sind aber alt und berücksichtigen Orcas noch nicht. Was ich bei einem kurzen Test mit Orcas beta 1 und 2 gesehen hab, hat mich noch nicht überzeugt. Aber ich habe bereits ein Software-Projekt dafür vorgesehen, WPF-Erfahrungen zu sammeln.

Vista sollte ja soviel haben und können, aber übrig geblieben ist fast nichts davon. Die GUI ist immer noch so wie früher (okay, bissl unübersichtliche 3D-Spielerei, aber die Dialoge sind größtenteils unverändert). Vielleicht hat Microsoft das zumindest intern erkannt und arbeitet jetzt mit mehr Energie am Vista-Nachfolger. Denn ein Nachfolger für Windows Forms wäre technisch angebracht und WPF (nach Primbs' Folien) macht dafür einen guten Eindruck - zumindest theoretisch.

Pack doch mal alles in eine Transaktion rein, vielleicht hilft das. Üblicherweise sollten alle Integritätsprüfungen erst beim Commiten der Transaktion geprüft werden. Also das hier ganz an den Anfang der Datei:
BEGIN TRANSACTION;
und das ans Ende:
COMMIT;
und sicherstellen, dass die beiden nirgendwo sonst vorkommen.

Das ist die ganz normale System.Windows.Forms.ListView, die man im Designer einsetzen kann. Außerdem wird der Event-Handler bereits im Designer festgelegt. Kann ich den zur Laufzeit vorübergehend deaktivieren, ohne die halbe Oberfläche zur Laufzeit ständig neu einrichten zu müssen?

Es hat übrigens nicht geholfen, die ListView während dem Ändern der Checked-Eigenschaft eines Items zu deaktivieren (Enabled = false) oder zu verstecken (Visible = false), in beiden Fällen wurden die Events trotzdem ausgelöst.

Übrigens ist das Verhalten bei einem Doppelklick auf die CheckBox auch sehr irritierend: Beim ersten Klick wird das Ereignis ausgelöst. Beim zweiten Klick in Folge wird das Ereignis zweimal ausgelöst: einmal mit dem neuen Wert und dann sofort nochmal mit dem alten Wert, um praktisch die Folgen des zweiten Klicks direkt wieder umzukehren. Das Ergebnis ist das Ignorieren des Doppelklick, aber auf Anwendungen, die jede Änderung des Checked beobachten, hat das verwirrende Auswirkungen, da sie mit unsinnigen Events überhäuft werden. Interessant ist auch, dass das ItemChecked-Event durchaus mal ohne jede Event-Informationen aufgerufen wird. e.Item ist dann einfach null und mangels weiterer Daten ist das Event damit völlig unbrauchbar. Ich sag ja: kaputt. Sollte meine eigene CheckedListBox implementieren... Mit mehreren Spalten usw...

Kann irgendwie nicht sein. Die Reihenfolge der Debug-Ausgaben deckt sich in etwa mit meinen Beobachtungen im restlichen Programmablauf. Zuerst wird die Liste gefüllt, und wenn diese Methode durch ist, werden der Reihe nach die ganzen Events geworfen. Auch beim Einzelschritt-Debuggen werde ich nicht sofort beim Ändern der Eigenschaft in den Event-Handler gebracht, das passiert erst später. Die Thread-ID ist übrigens überall gleich.

Durch einiges wahlfreies Rumbasteln und Ausprobieren hab ich die Anwendung jetzt zwar halbwegs gut am Laufen, aber ich verstehe nicht, warum es so ist, und schön ist es auch nicht. Irgendwie ist diese ListView ziemlich kaputt. (Kennt man ja schon vom TreeView...)

Hi,

ich hab in meiner Anwendung eine ListView verbaut, bei der CheckBoxes angezeigt werden. Diese Liste wird beim Programmstart oder auch später durch Code mit Inhalten gefüllt. Dazu gehört auch, dass das Häkchen gesetzt oder entfernt wird. Gleichzeitig reagiert das Programm darauf, wenn der Benutzer das Kästchen ankreuzt, dann werden nämlich Daten verändert und gespeichert.

Das Problem, das ich jetzt habe, ist dass beim Füllen der Liste mehrmals das ItemChecked-Ereignis geworfen wird, und das auch noch mit wechselnden Daten. Einmal sagt es, das Item wäre gecheckt, dann wieder nicht. Dabei hat der Benutzer das Kästchen gar nicht angefasst.

Prinzipiell würde man jetzt während dem Füllen der Liste eine Zustandsvariable setzen, die das Verarbeiten des Event-Handlers verhindert. Leider ist die ListView von der ganz hinterlistigen Sorte und wirft dieses Event asynchron. Zu dem Zeitpunkt, wenn das Event geworfen wird, ist das Füllen der Liste also schon wieder vorbei und niemand weiß mehr, warum das Event aufgerufen wird.

Ich brauche jetzt eine Möglichkeit, dafür zu sorgen, dass der Event-Handler ausschließlich dann aufgerufen wird, wenn der Benutzer etwas tut und nicht auch durch das Programm selbst.

Eine Zeitverzögerung will ich nicht verwenden (also nur ungern), da ich nicht weiß, wieviel Zeit sich die ListView mit dem Aufrufen der Ereignisse lässt und daher schnell folgende Benutzeraktionen ignoriert werden können.

Hat sich erledigt.

Der Typ, den ich da übergeben wollte, besteht nur aus öffentlichen Feldern. Daher hab ich ihn nicht mehr von MarshalByRefObject erben lassen (dessen Dokumentation mich auf die Idee gebracht hat). Nach dem nächsten Stups hab ich ihn dann auch als Serializable markiert und nun läuft die Sache. Wunderbar, Remoting, das mal funktioniert. 🙂

Hi,

ich unternehme gerade meine ersten Schritte mit .NET-Remoting zwischen einem Windows-Dienst und einer Client-Anwendung, alles auf dem selben PC. Das Remoting brauche ich, da der Client nicht auf die Dateien des NetworkService-Accounts zugreifen kann/können soll. Jetzt hab ich Rainbirds RemotingHelper-Klasse hier verbaut und dank dem veröffentlichten Patch mit dem „channelSettings["port"] = 0“ kann ich auch Methoden aufrufen, sonst ging da nichts. Leider kommt mir jetzt bei einem Aufruf (nicht dem ersten) folgende Exception entgegen geflogen:

InvalidOperationException
"Es wurde versucht, die Adresse eines Werttyp-Feldes für ein remotes Objekt zu berechnen. Dies wurde wahrscheinlich durch den Versuch verursacht, den Wert eines Feldes direkt in diesem eingebetteten Werttyp abzurufen oder festzulegen. Dies sollte vermieden werden. Sie sollten Methoden für alle Felder im Objekt, auf die remote zugegriffen wird, vorgeben und verwenden."

Das passiert beim Aufruf einer Methode, die als Argument ein Objekt annimmt, das ein paar öffentliche Felder enthält. Das Objekt dient nur der Speicherung strukturierter Daten und kann weiter nichts. Hat das was mit dem Fehler zu tun? Was bedeutet diese Meldung überhaupt? Google hat die leider auch noch nicht gesehen. Muss neu sein...

  
a=b ? lalala:tralala;  
  

tralala wird nie ausgeführt. Weißt du auch warum? 😉

Original von Wax
werden die Entities denn schon beim einlesen umgewandelt, oder erst beim schreiben?

Das wird man wohl nicht so einfach rausfinden können, da die XML-Datei beim Einlesen wohl in einer internen Datenstruktur gespeichert wird, die nicht mit der gespeicherten Darstellung vergleichbar ist.

Das Event befindet sich wahrscheinlich in der Microsoft.Win32.SystemEvents-Klasse und heißt PowerModeChanged. Hab's aber nicht getestet.

[Unmanaged-Alternative] Ansonsten kann man auch die Nachricht WM_POWERBROADCAST prüfen und nach den wParam-Werten PBT_APMSUSPEND, PBT_APMRESUMEAUTOMATIC, PBT_APMRESUMESUSPEND und PBT_APMRESUMECRITICAL unterscheiden.

Zum ❔-Operator hat mir vor Jahren ein Arbeitskollege mal gesagt, ich sollte das besser nicht verwenden (weiß nicht, ob das damals noch in C++ war - gab's den da auch schon?), weil ihn viele nicht kennen und den Code dann nicht verstehen würden. Find ich ein doofes Argument, dann sollen sie die Sprache halt besser lernen. Ist ja alles übersichtlich dokumentiert. Wo diese Abkürzungen die Lesbarkeit verbessern, also insbesondere bei kurzen Ausdrücken von max. einer halben Zeile, verwende ich sie gerne. Wenn man mehrere Zeilen dafür braucht, ist ein if u.U. doch besser geeignet.

Huch, nein, den kannte ich noch nicht. Vor langer Zeit hab ich mir mal die Schlüsselwort-Liste für C# vorgenommen und alle Schlüsselwörter genau erforscht. Aber an Operatoren hab ich da nicht gedacht. 😉

M3U-Dateien enthalten einen Dateinamen pro Zeile. Vorzugsweise mit relativen Pfaden zur M3U-Datei. Aber geh doch mal in Winamp, zieh ein paar Lieder rein und speicher die Liste, dann siehtst du, wie das erweiterte Format aussieht. Ist wirklich keine Zauberei.

Hey, das hört sich stellenweise sehr vertraut an! 🙂 Ich habe hier auch ein paar Pläne für einen Musik-Player rumliegen. Allerdings habe ich etwas andere Anforderungen und wollte daher andere Technik verwenden. Zuerst hab ich an eine normale Desktop-Anwendung gedacht, also für PCs. Naja, nicht so ganz normal, sondern etwas, das zur 1ft- und zur 10ft-"Experience" passt, also teilweise auch aus größerer Entfernung ablesbar ist, wie bei einem Fernseher (à la Media Center / eHome). Die Wiedergabe könnte ein bisschen wie in meinem WinampPresenter im Vollbild aussehen. Da ich meine Musik auf dem Notebook komprimiert abgelegt habe und sich dafür das AAC-HE-Format (AACplus v.2 mit 64 kbit/s) gut eignet, brauche ich natürlich auch was, das diese Dateien abspielen kann. Außer Winamp ist mir leider nichts bekannt. An einer Code-Lizensierung ist man bei Coding Technologies scheinbar nicht interessiert. Außerdem hat Winamp immerhin ein bisschen Cross-Track-Fading, besser als gar keins. Und so habe ich vor, mir win gekidnapptes Winamp einzuspannen. Die Anpassung des Programms und die Fernsteuerung klappen schon ganz gut.

Außerdem werde ich vermutlich dieses Projekt zum Studieren von WPF (Windows Presentation Foundation) hernehmen. Also geht meins doch in eine etwas andere Richtung. Was aber ähnlich ist, ist die automatische Auswahl der Musik. Ich will für alle Stücke Tags vergeben, die in einer einfachen hierarchischen Struktur definiert sind. Danach können die Musikstücke dann auch verglichen und ausgesucht werden.

Das mit dem Wechseln der Richtung beim Skippen hab ich mir genau so auch ausgemalt. 😉 Wobei es dabei auch einige Spezialbedingungen zu beachten gilt. Ich hab mir z.B. gedacht, dass ich Lieder beim schnellen Skippen oder vollständigen Hören negativ bzw. positiv bewerte. Wenn sich über eine lange Zeit nichts tut, soll das Gewicht der Bewertungen aber sinken, da der Benutzer schon lange verschwunden sein könnte und nicht mehr zuhört. Wenn mehrere Lieder übersprungen werden und die Richtung gewechselt wird, muss die negative Bewertung der Lieder nur mit der vorherigen Musikrichtung verbunden werden, denn dazu haben sie scheinbar nicht gepasst. Ein Löschen der negativen Bewertungen beim Richtungswechsel wäre auch zu erwägen, wenn man die Lieder nicht schlecht findet und sie zur Richtung passen, aber man sie jetzt eben einfach nicht hören will.

Naja, Speicherung der Daten in einer Datenbank (welche steht noch nicht fest, entweder SQLite oder was mehr ".NETtiges"), keine ID3-Tags (die mag ich nicht, passt auch nicht zur DB-Verwendung), Verwaltung vieler Playlists (z.B. für Alben) und Export von Playlists (z.B. für die MP3-CD fürs Auto). Ideen hab ich schon viele gesammelt, das Screen-Layout ist recht weit gereift. Die Technik ist da, fehlt nur noch die Zeit, tatsächlich eine Oberfläche dafür zu erstellen und all die netten Automatikfunktionen zu implementieren. 🙂

Ich suche Dateien auch bevorzugt an einer Stelle, auf die der Benutzer möglichst keinen Einfluss hat. Hier bietet sich der Registry-Schlüssel HKCR/FirefoxURL oder FirefoxHTML an, oder sowas wie HKLM/Software/Mozilla/Mozilla Firefox/{@CurrentVersion}/Main/PathToExe.

Außerdem heißt es "Safe Mode", nicht "Save Mode". Da wird niemand gerettet (a.k.a. gespeichert), sondern etwas sicher (abgesichert) ausgeführt. Oft hilft ein Wörterbuch, hier reicht schon richtig lesen. 😉

Original von MagicAndre1981

>

Jep, der funktioniert ganz ordentlich. Ist glaub ich auch der einzige (oder einer der sehr wenigen) brauchbaren SQLite-Wrapper für .NET.