Hallo,

falls es sich hierbei um eine App handelt, deren Quellcode du hast, könntest du per IPC über ein eigens definiertes Interface die App ansprechen.

Ansonsten bist du, so wie ich das sehe, schon mal auf dem richtigen Weg. Bezühlich Spy++ kann ich dir leider nichts über das Herausfinden der Handles sagen.

Hallo zusammen,

ich habe nach langer Zeit endlich wieder was, worauf ich im Netz nichts finden konnte.

Ich habe ein Objekt mit dem BinaryFormatter serialisiert.
Nun möchte ich dieses Objekt in ein anderes Objekt deserialisieren (migrieren).
Das ist mit dem SerializationBinder schonmal kein Problem, wenn die Properties der Objekte übereinstimmen.
Wenn die Properties jedoch abweichen, wird da ISerializable auf dem neuen Objekt nötig, um die Properties entsprechend zu übernehmen.

Jetzt zum Problem: Wenn ich ISerializable implementiere, kommt am Ende eine Null-Referenz anstelle des neuen Objekts raus. Wenn ich das Interface weglasse, funktioniert alles - bis auf die Properties, die nicht gefüllt sind, weil sie sich im Namen vom alten Objekt unterscheiden.

Deserialisung

public Car Deserialize(Stream stream)
{
    stream.Position = 0;

    var f = new BinaryFormatter();
    f.Binder = new VehicleToCarBinder();
    return (Car)f.Deserialize(stream);
}

VehicleToCarBinder

public class VehicleToCarBinder : SerializationBinder
{
    public override Type BindToType(string assemblyName, string typeName)
    {
        if (typeName == typeof(Vehicle).FullName)
            return typeof(Car);

        if (typeName == typeof(List<Namespace1.Wheel>).FullName)
            return typeof(List<Namespace2.Wheel>);

        if (typeName == typeof(Namespace1.Wheel).FullName)
            return typeof(Namespace2.Wheel);

        return null;
    }
}

Betroffenes (neues) Objekt

namespace Namespace2
{
    [Serializable]
    public class Wheel// : ISerializable // <-- Interface auskommentieren: Unit-Test funktioniert (logischerweise ohne Property-Werte)
    {
        public Wheel()
        {
        }

        protected Wheel(SerializationInfo info, StreamingContext context)
        {
            Inches = (int)info.GetValue("<Size>k__BackingField", typeof(int));
        }

        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("<Size>k__BackingField", Inches);
        }

        public int Inches { get; set; }
        public string Type { get; set; }
    }
}

Der Test

[TestMethod]
public void SerializeVehicle()
{
    var vehicle = new Vehicle();
    vehicle.Wheels.Add(new Wheel { Size = 15, Type = "Soft" });
    vehicle.Wheels.Add(new Wheel { Size = 15, Type = "Hard" });

    var serializer = new VehicleSerializer();
    var stream = serializer.Serialize(vehicle);

    var car = serializer.Deserialize(stream);

    Assert.IsNotNull(car.Wheels[0]);
    Assert.IsNotNull(car.Wheels[1]);

    Assert.AreEqual(vehicle.Wheels[0].Type, car.Wheels[0].Type);

    // Die letzten beiden Tests sollten am Ende auch funktionieren

    //Assert.AreEqual(vehicle.Wheels[0].Size, car.Wheels[0].Inches);
    //Assert.AreEqual(vehicle.Wheels[1].Size, car.Wheels[1].Inches);
}

Anbei ist das Ganze als lauffähige Solution angehängt.

Ich hoffe, jemand stand schonmal vor dieser Problematik.

Danke euch

Zum Speicherverbrauch:
Bei vielen Einträgen stößt man halt mit der ListView an ihre Grenzen. Entweder würde ich die ListView pagen oder es mit dem DataGridView probieren, sollte grundsätzlich Speicherschonender sein.

Vermutlich steht der SelectionMode nicht auf Cell (oder so ähnlich)?
Weiß jetzt gerade nicht die korrekten Properties, aber in die Richtung könnte es gehen.

"Windows 8 Apps benötigen neue Windows Runtime"

Hat das jemand eigentlich mitbekommen?

Es bezieht sich zwar fürs erste auf Windows 8 Metro Apps, aber es sieht nach einer klaren Marschrichtung aus:

Windows 8 Apps benötigen neue Windows Runtime: .NET neu erfunden in Native Code und COM

Ich hätte dazu eine Idee, die Umsetzung der Bitte zu pushen.

Man sollte die Hilfesuchenden doch auch einfach mal fragen (nicht rügen), was aus ihrem Problem geworden ist und warum die (evtl.) Treffer nicht gepostet wurden.
Es könnte nämlich auch gut sein, dass man in der Zwischenzeit das Problem anderweitig gelöst hat (von selbst, Google).

Die Idee, das Ganze zu pushen, liegt darin, geöffnete Threads als [ungelöst] zu markieren. Und der User diese als [gelöst] markieren kann, sobald er eine Lösung hat. Natürlich unter der sinnvollen Voraussetzung, dass er ebenso die Lösung postet.

Was ich auch nicht schlecht finde, ist die Markierung eines Posts als "most helpful/best answer" und z.B. direkt unter dem Eingangspost gepinned ist.

Ich denke einfach nur, dass das den Hilfesuchenden mehr motiviert, den Thread qualitativ und im Sinne der Community zu gestalten. Ich empfinde es als "unangenehm" wenn der Thread mit ner dicken roten Schrift vorangestellt ist, und wenn ich doch eine Lösung für mein Problem habe, dann lasse ich die rote Schrift verschwinden und bin zufrieden.

Inspiriert aus diesem Forum: http://www.sencha.com/forum/forumdisplay.php?87-Ext-Q-amp-A

Was dort etwas "krass" ist - wie ich finde, aber vielleicht akzeptabel - dass man als Threadersteller eine PN bekommt, sobald eine Antwort verfasst wurde und man prüfen soll, ob das die Lösung war, um dann den Thread als gelöst und die beste Antwort zu markieren.

Bei Windows-Controls ist das etwas schwerer mit dem Zeichnen.
Du könntest viel eher versuchen, WM_PAINT (Stichwort: P/Invoke) zu behandeln und dort deine Zeichenroutine versuchen.
Aber das ist alles wieder so experimentell, erst recht deine Idee, die Methode technisch zu Überschreiben.
Selbst wenn du sie überschreiben würdest, meines Wissens nach ist das Zeichnen zu dem Zeitpunkt bereits geschehen.

Die einzig wirkungsvolle Variante, einen System.Windows.Forms.Button vom Zeichnen abzuhalten, sehe ich nur in einem eigenen IMessageFilter, der WM_PAINT für Buttons dann einfach nicht behandelt. In etwa so:

if (m.Msg == WM_PAINT)
    return true;

Viel Spaß damit.

Du könntest höchtens noch versuchen, bei den vorhandenen Buttons das Paint-Event zu abbonieren

Das tut er doch bisher schon:

else if (c.GetType() == typeof(Button))
{
    Button b = (Button)c;

    // Hier -->
    b.Paint += new PaintEventHandler(delegate(object sender, PaintEventArgs e)
    {
        Pen blackPen = new Pen(Color.Black, 3);
        Rectangle rect = new Rectangle(0, 0, 200, 200);
        e.Graphics.DrawRectangle(blackPen, rect);
    });
}

Na du bist mir ein Held. Es ist ja immer noch ein Windows Forms Button!
Ihn in ButtonBase zu casten ändert doch gar nichts.

public class MyButton : ButtonBase
{
}

Edit: Beim Erstellen des Buttons schreibst du anstatt new Button() --> new MyButton()

und später dann:

else if (c.GetType() == typeof(MyButton))
{
    MyButton b = (MyButton)c;

    b.Paint += new PaintEventHandler(delegate(object sender, PaintEventArgs e)
    {
        Pen blackPen = new Pen(Color.Black, 3);
        Rectangle rect = new Rectangle(0, 0, 200, 200);
        e.Graphics.DrawRectangle(blackPen, rect);
    });
}

Wobei ich bei der Gelegenheit das dann eher so machen würde:

public class MyButton : ButtonBase
{
    public Skin Skin { get; set; }

    protected override void OnPaint(PaintEventArgs e)
    {
        this.Skin.Paint(this, e); // where Skin : ButtonSkin

        base.OnPaint(e);
    }
}

public abstract class Skin
{
    public void Paint(Control c, PaintEventArgs e)
    {
        this.Control = c;
        this.Graphics = e.Graphics;

        // BeforePaint();
        this.OnPaint();
        // AfterPaint();
    }

    protected abstract void OnPaint();
}

public class ButtonSkin : Skin
{
    // Abstract
    protected override void OnPaint()
    {
        Pen blackPen = new Pen(Color.Black, 3);
        Rectangle rect = new Rectangle(0, 0, 200, 200);
        this.Graphics.DrawRectangle(blackPen, rect);
    }
}

Zur Design-Zeit, ja.
Es geht ja gerade darum, dass du per Paint-Event den System.Windows.Forms.Button nicht groß beeinflussen kannst. Und ich meine, dass das mit ButtonBase zu bewerkstelligen sein müsste.

Ich glaube, dafür kannst du ButtonBase gut verwenden. Also erstelle dir eine Klasse, die davon ableitet.

Danke für die Info!
Kommt gerade recht. Sind schon am Planen, das TE Edit Control durch TXText Control zu ersetzen. Mal schauen, ob dafür die Express-Version ausreicht.

Hallo,

so ganz verstehe ich dein Problem jetzt nicht. Wenn du eine Klasse hast, die sich um das UDP Handling kümmert, ist es dir egal, ob die Start-Methode synchron oder asynchron ausgeführt wird.

class UDP
{
    public void Start(int port)
    {
        ThreadPool.QueueUserWorkItem(StartInternal, port);
    }

    private void StartInternal(object _port)
    {
        int port = (int)_port;
        // ...

        if (DeinEvent != null)
        {
            DeinEvent(this, EventArgs.Empty);
        }
    }

    public event EventHandler DeinEvent;
}

von außen aufgerufen:

UDP udp = new UDP();
udp.DeinEvent += DeinEventHandler;
udp.Start(5000);

void DeinEventHandler(object sender, EventArgs e) { }

Der Code ist mehr exemplarisch, sollte dir so jedoch veranschaulichend weiterhelfen.

Achso, war mir jetzt nicht klar, dass beim Late Binding der Aufruf nicht genauso erfolgt.

Die Methode heißt doch **set_**DefaultFilePath! Und ob da BindingFlags.SetProperty funktioniert, weiß ich nicht. Es ist immerhin eine Methode, die aufgerufen wird, und nicht ein Property.

IMHO:
Das liegt auch daran, dass "Windows" mittlerweile viel mehr ein eigenständiger Name ist, mit dem man einfach nur das Betriebssystem in Verbindung bringt, ohne dabei an die Fenster zu denken.

Daher denke ich, wird Windows als Name auch bleiben, sonst wäre ja der gewichtige Marktname zerstört. Außerdem soll ja Windows an sich im Unterbau erhalten bleiben 😃 Und wenn ich das richtig aufgefasst habe, sind die Tiles nur ein Aufsatz, gedacht als primäre Oberfläche.

Windows Tiles könnte ich mir von daher vielleicht als Name vorstellen.

Sehr gute Arbeit! Werde ich mir mal anschauen. Könnte das gut gebrauchen.

Du kannst doch die Bilder statisch in deiner Anwendung buffern. Da du ja die URL zu dem Bild hast, reicht doch ein simples <string, Image>Dictionary völlig aus, oder habe ich jetzt etwas übersehen?

Kann mich nicht genau vorstellen, was du genau machst? Sind das Vorschaubilder deiner Suchergebnisse, sind die Bilder immer gleich? Wieso werden diese immer neu geladen?

Sind wir jetzt im Web oder in Windows Forms?

Danke für eure Antworten.

Ich habe jetzt den Grund für meine Verwirrung gefunden.
Ich habe AddValueChanged in einigen Projekten benutzt, um ein Objekt zu überwachen, über das ich selbst nicht die Kontrolle habe. Und anscheinend werden die Properties auf dem Objekt mit SetValue gesetzt. Das war mir nicht bewusst.

Aber auslösen tust du das Event ja nie?!?

Du musst in den Setter den entsprechenden Code schreiben - sollte aber genügend Beispiele dazu geben.

Das Event will ich ja auch gar nicht selber auslösen. Das soll ja eben automatisch über den PropertyDescriptor mit AddValueChanged geschehen.

Verstehe ich eure Hinweise also richtig, für jedes Property ein -Changed Event bereitzustellen? Wo ist denn da noch der Mehrwert von AddValueChanged?
Ich bin mir auch mittlerweile nicht mehr sicher, ob wir noch von dem selben Problem sprechen..

Ich hab das bisher immer so gemacht, den PropertyDescriptor jedes Property's einer Klasse zu durchlaufen und in AddValueChanged eine stupide Methode zu hinterlegen, die aufgerufen wird, sobald sich irgendein Property-Wert ändert, was aber nicht passiert.

Aber soweit erstmal Danke für eure Antworten.

bezüglich VS Express: Hat damit absolut gar nichts zu tun, da das ja nen Thema der Runtime und nicht der IDE ist.

Ich weiß 😃 Das sind aber diese Momente wo ich anfange, alles in Erwägung zu ziehen 😃

Das mit dem Interface habe ich schon drin gehabt, hab das im Post nur ausgelassen.
Habe jetzt nochmal ein neues Sample gemacht. Sowohl Interface implementiert, als auch EventHandler ValueChanged zusätzlich bereitgestellt:

class Program
{
    static void Main(string[] args)
    {
        var i = new MyClass();
        i.ValueChanged += new EventHandler(i_ValueChanged);
        i.PropertyChanged += new PropertyChangedEventHandler(i_PropertyChanged);
        i.Property = "test";

        Console.ReadLine();
    }

    static void i_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        Console.WriteLine("Property value changed");
    }

    static void i_ValueChanged(object sender, EventArgs e)
    {
        Console.WriteLine("Property value changed");
    }
}

public class MyClass : INotifyPropertyChanged
{
    public MyClass()
    {
        foreach (PropertyDescriptor pd in TypeDescriptor.GetProperties(this))
        {
            pd.AddValueChanged(this, this.OnValueChanged);
        }
    }

    private void OnValueChanged(object sender, EventArgs e)
    {
        if (this.ValueChanged != null)
        {
            this.ValueChanged(this, new PropertyChangedEventArgs(""));
        }

        if (this.PropertyChanged != null)
        {
            this.PropertyChanged(this, new PropertyChangedEventArgs(""));
        }
    }

    public event EventHandler ValueChanged;

    #region INotifyPropertyChanged implementation
    public event PropertyChangedEventHandler PropertyChanged;
    #endregion

    public string Property { get; set; }
}

Hallo,

ich bin am Verzweifeln. Ich hab das schon 1000 mal gemacht, und heute Nacht ging das auch noch.
Jetzt nicht mehr. Und zwar folgendes:

Der Bequemlichkeit halber will ich Property-Änderungen dynamisch überwachen:

foreach (PropertyDescriptor pd in TypeDescriptor.GetProperties(this))
{
    pd.AddValueChanged(this, this.OnPropertyValueChanged);
}
// ...
private void OnPropertyValueChanged(object sender, EventArgs e)
{
}

An sich nichts spektakuläres. Der übergebene Handler in AddValueChanged wird nie aufgerufen, wenn sich ein Property-Wert ändert. Vielleicht seh ich gerade auch den Wald vor lauter Bäumen nicht. Aber ich kann keinen Fehler entdecken.

Hier die vollständige Test-Klasse, mit der es (bei mir) nicht funktioniert:

public class Class1
{
    public void Test()
    {
        this.Value = 0;

        foreach (PropertyDescriptor pd in TypeDescriptor.GetProperties(this))
        {
            pd.AddValueChanged(this, this.OnPropertyValueChanged);
        }

        // Wertänderungsbenachrichtigung erzwingen
        this.Value = 4711;
        this.Value = 0815;
    }

    private void OnPropertyValueChanged(object sender, EventArgs e)
    {
        // Wird nie aufgerufen
        Debug.Assert(false, "this.Value changed: " + this.Value);
    }

    public int Value { get; set; }
}

var test = new Class1();
test.Test();

Im Internet finde ich keine nützliche Informationen. Und da es so schon immer funktioniert hat, wollte ich auch nicht auf das "neue" DependencyProperty Handling umsteigen.

Das einzige was ich gefunden habe, ist das SupportChangeEvents Property auf dem PropertyDescriptor was auf false steht, was mit der Nicht-Benachrichtigung zu tun haben könnte. Aber damit kann ich auch nicht viel anfangen, da ich auch Basistypen wie int und string verwende. Ich musste mich auch nie darum kümmern.

Das Ganze habe ich in einer VM (Windows XP SP 3) mit Visual C# Express 2010 am Laufen. Ich kann mir nicht vorstellen, dass die Express Version solche Einschränkungen hat?!

Stimmt. Ich war mir nicht sicher, ob die Selected-Collection unverändert bleibt. Hab das verwechselt.

[FAQ] Auflistungs-Elemente suchen und entfernen

Was bedeutet denn listView1.SelectedItems[**:::

Entfernen tust du ohnehin besser so:

foreach (ListViewItem item in listView1.SelectedItems)
{
    item.Remove();
}

Was heißt genau "sobald du DoubleBuffering verwendest"?

Edit: Hab das mal versucht, nachzustellen. Scheint so nix zu helfen. Da Transparenz, vor allem in GDI/+ sehr langsam ist, ist wohl WPF die bessere Wahl, wenn du damit rumspielen willst.

public class MagicPanel : Control
{
    public MagicPanel()
    {
        this.SetStyle(
            ControlStyles.SupportsTransparentBackColor | /* wichtig */
            ControlStyles.UserPaint | /* benötigt */
            ControlStyles.AllPaintingInWmPaint | /* benötigt */

            ControlStyles.OptimizedDoubleBuffer | /* Mit oder ohne, gleiches Verhalten */
                
            ControlStyles.ContainerControl | /* optional */
            ControlStyles.ResizeRedraw, /* optional */
            true);
    }
}

Zu 1) Das Thema hatte mich mal auch interessiert und bin bisher nicht wirklich zu einer eindeutigen bzw. schlüssigen Antwort gekommen. Viele sagen, dass es sogar keinen Unterschied machst, ob du die Column 'Is Unique' machst oder als Type 'Index' oder 'Unique' auswählst. Der Index kommt letztendlich immer drauf. Aber dem traue ich nicht so ganz. Lässt sich aber eigentlich leicht feststellen, ob das so ist (Index-Einträge ansehen). Bin nur grad nicht in der Lage dies zu tun.

Hab soeben etwas idiotisches in meinem eigenen Code entdeckt 😄

if (instance.Prop1 != null && instance != null)

Status: Fixed 😉

Ich war schon kurz davor, mit dem Gedanken zu spielen, meine Mitgliedschaft hier zu beenden 😉

PS: Heute werden 60.000 Punkte zum Abbauen des Punktestands in Flensburg für den Führerschein verlost! 😃

Oder noch einfacher (falls vorhanden): Mittlere Taste (Mausrad).

Wenn es um die Verwendung geht, wo der Compiler meckert, dann sollte es genügen, die Klasse mit ihrem qualifizierten Namen anzusprechen.

Anlässlich des Firefox 4 final veröffentlicht Threads in der wie im Web allgemein die verbreitete Geschwindigkeitsdiskussion wieder aufglimmt, wollte ich das Thema separiert hier aufgreifen. Mir gehts im Endeffekt nur darum, das Problem zu erörtern, weil ich es nie verstehe, da ich es nicht habe:

Seit Jahren wird darüber gestritten, dass der Firefox langsam startet, usw.
Ich hab in all den Jahren mit verschiedenen Maschinen (Pentium 4, Dual Core, Quad Core) seit Windows XP bis 7 mit den (meinen) 3-4 wichtigsten Add-Ons (AdBlock Plus, NoScript, Firebug, Omnibar/andere) nie Probleme gehabt.

Klar, damals ging der Fuchs nicht so schnell auf, das hat dann schon mal 3-5 Sekunden beim Erststart gedauert, bis er dann vor allem auch Eingabebereit war. Aber das war kein Problem > Relativ "langsame" Kiste, einige Add-Ons installiert, erster Start, viele Bookmarks.

Mit meinem jetzigen i7 920 dauert es max. 1-2 Sek, super-gefetched vielleicht nur noch ne halbe Sekunde (seit ungefähr Firefox 3.5 bis jetzt - 4.0). Wie es in den vorigen Versionen genau war, weiß ich nicht mehr genau, war aber ähnlich.

Was ist bei euch "langsam"? Welche und wieviele Add-Ons sind installiert. Was ist mit den Plugins? Eure Hardware?

Ich muss zudem auch sagen, dass ich grundsätzlich die unnötigen Windows Dienste ausschalte, da kommen schon ca. 20-30 Dienste zusammen, die wegfallen. Halte meine Registry immer sauber. Unnötige Programme weg (nur die nötigsten). Das hat sicherlich auch einen Einfluss auf das Startverhalten der Programme. Daher würde mich mal interessieren, wie "schlimm" denn euer Problem mit dem Firefox beim Starten ist.

Habt ihr auch am linken und rechten Rand eines aktiven Fensters einen abrupten Farb-/Transparenzwechsel? (Siehe Anhang: links aktives Fenster, rechts nicht aktives Fenster).
Der hat bei mir irgendwie die Eigenart, sich dauernd plötzlich nach oben und unten zu verschieben (ohne für mich erkennbaren Auslöser). Das nervt total - ist das normal?

Das ist mir sofort schon an der Beta 11 aufgefallen. Ich vermute, dass das ein ungewollter Seiteneffekt ist, der beim Hovern von Hyperlinks auftritt. In dem Moment wird nämlich auch die Statusleiste mit der Link-URL eingeblendet, welche diesen Border nach oben verschieben lässt.

BerndFfm:
Bei dem was du da sagst, kommt mir nur eine komplette Neuinstallation in den Sinn. Ich "experimentier" auch mit so einigen Betas. Installation/Deinstallation usw. Und meine MS Produkte funktionieren immer noch ohne irgendwelche Fehler 😉

Hört sich vielleicht etwas primitiv an, aber hast du den Ccleaner über die Registry laufen lassen?

Schau mal, ob es im DGV so etwas wie ein GetCellValue gibt. Irgendwas in dieser Richtung, sei es als Event oder als virtuelle Methode.

Mit dynamic brauchst du nichts zu machen.

Wonach richtet sich die Dynamik bei dir? Kannst du die Daten nicht vorher schon entsprechend aufbereiten?

Bitte arbeite dich in die Grundlagen ein. Die Frage ist mehr als Low-Level.

Sowas kannst du auch ohne Ahnung grundsätzlich mit Google lösen: "<Suchbegriff> c#" bringt dir in den meisten Fällen ein gutes Ergebnis.

such also einfach nach "List c#". Das sollte deine Frage beantworten.

Wir hatten mal einen Kaffeevollautomaten mit edlem Schümli Bohnenkaffee. Das hat pro Woche ca. 10-15 EUR gefressen (4 Mann) 😁

Seit längerem gibts also nur noch Brühkaffee, soviel wie wir trinken können bzw. Kaffeepulver vorhanden ist. Mehr als 4 Tassen trinken ich da pro Tag aber so gut wie nie.

Wasser und Frischmilch steht uns auch zur Verfügung.

Wobei ich mich als Angestellter eines kleinen 4-Mann-Betriebes nicht mit der Versorgung eines "richtigen" Betriebes vergleichen kann. Das basiert hier auf Wohlwollen und privaten Spenden des Chefs.

@M@TUK:
5-8 Espressi... kwt... 8o

Erstell dir eine eigene TreeView Klasse, die von TreeView erbt und dann:
Control verliert Focus durch Pfeiltasten...

Sicher, dass es nur ein OK Button ist? Ich vermute, dass das die Meldung sein wird, die sagt, dass das ausgeführte Skript lange ausführt und ob die Ausführung abgebrochen werden soll (Ja|Nein).

Entweder du handlest sie in der CmdKey direkt oder du schleifst sie durch per Aufruf an OnKeyDown. Bei Letzterem musst du in der CmdKey das Handled-Flag anschließend prüfen und entsprechend den base-Aufruf vornehmen oder nicht.

ich habe vergessen zu erwähnen wo er die Exception wirft, nämlich in der img.save zeile. Ist das Image null? Ansonsten mal ein anderes ImageFormat probieren.

Sehe ich genauso wie Jack. Das führt nur zu einer zwanghaften Erweiterung des Methodennamens.

Eigentlich war herbivores 1. Stichwort zu WndProc für dich Anlass genug, danach zu googlen, Implementierungen anzuschauen, usw.

Meinem Beispiel fehlt noch der base-Aufruf zu dieser Methode. Das wäre in diesem Fal:

base.WndProc(ref m);

Für gewöhnlich am Anfang der Methode.

Erstell dir eine eigene TextBox-Klasse, die von System.Windows.Forms.TextBox erbt und überschreibe =>

protected override void WndProc(ref Message m)
{
    // Auf WM für key up prüfen
    if (m.Msg == <Windows-Message Code>) // Auflistung unter pinvoke.com, Stichwort: WM, Windows Messages
    {
        
    }
}

Damit übersteuerst du die ganzen Events usw.

Siehe auch, ProcessCmdKey, ProcessX... auf System.Windows.Forms.Control.

Und darf man fragen, warum es kein Label sein darf? Das Argument mit der Druckvorschau leuchtet mir nicht wirklich ein.

WndProc, protected, virtual

in jedem Control.

Das ist ok.
Es gibt im Framework genügend gleiche Beispiele.

Möglicherweise reicht schon die Schätzung aus diesem Eingangspost aus: http://forums.arm.com/index.php?/topic/14569-loop-detection/

Die Sprungmarke hat einen geringeren Wert, als die aktuelle Position. Ob das nur bei Schleifen so ist, wage ich zu bezweifeln (-> Funktionsaufrufe).