Changement de label.la visibilité avec une méthode - Pourquoi ne pas le cacher?

Je veux être en mesure de définir l'étiquette de la visibilité à des vrai ou faux avec une méthode. J'ai ce code:

private void Change_Visible(Label toBeChanged)
{
    if (toBeChanged.Visible == false)
    {
        toBeChanged.Visible = true;
    }
    else
    {
        toBeChanged.Visible = false;
    }
    toBeChanged.Refresh();
}

J'appelle à ce code avec:

    Change_Visible(myLabel);
    //
    //Do other things
    //
    Change_Visible(myLabel);

Dans mon exemple précis, myLabel est configuré pour ne pas être visible à la charge de ma forme. Après le premier appel à Change_Visible il devient visible, mais après le deuxième appel à Change_Visible rien ne se passe. Pouvez-vous m'aider à le faire disparaître?

J'ai déjà essayé quelques autres logiques à la recherche d'une solution - par exemple:

private void Change_Visible(Label toBeChanged)
{
    if (toBeChanged.Visible == false)
    {
        toBeChanged.Visible = true;
        toBeChanged.Refresh();
        return;
    }
    if (toBeChanged.Visible == true)
    {
        toBeChanged.Visible = false;
        toBeChanged.Refresh();
        return;
    }
}

Je n'ai pas pris de conclusions. Je suis en train d'apprendre le C# par moi-même et a commencé il y a quelques semaines, alors peut-être que je suis absent quelque chose d'évident. Merci pour votre aide!

assurez-vous que vous n'êtes pas de blocage thread de l'INTERFACE utilisateur après le deuxième appel à change_visible
Tout semble bien se passer - pourriez-vous nous présenter quelques plus de contexte?. L'Étiquette sera effectivement invalidé lorsque la Label.Visible propriété est définie, ce qui signifie appeler Label.Refresh est en fait redondante ici. Vous pouvez effectivement remplacer l'ensemble du corps de la méthode avec return toBeChanged.Visible = !toBeChanged.Visible;.
Il n'a pas montrer l'étiquette la première fois jusqu'à ce que j'ai ajouté l'Étiquette.Refresh() de la ligne, c'est pourquoi elle est là.

InformationsquelleAutor Elder Taylor | 2013-10-19

c#methods winforms

5

L'étiquette ne sera pas réellement devenir invisible pour l'utilisateur jusqu'à ce que son Parent retrace son contexte, de la peinture sur les pixels auparavant établi par le contrôle label. Cela n'arrive pas dans votre code, la peinture ne se produit que lorsque le thread principal passe inactif et rentre dans la boucle de message. Il n'est pas inactif, il est de l'exécution de ces "autres choses".

Une solution de contournement est de demander au parent de la peinture elle-même au début:
```
myLabel.Visible = false;
this.Update();
//
//Do other things
//
myLabel.Visible = true;
```
Code qui s'exécute assez long pour exiger ce genre de commentaire devrait être exécuté dans un thread de travail à la place. Utiliser un BackgroundWorker ou de la Tâche.
- L'ajout de cette.Mise à jour(); a parfaitement fonctionné. J'ai aussi regardé dans le BackgroundWorker et pense que ça aiderait beaucoup de ce que je fais. Merci pour la réponse!
InformationsquelleAutor Hans Passant
0

Peut-être essayer de passer l'étiquette dans votre méthode de référence?
```
Change_Visible(ref myLabel);
//
//Do other things
//
Change_Visible(ref myLabel);
```
- Ouais, je suppose que ça doit être le comportement attendu
InformationsquelleAutor stayinwett
0

je pense que le seul problème avec ce code, c'est que depuis l'étiquette est en cours d'actualisation dans le thread de l'INTERFACE utilisateur, il va attendre que la peinture de cet évènement.

pour répondre regardez ce lien
Pourquoi ne pas en contrôle de la mise à jour de rafraîchissement de mi-processus de

InformationsquelleAutor Parv Sharma
-1

Exécuter les lignes suivantes après votre Visible/Permettre d'apporter des changements et le travail est fait!
```
//Explicit call for render
this.Update(); 
```
InformationsquelleAutor Manjit Chavan

Vous devez vous connecter pour publier un commentaire.