[C#] Contrôles personnalisés ASP.NET - Composites


Answers

Voici une autre méthode d'extension que j'utilise pour le rendu personnalisé:

 public static void WriteControls
        (this HtmlTextWriter o, string format, params object[] args)
 { 
    const string delimiter = "<2E01A260-BD39-47d0-8C5E-0DF814FDF9DC>";
    var controls  = new Dictionary<string,Control>();

    for(int i =0; i < args.Length; ++i)
    { 
       var c = args[i] as Control; 
       if (c==null) continue;
       var guid = Guid.NewGuid().ToString();
       controls[guid] = c;
       args[i] = delimiter+guid+delimiter;
    }

    var _strings = string.Format(format, args)
                         .Split(new string[]{delimiter},
                                StringSplitOptions.None);
    foreach(var s in _strings)
    { 
       if (controls.ContainsKey(s)) 
           controls[s].RenderControl(o);
       else 
           o.Write(s);
    }
}

Ensuite, pour afficher un composite personnalisé dans la méthode RenderContents (), j'écris ceci:

protected override void RenderContents(HtmlTextWriter o)
{ 
    o.WriteControls
         (@"<table>
               <tr>
                    <td>{0}</td>
                    <td>{1}</td>
               </tr>
             </table>"
            ,Text
            ,control1);
 }
Question

Résumé

Salut à tous,
OK, plus loin dans mes aventures avec des contrôles personnalisés ...

En résumé, voici que j'ai appris de trois "classes" principales de contrôles personnalisés. N'hésitez pas à me corriger si cela est faux!

  1. UserControls - Qui héritent de UserControl et sont contenues dans un fichier ASCX . Ceux-ci sont assez limités dans ce qu'ils peuvent faire, mais sont un moyen rapide et léger d'obtenir une certaine communalité de l'interface utilisateur avec le support des concepteurs.
  2. Contrôles composites personnalisés : il s'agit de contrôles héritant de WebControl dans lesquels vous ajoutez des contrôles préexistants au contrôle dans la méthode CreateChildControls . Ceci fournit une grande flexibilité, mais manque de support de concepteur sans codage supplémentaire. Ils sont très portables, car ils peuvent être compilés dans une DLL.
  3. Commandes personnalisées rendues - Similaire aux commandes composites personnalisées, elles sont ajoutées à un projet de bibliothèque de contrôles Web. Le rendu du contrôle est entièrement contrôlé par le programmeur en remplaçant la méthode Render .

Mes pensées..

OK, donc en jouant avec des composites personnalisés, j'ai trouvé ce qui suit:

  • Vous avez peu / pas de contrôle sur la sortie HTML, ce qui rend difficile le "débogage".
  • Les CreateChildControls (et les méthodes suivantes) peuvent être réellement occupés avec Controls.Add (myControl) partout.
  • J'ai trouvé que les tableaux de rendu (que ce soit pour la mise en page ou le contenu) étaient très gênants.

Questions)..

Donc, j'admets, je suis nouveau à ce sujet, donc je pourrais être loin de certains de mes points ci-dessus.

  • Utilisez-vous des composites?
  • Avez-vous des astuces pour contrôler la sortie HTML?
  • Est-ce que vous dites juste "au diable avec lui" et allez-y et créez un contrôle rendu personnalisé?

C'est quelque chose que je tiens vraiment à avoir en tête puisque je sais combien le développement de bons contrôles peut réduire le temps de développement global.

J'attends vos réponses avec impatience ^ _ ^




J'utilise souvent des contrôles composites. Au lieu de surcharger Render ou RenderContents, attribuez à chaque Control une CssClass et utilisez des feuilles de style. Pour plusieurs Controls.Add, j'utilise une méthode d'extension:

//Controls.Add(c1, c2, c3)
static void Add(this ControlCollection coll, params Control[] controls)
 { foreach(Control control in controls) coll.Add(control);
 }

Pour un rendu rapide et sale, j'utilise quelque chose comme ceci:

writer.Render(@"<table>
                   <tr><td>{0}</td></tr>
                   <tr>
                       <td>", Text);
control1.RenderControl(writer);
writer.Render("</td></tr></table>");

Pour initialiser les propriétés de contrôle, j'utilise la syntaxe d'initialisation de propriété:

childControl = new Control {  ID="Foo"
                            , CssClass="class1"
                            , CausesValidation=true;
                           };



Vous pourriez être en mesure d'utiliser cette technique pour faciliter le design:

http://aspadvice.com/blogs/ssmith/archive/2007/10/19/Render-User-Control-as-String-Template.aspx

Fondamentalement, vous créez une instance d'un contrôle utilisateur au moment de l'exécution à l'aide de la méthode LoadControl, puis lui remettez un étatbag, puis l'attachez à l'arbre de contrôle. Ainsi, votre contrôle composite fonctionnerait comme un contrôleur, et le fichier .ascx ressemblerait à une vue.

Cela vous éviterait d'avoir à instancier l'intégralité de l'arbre de contrôle et à styliser le contrôle en C #!