... deploying BlogEngine.NET (your looking at it atm) and playing with some elements of the BlogEngine source code - Which whilst wonderfully functional - is somewhat lacking in quality. 

Cases in point: 

• No unit tests....  (what? are we to just assume alterations to functionality just work?)
• Isn't exactly optimized... (yes, with 10 minutes work, I already increased the speed of several areas by upto a factor of 3...)
• Contains very little to no comments... or change history... (Who was that masked coder??)
• the XML technology isn't well implemented... Big glaring example... schema anybody?
• ....

Hey guys... how about a clean-up iteration or two? 

For 'spaz99'

Sometimes as you may already know, custom controls can become somewhat large. With many features and abilities that need to be configured as part of their usual operation, usually this is done via the use of custom attributes. However this does get unwieldy on the larger objects.

M$ not being altogether immune from practicality catered for this with ASP.NET by providing the [PersistenceMode(PersistenceMode.InnerProperty)] attribute.  This allows us to move sizeable attributes to inner XML based elements instead, while being able to retain the properties in our objects.

An example of which is given below.

namespace InnerPropControlExample
{
    using System.Collections;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Web.UI;
    using System.Web.UI.WebControls;
       
    [ToolboxData(@"<{0}:InnerPropControl runat=""server"">        
    <Parameters>
        <Param Name=""param1"" Value=""value1"" />
        <Param Name=""param2"" Value=""value2"" />
        <Param Name=""param3"" Value=""value3"" />
    </Parameters>
</{0}:InnerPropControl>")]
    public class InnerPropControl : WebControl
    {
        /// <summary>
        /// Holds the parameters during object lifetime
        /// </summary>
        private ParamCollection _par;

        /// <summary>
        /// Gets or sets the parameters.
        /// </summary>
        /// <value>The parameters.</value>
        /// MRW: 21/02/2007 
        [Browsable(false)]
        public ParamCollection Parameters
        {
            set { this._par = value; }
            get { return this._par; }
        }

        /// <summary>
        /// Renders the control to the specified HTML writer.
        ///   -- In this case it simply renders out the name/value parameers
        /// </summary>
        /// <param name="writer">The HtmlTextWriter that receives the content.</param>
        protected override void Render(HtmlTextWriter writer)
        {
            foreach( Param par in this._par )
                writer.Write("{0} = {1}<br/>\n", par.Name, par.Value);

            base.Render(writer);
        }
    }

    /// <summary>
    /// A basic Name/Value container
    /// </summary>
    [PersistenceMode(PersistenceMode.InnerProperty)]
    public class Param
    {
        public string Name;
        public string Value;
    }

    /// <summary>
    /// A collection for the Name/Value container
    /// </summary>
    [PersistenceMode(PersistenceMode.InnerProperty)]
    public class ParamCollection : IList<Param>
    {
        private List<Param> _col = new List<Param>();

        /// <summary>
        /// Sets the parameters as they are added by ASP.NET
        /// </summary>
        /// <value>The param.</value>
        public Param Param
        {
            set { this._col.Add(value); } // notice the Add!
        }

        // Everything below is pretty much standard...

        Param IList<Param>.this[int index]
        {
            get { return this._col[index]; }
            set { this._col[index] = value; }
        }
        int IList<Param>.IndexOf(Param item)
        {
            return this._col.IndexOf(item);
        }
        void IList<Param>.Insert(int index, Param item)
        {
            this._col.Insert(index, item);
        }
        void IList<Param>.RemoveAt(int index)
        {
            this._col.RemoveAt(index);
        }
        void ICollection<Param>.Add(Param item)
        {
            this._col.Add(item);
        }
        void ICollection<Param>.Clear()
        {
            this._col.Clear();
        }
        bool ICollection<Param>.Contains(Param item)
        {
            return this._col.Contains(item);
        }
        void ICollection<Param>.CopyTo(Param[] array, int arrayIndex)
        {
            this._col.CopyTo(array, arrayIndex);
        }
        int ICollection<Param>.Count
        {
            get { return this._col.Count; }
        }
        bool ICollection<Param>.IsReadOnly
        {
            get { return false; }
        }
        bool ICollection<Param>.Remove(Param item)
        {
            return this._col.Remove(item);
        }
        public IEnumerator<Param> GetEnumerator()
        {
            return this._col.GetEnumerator();
        }
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this._col.GetEnumerator();
        }
    }
}