C# aspetta che l'utente finisca di digitare in una casella di testo

Question

C'è un modo in C# di aspettare fino a quando l'utente ha finito di digitare una casella di testo prima di prendere i valori che ha digitato senza premere invio?

rivisto questo domanda un po ':

Va bene ho una semplice calcolatrice che moltiplica per 2.

Ecco quello che voglio fare: l'utente immette un valore come 1000 in una casella di testo e visualizza automaticamente 2000.

Ecco cosa accade: non appena l'utente inserisce nella 1 suoi moltiplicazione per 2 e uscite 2.

Answer 1

È possibile utilizzare l'evento di testo onChange(). Se il testo viene modificato nella casella di testo, verificare se il valore immesso è un numero e calcolare il valore totale in base all'altro valore.

Answer 2

è possibile gestire l'evento LostFocus della casella di testo che scatta ogni finiture utente digitando a nd si allontana dalla casella di testo. Ecco la documentazione su LostFocus: http://msdn.microsoft.com/en-us/library/system.windows.forms.control.lostfocus.aspx

Tuttavia, non sono sicuro di cosa esattamente si stia tentando di fare qui poiché la domanda non è molto chiara su cosa significa "finitura".

Answer 3

Cosa succede se si attiva un evento in base a una sequenza di tasti come scheda o ritorno?

Answer 4

Si desidera utilizzare gestire l'evento Leave o LostFocus per la casella di testo in questione. Suppongo che tu stia usando WinForm anche se non lo dici nella tua domanda.

Answer 5

Definisco "terminato digitando" ora come "l'utente ha digitato qualcosa ma non ha digitato nulla dopo un certo tempo". Avendo che come definizione ho scritto una piccola classe che deriva da TextBox per estenderlo con un evento DelayedTextChanged. Non sono sicuro che sia completo e privo di bug, ma ha soddisfatto un piccolo test del fumo. Sentiti libero di cambiare e/o usarlo. L'ho chiamato MyTextBox perché non riuscivo a trovare un nome migliore adesso. È possibile utilizzare la proprietà DelayedTextChangedTimeout per modificare il timeout di attesa. L'impostazione predefinita è 10000 ms (= 10 secondi).

public class MyTextBox : TextBox 
{ 
    private Timer m_delayedTextChangedTimer; 

    public event EventHandler DelayedTextChanged; 

    public MyTextBox() : base() 
    { 
     this.DelayedTextChangedTimeout = 10 * 1000; // 10 seconds 
    } 

    protected override void Dispose(bool disposing) 
    { 
     if (m_delayedTextChangedTimer != null) 
     { 
      m_delayedTextChangedTimer.Stop(); 
      if (disposing) 
       m_delayedTextChangedTimer.Dispose(); 
     } 

     base.Dispose(disposing);    
    } 

    public int DelayedTextChangedTimeout { get; set; } 

    protected virtual void OnDelayedTextChanged(EventArgs e) 
    { 
     if (this.DelayedTextChanged != null) 
      this.DelayedTextChanged(this, e); 
    } 

    protected override void OnTextChanged(EventArgs e) 
    { 
     this.InitializeDelayedTextChangedEvent(); 
     base.OnTextChanged(e);    
    }     

    private void InitializeDelayedTextChangedEvent() 
    { 
     if (m_delayedTextChangedTimer != null) 
      m_delayedTextChangedTimer.Stop(); 

     if (m_delayedTextChangedTimer == null || m_delayedTextChangedTimer.Interval != this.DelayedTextChangedTimeout) 
     {     
      m_delayedTextChangedTimer = new Timer(); 
      m_delayedTextChangedTimer.Tick += new EventHandler(HandleDelayedTextChangedTimerTick); 
      m_delayedTextChangedTimer.Interval = this.DelayedTextChangedTimeout; 
     } 

     m_delayedTextChangedTimer.Start(); 
    } 

    private void HandleDelayedTextChangedTimerTick(object sender, EventArgs e) 
    { 
     Timer timer = sender as Timer; 
     timer.Stop(); 

     this.OnDelayedTextChanged(EventArgs.Empty); 
    } 
} 

Answer 6

Non so se l'onChange() esiste solo in una versione precedente di C#, ma non riesco a trovarlo!

i seguenti lavori per rilevare quando un utente o colpisce il tasto Invio o Tab per uscire dal TextBox, ma solo dopo aver cambiato una parte di testo:

//--- this block deals with user editing the textBoxInputFile --- // 
    private Boolean textChanged = false; 
    private void textBoxInputFile_TextChanged(object sender, EventArgs e) { 
     textChanged = true; 
    } 
    private void textBoxInputFile_Leave(object sender, EventArgs e) { 
     if (textChanged) { 
      fileNameChanged(); 
     } 
     textChanged = false; 
    } 
    private void textBoxInputFile_KeyDown(object sender, KeyEventArgs e) { 
     if (textChanged & e.KeyCode == Keys.Enter) { 
      fileNameChanged(); 
     } 
     textChanged = false; 
    } 
    //--- end block --- // 

Answer 7

Un'altra soluzione semplice sarebbe quella di aggiungere un timer per il vostro modulo, impostare la proprietà Interval a 250 e quindi utilizzare evento tick del timer come segue:

private void timer1_Tick(object sender, EventArgs e) 
{ 
    timer1.Stop(); 
    Calculate(); // method to calculate value 
} 

private void txtNumber_TextChanged(object sender, EventArgs e) 
{ 
    timer1.Stop(); 
    timer1.Start(); 
} 

Answer 8

Se si utilizza WPF e .NET 4.5 o successiva c'è una nuova proprietà da parte di legame di un controllo denominato " Ritardo". Definisce un intervallo dopo il quale la fonte viene aggiornata.

<TextBox Text="{Binding Name, Delay=500}" /> 

Ciò significa che la sorgente viene aggiornata solo dopo 500 millisecondi. Per quanto vedo lo fa l'aggiornamento dopo aver digitato nel TextBox terminato. Btw. questa proprietà può essere utile anche in altri scenari, ad es. ListBox ecc.

Answer 9

Ho affrontato la stessa sfida, ed ecco il mio approccio semplice. Questo funziona senza problemi.

public partial class Form2 : Form 
    { 
     static int VALIDATION_DELAY = 1500; 
     System.Threading.Timer timer = null; 
     public Form2() 
     { 
      InitializeComponent(); 
     } 

     private void textBox1_TextChanged(object sender, EventArgs e) 
     { 
      TextBox origin = sender as TextBox; 
      if (!origin.ContainsFocus) 
       return; 

      DisposeTimer(); 
      timer = new System.Threading.Timer(TimerElapsed, null, VALIDATION_DELAY, VALIDATION_DELAY); 

     } 
     private void TimerElapsed(Object obj) 
     { 
      CheckSyntaxAndReport(); 
      DisposeTimer();    
     } 

     private void DisposeTimer() 
     { 
      if (timer != null) 
      { 
       timer.Dispose(); 
       timer = null; 
      } 
     } 

     private void CheckSyntaxAndReport() 
     {    
      this.Invoke(new Action(() => 
      { 
       string s = textBox1.Text.ToUpper(); //Do everything on the UI thread itself 
       label1.Text = s; 
      } 
       ));    
     } 
    } 

Answer 10

In UWP, ho fatto un controllo ritardato facendo una lastTimeOfTyping statica e controllando il tempo in cui l'evento "TextChanged" è accaduto. Questo attende che l'ultimo staticTimeOfTyping sia uguale quando una nuova ora "TextChanged" corrisponde e quindi esegue la funzione desiderata.

private const int millisecondsToWait = 500; 
    private static DateTime s_lastTimeOfTyping; 
    private void SearchField_OnTextChanged(object sender, TextChangedEventArgs e) 
    { 
     var latestTimeOfTyping = DateTime.Now; 
     var text = ((TextBox)sender).Text; 
     Task.Run(()=>DelayedCheck(latestTimeOfTyping, text)); 
     s_lastTimeOfTyping = latestTimeOfTyping; 
    } 

    private async Task DelayedCheck(DateTime latestTimeOfTyping, string text) 
    { 
     await Task.Delay(millisecondsToWait); 
     if (latestTimeOfTyping.Equals(s_lastTimeOfTyping)) 
     { 
      // Execute your function here after last text change 
      // Will need to bring back to the UI if doing UI changes 
     } 
    }