Formulaire de conception de charge Visual Studio

Question

Est-ce que quelqu'un a rencontré un problème lorsque vous avez une classe qui hérite de Forms, puis hérite de tous les formulaires de classe, puis a essayé de charger le formulaire en mode Création dans Visual Studio? Est-ce qu'il se charge correctement, parce que sur le mien il montre "Caractères illégaux dans le chemin.". J'ai couru le studio visuel en mode débogage et j'ai constaté qu'il essayait de vérifier un chemin pour le fichier je suppose et obtient le '>' de la définition générique. Donc, est-il possible de mettre en œuvre des génériques sur des formulaires Windows ou dois-je trouver une solution pour cela, j'ai cherché sur Internet des exemples ou des indices à suivre, mais je pourrais en trouver un important. Tout pointeur serait très apprécié, car l'application fonctionne bien mais pas le mode design de Visual Studio. Merci.

Classe de base

public class BaseForm<T, TU> : Form, IFormLanguageStrings 
     where T : class 
     where TU : class 
    { 
     #region Variables 

     public IApplicationValues applicationValues; 
     public T businessObject; 
     public IEventBroker eventBroker; 
     private bool hasChangesToCommit = false; 
     public ILanguageManager languageManager; 
     public IMessageBox messageBox; 
     public TU objService; 
     public DatabaseOperationType operationType; 
     public event EventHandler OnNeedToCommitChanges; 

     #endregion 

     #region Constructors 

     /// <summary> 
     /// Initializes a new instance of the <see cref="BaseForm"/> class. 
     /// </summary> 
     public BaseForm() 
     { 
      Closing += BaseForm_Closing; 
      Load += BaseForm_Load; 
      if (IsInDesignMode) return; 
      SetService(); 
     } 

     #endregion 

     #region Form Events 

     /// <summary> 
     /// Handles the Load event of the BaseForm control. 
     /// </summary> 
     /// <param name="sender">The source of the event.</param> 
     /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param> 
     private void BaseForm_Load(object sender, EventArgs e) 
     { 
      if (IsInDesignMode) return; 
      SetLabels(); 
      SetControls(); 
      LoadCombos(); 
      LoadDataForForm(); 
      ValidateDataInput(); 

      if (operationType == DatabaseOperationType.View) 
      { 
       eventBroker.Unregister(this); 
       DisableAllControls(); 
       InvisibleSelectControls("BtnAction"); 
      } 
     } 

     /// <summary> 
     /// Handles the Closing event of the BaseForm control. 
     /// </summary> 
     /// <param name="sender">The source of the event.</param> 
     /// <param name="e">The <see cref="System.ComponentModel.CancelEventArgs"/> instance containing the event data.</param> 
     private void BaseForm_Closing(object sender, CancelEventArgs e) 
     { 
      if (hasChangesToCommit) 
      { 
       if (
        messageBox.ShowQuestion(languageManager.GetString("MSG_PerformPendingOperations"), 
              MessageBoxButton.YesNo, MessageBoxResult.No) == MessageBoxResult.Yes) 
       { 
        RaiseCommitChanges(); 
       } 
      } 
      if (eventBroker != null) 
       eventBroker.Unregister(this); 
     } 

     #endregion 

     #region Virtual Methods 

     /// <summary> 
     /// Sets the labels. 
     /// </summary> 
     public virtual void SetLabels() 
     { 
      Controls.All().OfType<Control>().ToList().ForEach(
       ctl => 
        { 
         if (!string.IsNullOrEmpty(ctl.Name)) 
         { 
          string label = languageManager.GetString(ctl.Name); 
          if (!string.IsNullOrEmpty(label)) 
          { 
           ctl.Text = label; 
          } 
          if (ctl is ElementHost) 
          { 
           if (((ElementHost) ctl).Child is IFormLanguageStrings) 
           { 
            (((ElementHost) ctl).Child as IFormLanguageStrings).SetLabels(); 
           } 
          } 
         } 
        }); 
     } 

     /// <summary> 
     /// Sets the service. 
     /// </summary> 
     public virtual void SetService() 
     { 
      applicationValues = ServiceGateway.GetService<IApplicationValues>(); 
      languageManager = ServiceGateway.GetService<ILanguageManager>(); 
      messageBox = ServiceGateway.GetService<IMessageBox>(); 
      eventBroker = ServiceGateway.GetService<IEventBroker>(); 
      eventBroker.Register(this); 
      objService = ServiceGateway.GetService<TU>(); 
     } 

     /// <summary> 
     /// Validates the data input. 
     /// </summary> 
     public virtual void ValidateDataInput() 
     { 
     } 

     /// <summary> 
     /// Determines whether [has to commit changes] [the specified commit]. 
     /// </summary> 
     /// <param name="commit">if set to <c>true</c> [commit].</param> 
     public virtual void HasToCommitChanges(bool commit) 
     { 
      switch (operationType) 
      { 
       case DatabaseOperationType.Update: 
        hasChangesToCommit = commit; 
        break; 
      } 
     } 

     /// <summary> 
     /// Loads the combos. 
     /// </summary> 
     public virtual void LoadCombos() 
     { 
     } 

     /// <summary> 
     /// Loads the data for form. 
     /// </summary> 
     public virtual void LoadDataForForm() 
     { 
     } 

     /// <summary> 
     /// Sets the controls. 
     /// </summary> 
     public virtual void SetControls() 
     { 
     } 

     #endregion 

     #region Private Methods 

     /// <summary> 
     /// Raises the commit changes. 
     /// </summary> 
     private void RaiseCommitChanges() 
     { 
      if (OnNeedToCommitChanges != null) 
      { 
       OnNeedToCommitChanges(this, EventArgs.Empty); 
      } 
     } 

     /// <summary> 
     /// Closes the form. 
     /// </summary> 
     protected void CloseForm() 
     { 
      FireEventBroker(EventTopics.CloseMdiChild, new CloseMdiChildEventArgs(this)); 
     } 

     /// <summary> 
     /// Enables or disable controls. 
     /// </summary> 
     /// <typeparam name="T">type of control</typeparam> 
     /// <param name="isEnable">if set to <c>true</c> [is enable].</param> 
     private void EnableDisableControls<TX>(bool isEnable) where TX : Control 
     { 
      Controls.All() 
       .OfType<TX>() 
       .ToList() 
       .ForEach(ctl => ctl.Enabled = isEnable); 
     } 

     /// <summary> 
     /// Visibles or invisible all controls. 
     /// </summary> 
     /// <param name="isVisible">if set to <c>true</c> [is visible].</param> 
     private void VisibleInvisibleAllControls(bool isVisible) 
     { 
      Controls.All() 
       .OfType<Control>() 
       .ToList() 
       .ForEach(ctl => ctl.Visible = isVisible); 
     } 

     #endregion 

     #region Public Methods 

     /// <summary> 
     /// Gets a value indicating whether this instance is in design mode. 
     /// </summary> 
     /// <value> 
     ///  <c>true</c> if this instance is in design mode; otherwise, <c>false</c>. 
     /// </value> 
     public bool IsInDesignMode 
     { 
      get { return (Process.GetCurrentProcess().ProcessName == "devenv"); } 
     } 

     /// <summary> 
     /// Fires the event broker. 
     /// </summary> 
     /// <param name="eventTopic">The event topic.</param> 
     /// <param name="eventArgs">The <see cref="System.EventArgs"/> instance containing the event data.</param> 
     public void FireEventBroker(string eventTopic, EventArgs eventArgs) 
     { 
      eventBroker.Fire(eventTopic, this, eventArgs); 
     } 

     /// <summary> 
     /// Clears all bindings. 
     /// </summary> 
     public void ClearAllBindings() 
     { 
      Controls.All().OfType<Control>().ToList().ForEach(
       ctl => { if (ctl.DataBindings.Count != 0) ctl.DataBindings.Clear(); }); 
     } 

     /// <summary> 
     /// Enables all controls. 
     /// </summary> 
     public void EnableAllControls() 
     { 
      EnableDisableAllControls(true); 
     } 

     /// <summary> 
     /// Disables all controls. 
     /// </summary> 
     public void DisableAllControls() 
     { 
      EnableDisableAllControls(false); 
     } 

     /// <summary> 
     /// Enables or disable all controls. 
     /// </summary> 
     /// <param name="isEnable">if set to <c>true</c> [is enable].</param> 
     private void EnableDisableAllControls(bool isEnable) 
     { 
      Controls.All() 
       .OfType<Control>() 
       .ToList() 
       .ForEach(ctl => ctl.Enabled = isEnable); 
     } 

     /// <summary> 
     /// Enables all buttons. 
     /// </summary> 
     public void EnableAllButtons() 
     { 
      EnableDisableControls<Button>(true); 
     } 

     /// <summary> 
     /// Disables all buttons. 
     /// </summary> 
     public void DisableAllButtons() 
     { 
      EnableDisableControls<Button>(false); 
     } 

     /// <summary> 
     /// Enables all text boxes. 
     /// </summary> 
     public void EnableAllTextBoxes() 
     { 
      EnableDisableControls<TextBox>(true); 
     } 

     /// <summary> 
     /// Disables all text boxes. 
     /// </summary> 
     public void DisableAllTextBoxes() 
     { 
      EnableDisableControls<TextBox>(false); 
     } 

     /// <summary> 
     /// Enables the select controls. 
     /// </summary> 
     /// <param name="controlNames">The control names.</param> 
     public void EnableSelectControls(params string[] controlNames) 
     { 
      EnableDisableSelectedControls(true, controlNames); 
     } 

     /// <summary> 
     /// Disables the select controls. 
     /// </summary> 
     /// <param name="controlNames">The control names.</param> 
     public void DisableSelectControls(params string[] controlNames) 
     { 
      EnableDisableSelectedControls(false, controlNames); 
     } 

     /// <summary> 
     /// Enables or disable selected controls. 
     /// </summary> 
     /// <param name="isEnable">if set to <c>true</c> [is enable].</param> 
     /// <param name="controlNames">The control names.</param> 
     public void EnableDisableSelectedControls(bool isEnable, params string[] controlNames) 
     { 
      Controls.All() 
       .OfType<Control>() 
       .ToList() 
       .ForEach(ctl => { if (controlNames.Contains(ctl.Name)) ctl.Enabled = isEnable; }); 
     } 

     /// <summary> 
     /// Visibles the select controls. 
     /// </summary> 
     /// <param name="controlNames">The control names.</param> 
     public void VisibleSelectControls(params string[] controlNames) 
     { 
      VisibleInvisibleSelectedControls(true, controlNames); 
     } 

     /// <summary> 
     /// Invisibles the select controls. 
     /// </summary> 
     /// <param name="controlNames">The control names.</param> 
     public void InvisibleSelectControls(params string[] controlNames) 
     { 
      VisibleInvisibleSelectedControls(false, controlNames); 
     } 

     /// <summary> 
     /// Visibles or invisible selected controls. 
     /// </summary> 
     /// <param name="isVisible">if set to <c>true</c> [is visible].</param> 
     /// <param name="controlNames">The control names.</param> 
     private void VisibleInvisibleSelectedControls(bool isVisible, params string[] controlNames) 
     { 
      Controls.All() 
       .OfType<Control>() 
       .ToList() 
       .ForEach(ctl => { if (controlNames.Contains(ctl.Name)) ctl.Visible = isVisible; }); 
     } 

     /// <summary> 
     /// Visibles all controls. 
     /// </summary> 
     public void VisibleAllControls() 
     { 
      VisibleInvisibleAllControls(true); 
     } 

     /// <summary> 
     /// Invisibles all controls. 
     /// </summary> 
     public void InvisibleAllControls() 
     { 
      VisibleInvisibleAllControls(false); 
     } 

     #endregion 
    } 
} 

Answer 1

Ok, donc problème est que pour le créateur de "MyForm" ne fonctionne pas:

public class MyForm : BaseForm<MyPresenter, MyView> 
    { 
     //designer doesn't work 
    } 

Solution pour cela est de créer la classe d'aide:

public class MyFormWithDesign : BaseForm<MyPresenter, MyView> 
    { 
     //designer doesn't work 
    } 

donc nous dérivons de la classe auxiliaire et non de la classe générique:

01 sur le problème

public class MyForm : MyFormWithDesign 
    { 
     //designer WORKS! 
    } 

Des détails supplémentaires peuvent être trouvés ici:
Windows Form Designer can't use a component derived from a generic class