Le texte modifié de l'événement de zone de texte objet: comment effectuer le changement de texte + une autre action

Je voudrais que lorsque l'utilisateur tape/modifier le texte de la textBox1, simultanément, le texte d'une deuxième textBox2 permettrait d'obtenir effacée. Pour ce faire, j'ai simplement ajouté un événement de la forme:

private void textBox1_TextChanged(object sender, EventArgs e)
    {
        this.textBox2.Text = "";
    }

Cependant, c'est la cause du textBox2 arriver compensés, mais les commentaires que l'utilisateur a tapé perdu. Pratiquement:

ce que j'attends:
si le textBox1 de texte est vide et le textBox2 n'est pas, lorsque l'utilisateur tape "A" dans la première zone de texte, je voudrais obtenir simultanément le textBox2 effacé et la lettre "A" dans le textBox1.

ce que je reçois:
le textBox2 devient clair, mais la lettre "A" n'apparaît pas dans la textBox1: je vais avoir à le saisir une deuxième fois pour l'obtenir dans le bon endroit.

Que dois-je faire pour garder l'entrée de l'utilisateur dans le textBox1 tout en compensation de la textBox2?

EDIT: fait oublier d'y ajouter une partie importante de ce code, qui est le "jumeau" frère de la méthode que j'ai posté ci-dessus:

private void textBox2_TextChanged(object sender, EventArgs e)
    {
        this.textBox1.Text = "";
    }

Je réviser un peu ma question: comment puis-je répondre à mon comportement attendu, tout en évitant que la clairière textBox2 est pris comme un text_changed événement?

  • Est-ce asp.net ou winforms?
  • Êtes-vous sûr que vous n'êtes pas de compensation le texte de textbox1 quelque part ?
  • winforms. Désolé, j'ai oublié de préciser, je vais le faire dès maintenant
  • Le code ci-dessus ne peut produire que du comportement. Il y a autre chose qui efface le contenu de la première zone de texte.
  • bien sûr, j'ai pensé à la même chose, mais j'ai juste inséré et aucun autre code n'est pointant vers elle de toute façon.
  • Que faites-vous dans textBox2 événement textChanged?
  • Il doit y avoir d'autres codes que vous ne présentez pas, parce que ce que vous avez posté à faire ce que vous voulez. Avez-vous des code dans le textBox2_TextChanged événement?
  • Désolé les gars, c'était une erreur stupide. Vous avez raison, je ne suis pas de poster une importante partie de code qui est le cas dans textBox2_TextChanged. Je vais le faire dès maintenant, c'est clairement à l'origine du problème, donc je vais réviser un peu la question pour vous permettre de répondre correctement
  • Je voudrais vous recommandons de conserver les originaux de vos gestionnaires d'événements au lieu de les insérer bizarre événement de liaison/déliaison. Juste lier à l'un des événements de clavier, par exemple KeyUp au lieu de TextChanged. Les originaux de vos gestionnaires devrait fonctionner ensuite.
  • Je suis un newbie de la langue et j'ai trouvé cela intéressant. Pourriez-vous détailler votre point de s'il vous plaît? Ce genre de mauvaises choses dans cette approche pourrait entraîner? merci d'avance
  • Eh bien pour commencer, pourquoi aller avec des solutions compliquées quand vous pourriez utiliser un simple? Les originaux de vos gestionnaires sont concis et d'exprimer ce que vous voulez à la perfection. Ils sont juste la cuisson quand ils ne sont pas censés le faire, parce que l'événement que vous avez lié n'est pas celui que vous êtes réellement intéressé. Vous êtes intéressés à faire de cette zone de texte de compensation des choses quand, et je vous cite ici, "l'utilisateur est en tapant", pas quand la Text propriété de la zone de texte est modifié. La façon la plus simple de le faire est de se lier à un événement qui se déclenche uniquement lorsque l'utilisateur interagit avec la zone de texte.
  • Ensuite, vous aurez besoin d'appliquer ce correctif (ou un similaire), chaque fois que vous, explicitement ou implicitement, ajoutez le code qui modifie le contrôle textbox Text de la propriété. Même si vous-même n'avez pas l'esprit en ajoutant tous cet événement attachement détachement de trucs tout au long de votre base de code, si vous êtes à collaborer avec quelqu'un d'autre, ils ont probablement aucune idée intuitive pourquoi vous êtes attacher et détacher des gestionnaires en succession rapide, et il augmente leur la charge cognitive d'avoir à penser au sujet de ces effets secondaires que vous essayez d'éviter.
  • c'est une idée intéressante. Le comportement serait différent pour la accepté de répondre (il n'est pas clair ce que le comportement de l'OP veut). Imaginez un bouton pour l'exemple qui définit le textBox1.Text à une valeur non vide. Dans votre approche du texte dans textBox2 serait PAS effacé, mais dans l'acceptation de réponse, il serait. Si l'OP ne veut qu'une de ces zones de texte pour avoir une valeur à tout moment, et ils sont de modification dans le code de votre approche ne fonctionne pas (comme il est). En aparté, vous voudrez probablement utiliser KeyDown plutôt que KeyUp sinon vous obtiendrez comportement étrange lors de la tabulation.
  • Oui, votre bouton exemple est une bonne démonstration de pourquoi je suggère que l'OP utiliser le clavier plutôt des événements. De ma compréhension de la question de l'OP veut répondre à une saisie au clavier de l'utilisateur, et des modifications du programme de la Text propriété (comme ce serait un clic sur un bouton gestionnaire) ne devrait pas déclencher le gestionnaire.
  • Je pense que l'utilisateur est saisie/modification du texte est quelque peu ambiguë. Je l'ai lu comme une modification du texte, mais je peux voir pourquoi vous voulez le lire dans l'autre sens.
  • Si l'OP ne voulez que les autres à cocher dans le cas de la presse le bouton, il serait encore plus claire de l'OMI explicitement joindre le gestionnaire de compensation de l'autre zone de texte à l'événement click du bouton (en plus de toutes les autres gestionnaires). C'est une infime quantité de code (un énoncé) et beaucoup plus clairement exprime l'intention.
  • cela dépend de la façon dont de nombreux endroits, le texte est modifié à partir de. J'aime votre approche si.
  • c'est à dire l'Appel d'un gestionnaire d'événement ClearTextBox2, et l'ajouter à la première zone de texte du KeyDown (merci), le bouton de Click, et tous les autres endroits où vous souhaitez que la deuxième zone de texte effacé.
  • Je dois avouer que cette conversation est très intéressante d'un débutant point de vue. J'aimerais lire l'avis de @Steve ainsi, s'il n'a pas l'esprit. Pour vous, c'est probablement normal façon de penser, mais pour un non-professionnel de développeur de ces commentaires sont en or!
  • Je veux voir le code écrit, à l'approche de ce problème à l'aide de la un événement keydown avec toutes les variations possibles lorsque vous manipulez ce genre d'événement. (Copier/Coller, le retour arrière) je continue de penser que la désactivation de l'événement TextChanged exprimer parfaitement le programmeur intentions et il est tout à fait clair, mais j'ai peut-être tort.
  • J'ai ajouté le code écrit, vous avez demandé une réponse.
  • Dans le cas où vous êtes intéressé, je crois que j'ai trouvé un compromis 🙂

InformationsquelleAutor Matteo NNZ | 2014-10-28
  1. 2

    Vous pouvez désactiver votre gestionnaire d'événement pour éviter un événement interférer avec l'autre.

    Vous pouvez également utiliser un mondial variable booléenne, mais je préfère cette approche, car il ne nécessite pas de variables globales et pas ifs

    private void textBox1_TextChanged(object sender, EventArgs e)
{
    this.textBox2.TextChanged -= textBox2_TextChanged;
    this.textBox2.Text = "";
    this.textBox2.TextChanged += textBox2_TextChanged;
}

private void textBox2_TextChanged(object sender, EventArgs e)
{
    this.textBox1.TextChanged -= textBox1_TextChanged;
    this.textBox1.Text = "";
    this.textBox1.TextChanged += textBox1_TextChanged;
}
    • +1 @Steve - c'est ma préféré l'approche de trop 🙂
    • +1 & réponse à @Steve, je dirais. Je suis en train d'apprendre le C# maintenant, et cette approche du travail alors que l'enseignement des notions sur la gestion des événements à un débutant de la langue. Merci beaucoup.
    • quelle différence de 10 secondes en fait LOL
    • hehe j'ai bien vu vos réponses, la pensée de mon ordinateur portable était fou de dupliquer l'écran! J'ai choisi par la synchronisation depuis qu'il était vraiment le seul critère pour moi de choisir entre les deux 🙂
    • tout à fait d'accord. Je suis content que vous avez obtenu votre question triée. Je suis hors de la pratique de la dactylographie 🙂
    • C'est la mauvaise solution au problème. L'OP sera de retour où il a commencé le moment rien d'autre modifie la Text de propriété sur l'une des zones de texte. Pour ne pas mentionner à la fois les gestionnaires d'événements ont maintenant cryptique code à l'intérieur d'eux, même si ce qu'ils sont supposés faire, est trivial. Fondamentalement, l'OP veut se lier à ses délégués à une saisie au clavier de l'utilisateur, et non un changement dans le Text de la propriété. La solution est d'utiliser les événements de clavier au lieu de TextChanged.
    • vous êtes libre de vous proposer une solution. Je suis très impatient de voir votre approche et je vais upvote vous si vous me convaincre qu'il y a quelque chose de plus simple.
    • Mon approche est tout simplement à utiliser l'original des gestionnaires d'événements et de se lier à un événement de clavier, par exemple KeyUp à la place. Il n'y a pas de code que ce soit, donc je ne le sens pas, même mérite une réponse.

    InformationsquelleAutor Steve
  2. 2

    Je voudrais vous recommandons de conserver votre contact agréable et propre, comme vous les avez, et au lieu de faire une des deux choses:

    • À l'aide de la Modifié propriété de vérifier si l'utilisateur a effectivement modifié la zone de texte. Cette bool obtient automatiquement revenue à false lorsque des modifications du programme de Text sont faites
    • De liaison pour les événements de clavier au lieu

    À l'aide de Modified

    Voici comment vous pouvez mettre en œuvre la première option: 

    public void TextBox1_TextChanged(object sender, EventArgs ea)
{
    if (textBox1.Modified) textBox2.Clear(); 
}

    Cela fonctionne à merveille et est très facile à comprendre pour tous ceux qui cherchent à le code. Si le Text propriété a été modifié par programmation (comme dans votre cas, par l'autre gestionnaire d'événement), la Modified propriété est false, et pas de compensation qui se passe.

    Comme un bonus, si vous faites des changements dans le programme d'ailleurs, et ne voulez le gestionnaire d'événement à suivre à travers, vous pouvez facilement définir Modified = true explicitement:

    textBox1.Text = @"I have been set programmatically, 
                  but in this specific case the other box 
                  should still be cleared";
textBox1.Modified = true;

    À l'aide du clavier événements

    Voici comment vous pouvez mettre en œuvre ce à l'aide des événements de clavier:

    private void TextBox1_TextChanged(object sender, EventArgs e)
{
    textBox2.Clear();
}

    Et où vous le faites à votre gestionnaire d'événement pour l'événement de liaison:

    textBox1.KeyDown += TextBox1_TextChanged;
textBox1.Paste += TextBox1_TextChanged;

    D'autres améliorations

    Vous pourrait en faire un peu plus générique par l'ajout d'une méthode qui lie la zone de texte de compensation de logique pour toute autre zone de texte. Voici comment j'ai utilisé dans mon test winforms projet:

    public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        ClearOnUserInput(textBox1, textBox2);
        ClearOnUserInput(textBox2, textBox1);
    }

    private void ClearOnUserInput(TextBox inputBox, TextBox target)
    {
        inputBox.TextChanged += delegate {
            if(inputBox.Modified) target.Clear();
        };
    }
}

    Notez que j'ai ajouté une méthode distincte pour fixer la compensation logique de garder les choses à SEC, et je suis également en utilisant un délégué anonyme ici pour éviter d'ajouter des méthodes supplémentaires. Vous pouvez tout aussi bien utiliser deux gestionnaires comme vous l'étiez auparavant.

    InformationsquelleAutor Asad Saeeduddin
  3. 1

    Lorsque vous modifiez le texte de textBox2 dans le TextChanged cas de textBox1 il déclenche l' TextChanged cas de textBox2 qui définit à son tour la textBox1 texte "".

    Pour le résoudre, vous pourriez supprimer le contraire TextChanged de gestionnaire à l'intérieur de chaque gestionnaire avant de changer le texte, puis de le remettre:

    private void textBox1_TextChanged(object sender, EventArgs e)
{
    this.textBox2.TextChanged -= textBox2_TextChanged;
    this.textBox2.Text = "";
    this.textBox2.TextChanged += textBox2_TextChanged;
}

private void textBox2_TextChanged(object sender, EventArgs e)
{
    this.textBox1.TextChanged -= textBox1_TextChanged;
    this.textBox1.Text = "";
    this.textBox1.TextChanged += textBox1_TextChanged;
}
    InformationsquelleAutor petelids
  4. 0

    Vous utilisez Text Changed événement, pensez à la possibilité d'avoir 1 caractère dans la zone de texte:

    private void textBox1_TextChanged(object sender, EventArgs e)
{
    if (textBox1.Text.Length == 1 && textBox2.Text != String.Empty)
        textBox2.Text = String.Empty;
}

    Je vous recommande d'utiliser Key Down événement pour votre scénario. Il va en tirer avant de changer le Text de la zone de texte, et vos conditions sera vérifiée au bon moment.

    • La capture des événements de clavier est la meilleure solution, étant donné que l'OP veut déclencher un délégué lors de la Text propriété est modifiée, mais lorsque l'utilisateur fournit de l'entrée. Cela permettrait également d'éviter hacky solutions de contournement comme fixation et retrait des auditeurs.
    InformationsquelleAutor Shaharyar
  5. 0

    Si vous êtes en essayant de ne permettre qu'une seule zone de texte pour accepter l'entrée et toujours évident de l'autre, vous pouvez garder une trace de savoir si ou non votre code est en train de changer le texte dans une variable distincte.

    Exemple:

    //This variable tracks whether or not our code is changing the text
//If it's set to false, then the user is changing the text
private bool ignoreTextChange = false;

private void textBox1_TextChanged(object sender, EventArgs e)
{
    if (ignoreTextChange)
    {
        //Our code is changing the text, so just reset the variable
        ignoreTextChange = false;
    }
    else
    {
        //Our code is going to change the other text box,
        //so set our variable and clear the other text box
        ignoreTextChange = true;
        this.textBox2.Text = "";   
    }        
}

private void textBox2_TextChanged(object sender, EventArgs e)
{
    if (ignoreTextChange)
    {
        ignoreTextChange = false;
    }
    else
    {
        ignoreTextChange = true;
        this.textBox1.Text = "";
    }  
}
    InformationsquelleAutor Rufus L