Faire un indexée tableau de contrôle?

A C# indexé tableaux de contrôle ou pas? Je voudrais mettre un bouton "tableau" par exemple, avec 5 boutons qui utilisent seulement un gestionnaire d'événement qui s'occupe de l'index de tous les cette 5 contrôles (comme VB6 ne). Autre chose que j'ai à écrire pour chacun de ces 5 boutons un gestionnaire d'événement. Et si j'ai 100 boutons, j'ai besoin de 100 gestionnaires d'événements? Je veux dire quelque chose comme ça:

TextBox1[i].Text="Example";

Il pourrait faire de codage certainement plus facile pour moi de travailler avec des groupes de contrôle. Maintenant j'ai vu, C#, au moins, n'a pas visibles éventail de fonctionnalités sur les contrôles de l'utilisateur et non "index" de la propriété sur les commandes de l'utilisateur. Donc je suppose que C# n'a pas de tableaux de contrôle, ou je doit chaque élément de l'appel par nom connu.

Au lieu de donner des 100 zones de texte dans une boucle for 100 incrémentation des valeurs, je dois écrire:

TextBox1.Text = Value1;
TextBox2.Text = Value2;
...
...
TextBox100.Text = Value100;

Beaucoup plus de travail + l'ensemble de ces 100 des gestionnaires d'événements de chaque pour une autre zone de texte supplémentaire.

Chaque parent a également une propriété .Controls qui donne accès à une collection de contrôles enfants. Si vous placez l'ensemble de vos zones de texte à l'aide des boutons à l'intérieur de la même conteneur parent, vous pouvez faire référence à eux par le biais de l'enfant liste des contrôles.
Vous pouvez affecter le même gestionnaire d'événement à plusieurs contrôles, vous n'avez pas besoin de créer un nouveau gestionnaire d'événement de mise en œuvre pour chaque instance de contrôle.
Vous pouvez avoir un peu de chance la mise en œuvre de ICollection<T> T : Témoin, mais vous ne pouvez pas ajouter un gestionnaire d'événements pour un tableau.
Ne pourriez-vous pas mettre tous les contrôles dans un tableau à l'aide de la réflexion (une fois) et ensuite l'utiliser comme un tableau par la suite? Bien sûr, si vous êtes seulement après que les gestionnaires d'événements il y a d'autres façons, comme l'a suggéré.
La charge de l'utilisateur exposés à une INTERFACE utilisateur catastrophe avec une centaine de zones de texte, à plusieurs reprises, doit être correctement mis en correspondance avec le purgatoire un programmeur mérite pour en créer un. Son seul juste.

OriginalL'auteur feedwall | 2012-07-23

arrays c#user-controls winforms

4

Comme je l'ai mentionné dans un commentaire à une solution par HatSoft, C#, Winforms ne vous permet pas de créer des tableaux de contrôle, comme de vieux VB6 nous a permis de nous. Le plus proche, je pense que nous pouvons obtenir, c'est ce HatSoft et Bert Evans dans leurs postes ont montré.

Une chose que j'espère, satisfaire votre exigence est le gestionnaire d'événements, vous obtenez une commune gestionnaire d'événement et dans le gestionnaire d'événements lorsque vous transtypage de l ' "expéditeur", vous obtenez le contrôle directement comme vous le feriez dans VB6

C#
```
TextBox textBox = sender as TextBox;
```
VB6
```
TextBox textBox = TextBox1[i];
```
Donc la seule difficulté que vous pourriez avoir est de câblage de 100, des zones de texte à un seul gestionnaire d'événements, si vous ne créez pas les contrôles dynamiquement par le biais de code au lieu de le créer manuellement au moment de la conception alors tout ce qu'on peut suggérer, c'est de les regrouper dans un récipient comme dis. Ensuite sur la Forme de la Charge de fil tous à un seul gestionnaire d'événements comme ceci:
```
foreach (Control control in myTextBoxPanel.Controls)
{
    if(control is TextBox)
         control.TextChanged += new EventHandler(control_TextChanged);
}
```
OriginalL'auteur Arif Eqbal
5

Je sais que je suis un peu en retard pour cette partie, mais cette solution fonctionne:

Faire un tableau global:
```
    TextBox[] myTextBox;
```
Puis dans votre constructeur de l'objet, après l'appel à
```
    InitializeComponent();
```
initialiser votre tableau:
```
    myTextBox = new TextBox[] {TextBox1, TextBox2, ... };
```
Maintenant, vous pouvez parcourir votre tableau de contrôles:
```
    for(int i = 0; i < myTextBox.Length; i++)
        myTextBox[i].Text = "OMG IT WORKS!!!";
```
J'espère que cela aide!

Pete

OriginalL'auteur Pete
2

Il suffit de créer un gestionnaire et point tous les boutons.
```
var ButtonHandler = (sender, args) => {
    var clicked = (Button)sender;
    if (clicked.Text == "whatever")
       //do stuff
    else
       //do other stuff 
};

button1.Click += ButtonHandler;
button2.Click += ButtonHandler;
```
Alternativement, si vous créez des contrôles dans le code, vous pouvez utiliser l'une des techniques spécifiés dans cette réponse.

Ah, vous avez mentionné usercontrols et j'ai sauté à une conclusion.
Ligne de fond, créer un gestionnaire d'événements, et de l'attribuer aux commandes de l'événement.
Le gestionnaire reçoit l'expéditeur comme un argument. Si vous assignez une valeur à chaque contrôle, vous pouvez examiner cette valeur pour déterminer qui contrôle l'utilisateur a cliqué.

OriginalL'auteur Bert

Au lieu de donner des 100 zones de texte dans une boucle for 100 incrémentation des valeurs, je dois écrire:

for(int i = 0; i <100; i++)
{
   TextBox t = new TextBox(){ Id = "txt_" + i, Value = "txt_" + i};
   t.TextChanged += new System.EventHandler(this.textBox_Textchanged);
  Page.Controls.Add(t);

}

//and for event on TextChanged
private void textBox_Textchanged(object sender, EventArgs e)
    {
        TextBox textBox = sender as TextBox;

        if (textBox != null)
        {
////
        }
    }

Non, vous ne pouvez pas avoir un tableau comme vous pouvez vous en VB6 au moment de la conception. Cependant, vous pourriez avoir une commune de gestionnaire d'événements pour tous les contrôles, mais vous devrez manuellement les fils en place au moment de la conception ou à l'aide de code.

OriginalL'auteur HatSoft

0

Si vous travaillez avec des Formulaires Web et pas de MVC, vous pouvez accéder à une collection de contrôles sur la page, comme indiqué dans À l'aide de la Collection de Contrôles dans un ASP.NET Page Web. Essentiellement de la collection controls est un arbre avec la page hébergeant le premier niveau de contrôle des enfants et certains éléments d'avoir des enfants de leur propre. Voir Comment: Recherchez les Contrôles de Formulaires Web sur une Page en Marche de la Collection Controls pour un exemple de la façon de suivre l'arbre.

Aussi, voir Comment: Ajouter des Contrôles à un ASP.NET Page Web par programmation.

Vous pouvez utiliser le même gestionnaire d'événements pour plusieurs articles, aussi longtemps que la signature est la même.

Pour Windows Forms c'est à peu près identique, car ils sont basés sur des modèles architecturaux, mais vous aurez envie De contrôle.Les Contrôles De La Propriété et Comment: Ajouter des Contrôles Windows Forms.

Les Formulaires Windows et Web les modèles sont presque identiques comme mesure de base de l'architecture. Beaucoup de la technique s'applique. J'ai ajouté un peu plus de la réponse.

OriginalL'auteur JamieSee
0

Une autre chose à noter: si vous avez vraiment besoin de modifier de 100 chaînes sur un seul formulaire, vous devez sans doute penser que 100 des zones de texte est vraiment la meilleure façon de le faire. Peut-être un ListView, DataGridView, ou grille de propriété serait mieux adaptée.

Cela s'applique à presque tout moment vous pensez que vous avez besoin d'un large éventail de contrôles.

OriginalL'auteur smead

Garder les choses simples:

TextBox[] keybox = new TextBox[16];   //create an array

for (int i=0; i<16; i++) 
{
    keybox[i] = new TextBox();        //initialize (create storage for elements)
    keybox[i].Tag = i;                //Tag prop = index (not available at design time)
    keybox[i].KeyDown += keybox_down; //define event handler for array
}

private void keybox_down(object sender, KeyEventArgs e)
{
    int index = (int)((TextBox)sender).Tag    //get index of element that fired event
    ...
}

OriginalL'auteur John

Vous devez vous connecter pour publier un commentaire.