Constructeur 'UserControl' avec paramètres en C#

Il existe deux paradigmes concurrents pour concevoir des classes:

1. Utilisez des constructeurs sans paramètres et définissez un tas de propriétés par la suite
2. Utilisez des constructeurs paramétrés pour définir des propriétés dans le constructeur

Le Visual Studio Windows Forms Designer vous oblige à fournir un calculateur sans paramètre sur les contrôles afin de fonctionner correctement. En fait, il ne nécessite qu'un constructeur sans paramètre pour instancier les contrôles, mais pas pour concevoir eux (le concepteur analysera réellement la méthode InitializeComponent lors de la conception d'un contrôle). Cela signifie que vous pouvez utiliser le concepteur pour concevoir un formulaire ou un contrôle utilisateur sans constructeur sans paramètre, mais vous ne pouvez pas concevoir un autre contrôle pour l'utiliser car le concepteur ne parviendra pas à l'instancier.

Si vous n'avez pas l'intention d'instancier par programme vos contrôles (c'est-à-dire de construire votre interface utilisateur "à la main"), ne vous inquiétez pas de créer des constructeurs paramétrés, car ils ne sera pas utilisé. Même si vous instanciez par programme vos contrôles, vous pouvez fournir un constructeur sans paramètre afin qu'ils puissent toujours être utilisés dans le concepteur si nécessaire.

Quel que soit le paradigme que vous utilisez, il est également généralement judicieux de mettre un long code d'initialisation dans la méthode OnLoad(), d'autant plus que la propriété DesignMode fonctionnera au moment du chargement, mais ne fonctionnera pas dans le constructeur.

Je recommande

public partial class MyUserControl : UserControl
{
    private int _parm1;
    private string _parm2;

    private MyUserControl()
    {
        InitializeComponent();
    }

    public MyUserControl(int parm1, string parm2) : this()
    {
        _parm1 = parm1;
        _parm2 = parm2;
    }
}

De cette façon, le constructeur de base est toujours appelé en premier et toutes les références aux composants sont valides.

Vous pouvez alors surcharger le ctor public si nécessaire, en vous assurant que le contrôle est toujours instancié avec les valeurs correctes.

De toute façon, vous vous assurez que le ctor sans paramètre n'est jamais appelé.

Je n'ai pas testé cela, donc si ça tombe, je m'excuse!

C'est malheureusement un problème de conception qui se produira fréquemment, pas seulement dans l'espace de contrôle.

Il y a souvent des situations où vous devez avoir un constructeur sans paramètre, même si un constructeur sans paramètre n'est pas idéal. Par exemple, de nombreux types de valeur, IMO, seraient mieux sans constructeurs sans paramètres, mais il est impossible d'en créer un qui fonctionne de cette façon.

Dans ces situations, vous devez simplement concevoir le contrôle/composant de la meilleure manière possible. L'utilisation de paramètres par défaut raisonnables (et de préférence les plus courants) peut aider considérablement, puisque vous pouvez au moins (espérons-le) initialiser le composant avec une bonne valeur.

Essayez également de concevoir le composant de manière à pouvoir modifier ces propriétés une fois le composant généré. Avec les composants Windows Forms, c'est généralement bien, car vous pouvez à peu près tout faire jusqu'au temps de chargement en toute sécurité.

Encore une fois, je suis d'accord - ce n'est pas idéal, mais c'est juste quelque chose que nous avoir à vivre avec et travailler autour.

Eh bien, en bref, le concepteur est le genre de gars qui aime les constructeurs sans paramètres. Donc, au meilleur de ma connaissance, si vous voulez vraiment utiliser des constructeurs basés sur des paramètres, vous êtes probablement coincé avec le contourner d'une manière ou d'une autre.

Fournissez un constructeur sans paramètre pour le concepteur et rendez - le privé-si vous devez vraiment le faire de cette façon... :-)

EDIT: bien sûr, cela ne fonctionnera pas pour UserControls. Je ne pensais pas clairement. Le concepteur doit exécuter le code dans InitializeComponent () et cela ne peut pas fonctionner si le constructeur est privé. Désolé à ce sujet. Il Ne fonctionne pour les formulaires, cependant.

Faites simplement ceci:

public partial class MyUserControl : UserControl
{
    public MyUserControl() : this(-1, string.Empty)
    {
    }

    public MyUserControl(int parm1, string parm2)
    {
        // We'll do something with the parms, I promise
        if (parm1 == -1) { ... }
        InitializeComponent();
    }
}

Alors le constructeur 'réel' peut agir en conséquence.

Cela fait un certain temps que la question a été posée, mais peut-être que mon approche est utile à quelqu'un.

Personnellement, je préfère aussi utiliser les Constructeurs paramétrés pour éviter d'oublier de définir une certaine propriété.

Donc, au lieu d'utiliser le constructeur réel, je définis simplement un public void PostConstructor où toutes les choses sont mises que vous mettriez normalement dans le constructeur. Ainsi, le constructeur réel de UserControl ne contient toujours que InitializeComponent () . De cette façon, vous n'avez pas besoin d'ajuster votre paradigme de programmation préféré aux besoins de VisualStudios pour exécuter correctement le concepteur. Pour que ce schéma de programmation fonctionne, il doit être suivi tout en bas.

En pratique, ce PostConstructionalizm ressemblerait un peu à ceci: Commençons par un contrôle au bas de votre hiérarchie D'appels UserControl.

public partial class ChildControl : UserControl
{
  public ChildControl()
  {
    InitializeComponent();
  }

  public void PostConstructor(YourParameters[])
  {
      //setting parameters/fillingdata into form
  }
}

Donc, un UserControl contenant le ChildControl ressemblerait à quelque chose comme que:

public partial class FatherControl : UserControl
{
  public FatherControl()
  {
    InitializeComponent();
  }

  public void PostConstructor(YourParameters[])
  {
      ChildControl.PostConstructor(YourParameters[])
      //setting parameters/fillingdata into form
  }
}

Et enfin un formulaire appelant l'un des contrôles utilisateur place simplement le PostConstructor après InitializeComponent .

public partial class UI : Form
{
  public UI(yourParameters[])
  {
    InitializeComponent();
    FatherControl.PostConstructor(yourParameters[]);
  }
}

J'ai un moyen de le contourner.

1. créez un contrôle A sur le formulaire avec le constructeur sans paramètre.
2. créez un contrôle B avec un constructeur paramétré sous la forme contstructor.
3. copier la position et la taille de A à B.
4. Faire un invisible.
5. Ajouter B au parent de A.

J'espère que cela aidera. Je viens de rencontrer la même question et j'ai essayé et testé cette méthode.

Code pour démontrer:

public Form1()
{
    InitializeComponent();
    var holder = PositionHolderAlgorithmComboBox;
    holder.Visible = false;
    fixedKAlgorithmComboBox = new MiCluster.UI.Controls.AlgorithmComboBox(c => c.CanFixK);
    fixedKAlgorithmComboBox.Name = "fixedKAlgorithmComboBox";
    fixedKAlgorithmComboBox.Location = holder.Location;
    fixedKAlgorithmComboBox.Size = new System.Drawing.Size(holder.Width, holder.Height);
    holder.Parent.Controls.Add(fixedKAlgorithmComboBox);
}

Le titulaire est le contrôle A, fixedKAlgorithmComboBox est le contrôle B.

Une solution encore meilleure et complète serait d'utiliser reflect pour copier les propriétés une par une de A à B. Pour le moment, je suis occupé et je ne le fais pas. Peut-être qu'à l'avenir, je reviendrai avec le code. Mais ce n'est pas si difficile et je crois que vous pouvez le faire vous-même.

J'ai eu un problème similaire en essayant de passer un objet créé dans le formulaire Windows principal à un formulaire UserControl personnalisé. Ce qui a fonctionné pour moi était d'ajouter une propriété avec une valeur par défaut à UserControl.Designer.cs et le mettre à jour après L'appel InitializeComponent() dans le formulaire principal. Ayant une valeur par défaut empêche WinForms concepteur de lancer un "Objet de référence non définie à une instance d'un objet" erreur.

Exemple:

// MainForm.cs
public partial class MainForm : Form
   public MainForm() 
   {
     /* code for parsing configuration parameters which producs in <myObj> myConfig */
     InitializeComponent();
     myUserControl1.config = myConfig; // set the config property to myConfig object
   }

//myUserControl.Designer.cs
partial class myUserControl
{
    /// <summary> 
    /// Required designer variable.
    /// </summary>
    private System.ComponentModel.IContainer components = null;

    /// <summary> 
    /// Clean up any resources being used.
    /// </summary>
    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
    protected override void Dispose(bool disposing)
    {
        if (disposing && (components != null))
        {
            components.Dispose();
        }
        base.Dispose(disposing);
    }

    // define the public property to hold the config and give it a default value
    private myObj _config = new myObj(param1, param2, ...);      
    public myObj config
    {
        get
        {
            return _config ;
        }
        set
        {
            _config = value;
        }
    }

    #region Component Designer generated code
    ...
}

Espérons que cela aide!