Wie um zu überprüfen, ob die Größe noch im Gange ist, mit OnResize-Ereignis?

Muss ich neu zeichnen eines Steuerelements, nachdem es vergrößert wurde und nicht, während es die Größe ändert, weil es braucht viel Zeit, neu zu zeichnen, eine Kontrolle und es verschwendet eine Menge von Ressourcen.

Meiner Kontrolle übernimmt Kontrolle Klasse und ich bin überschreiben der OnResize Veranstaltung.

PS: OnSizeChanged ist absolut das gleiche

InformationsquelleAutor Kristina Brooks | 2010-01-24

c#controls events redraw resize

2

Eine Lösung kann sein, resizeing Ihre Steuern nur nach dem übergeordneten Steuerelement/Formular fertig resizeing. Sie können dies tun, mit der 'ResizeEnd" - Veranstaltung.

Beispiel:
```
private void UserControl1_Load(object sender, EventArgs e)
{
    ((Form)this.Parent).ResizeEnd += new EventHandler(UserControl1_ResizeEnd);
}
void UserControl1_ResizeEnd(object sender, EventArgs e)
{
    MessageBox.Show("Resize end");
}
```
- Als nobugz darauf hingewiesen, das wird ärger bringen; eine Kontrolle soll nicht wissen, etwas bestimmtes über seine Eltern, ist es durchaus möglich, dass es gar nicht habe ein Elternteil, (zumindest vorübergehend). Dies kann praktisch sein, aber es bricht auch eine der grundlegendsten Regeln der Abstraktionen, die nicht nach reverse-Abhängigkeiten.
InformationsquelleAutor Amirshk
8

Lassen Sie mich einen anderen Blick auf dieses problem:

Das Problem ist nicht unbedingt, dass der "Benutzer ist immer noch die Größe des Steuerelements." Das eigentliche Problem ist, dass die Steuerung wird angepasst häufiger als die Zeit, die zum Neuzeichnen.

Wenn Sie definieren das problem als eines der Durchsatz, wird es leichter zu lösen. Und in der Tat Bebop hatte die richtige Idee, mit seiner Antwort, aber ich glaube, das können wir besser:
```
public class MyControl : Control
{
    private TimeSpan paintTime = 250;   //Time to paint, default=250ms
    private TimeSpan resizeTime = 100;  //Time to update layout, default=100ms

    protected override void OnPaint(PaintEventArgs pe)
    {
        Stopwatch sw = new Stopwatch();
        sw.Start();
        //Do your painting here, or call base.OnPaint
        sw.Stop();
        paintTime = sw.Elapsed;
    }

    protected override void OnResize(EventArgs e)
    {
        //The "Stop" is not redundant - it will force the timer to "reset"
        //if it is already running.
        resizeTimer.Stop();
        base.OnResize(e);
        resizeTimer.Interval =
            (int)(paintTime.TotalMilliseconds + resizeTime.TotalMilliseconds);
        resizeTimer.Start();
    }

    private void UpdateSize()
    {
        Stopwatch sw = new Stopwatch();
        sw.Start();
        //Resizing code goes here
        sw.Stop();
        resizeTime = sw.Elapsed;
    }

    private void resizeTimer_Tick(object sender, EventArgs e)
    {
        resizeTimer.Stop();
        UpdateSize();
    }
}
```
Die Idee hier ist, um das Steuerelement aktiv Profil selbst; wenn Sie es starten auf einer langsamen Maschine oder die Maschine einfach nur läuft schleppend, dann wird dies verlangsamen Ihre Aktualisierungsrate. Wenn Sie es auf bleeding-edge-hardware, dann kann es nicht haben, zu überspringen wissenschaftsfreiheit überhaupt. Dies ist eigentlich eine ziemlich einfache "auto frame skip" - Algorithmus von der Art sehen Sie oft im Geräte-Emulatoren.

Klar zu sein, ich habe nichts gegen den Ansatz spricht von nobugz; der einzige Grund, würde ich diese wählen stattdessen ist, dass die Logik ist vollständig in sich geschlossenes, in der Erwägung, dass das aussetzen einer Resizing Eigenschaft (oder vielleicht mehr treffend benannt EnableFullPaint) ist abhängig von dem Verbraucher, zu wissen, und verwenden Sie es richtig - und auch, es wird verhindert, dass alle Malerarbeiten für die gesamte Dauer von der Größe, was kann dazu führen, die app zu "fühlen" buggy - Nutzer nicht dazu neigen zu erwarten, dass eine leere/Unsinn Bildschirm während einer Größenänderung.

Ich habe beide Methoden und beide arbeiten; welche ist am besten für Sie hängt von Ihren Anforderungen ab. Ich schlage vor, Sie versuchen, diese, Sie sehen, wie gut es für Sie arbeitet, und wenn es problematisch wird oder nicht, was Sie wollen dann gehen Sie mit nobugz' Antwort.

InformationsquelleAutor Aaronaught
1

Wie wärs, wenn man das MouseDown-Ereignis gehen:
YourControl.SuspendLayout();

und dann in das MouseUp-Ereignis gehen:
YourControl.ResumeLayout();

InformationsquelleAutor foreyez
0

ResizeEnd Ereignis scheint die beste Idee, aber als alternative könnte man einen timer, die Sie neu starten, in das resize-Ereignis und Neuzeichnen, wenn der timer feuert. Solange die Zeit des Timers ist Recht kurz, sagen wir 100ms dann sollten Sie nicht bemerken, die redraw-Verzögerungen zu schlecht.

Aber das andere Ereignis scheint wie eine bessere option...

InformationsquelleAutor Sam Holder

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.