Creating expandable property in ASP.NET web control

Wed, 2006-03-01 16:55

Today I want to show how to implement expandable property for web control(property like Font or Style in WebControl class)

For example we have class

[TypeConverter(typeof (TresholdConverter))]
      public class Threshold
      {
 
 
            private int _low=1;
            private int _high=1;
            private Color _tresholdColor;
            private bool _flash=true;
 
            public Threshold()
            {
            }
 
            public Threshold(int low, int high,
                            Color color, bool flash)
            {
                  _low = low;
                  _high = high;
                  _tresholdColor = color;
                  _flash = flash;
            }
 
            [NotifyParentProperty(true),
                  Description("Low Treshold")]
            public int Low
            {
                  get { return _low; }
                  set { _low = value; }
            }
 
            [NotifyParentProperty(true),
                  Description("High Treshold")]
            public int High
            {
                  get { return _high; }
                  set { _high = value; }
            }
 
           
            [NotifyParentProperty(true),
                  Description("Color of value when in this threshold")]
            public Color TresholdColor
            {
                  get { return _tresholdColor; }
                  set { _tresholdColor = value; }
            }
            [NotifyParentProperty(true),
                  Description("Flash")]
            public bool Flash
            {
                  get { return _flash; }
                  set { _flash = value; }
            }
     
            protected internal bool IsEmpty
            {
                  get
                  {
                        return (Low == 0
                             && High == 0 &&
                             !_flash &&
                             _tresholdColor.IsEmpty);
                  }
            }
 
            public override string ToString()
            {
                  return ToString(CultureInfo.CurrentCulture);
            }
 
            public string ToString(CultureInfo Culture)
            {
                  return TypeDescriptor.GetConverter(typeof (Threshold)).ConvertToString(null,Culture, this);
            }
            public bool IsInTreshold(int value)
            {
                  return (value<High&&value>=Low);
            }
      }

The key string in this class is [TypeConverter(typeof (TresholdConverter))]. So we are going to implement TresholdConverter class

public class TresholdConverter : ExpandableObjectConverter
      {
            public override bool CanConvertFrom(
                  ITypeDescriptorContext context, Type sourceType)
            {
                  if (sourceType == typeof (string))
                  {
                        return true;
                  }
                  return base.CanConvertFrom(context, sourceType);
            }
 
            public override bool CanConvertTo(
                  ITypeDescriptorContext context, Type targetType)
            {
                  if (targetType == typeof (string))
                  {
                        return true;
                  }
                  return base.CanConvertTo(context, targetType);
            }
 
            public override object ConvertFrom(
                  ITypeDescriptorContext context, CultureInfo culture, object value)
            {
                  if (value == null)
                  {
                        return new Threshold();
                  }
 
                  if (value is string)
                  {
                        string str = (string) value;
                        if (str == "")
                        {
                             return new Threshold();
                        }
 
                        string[] propValues = str.Split(culture.TextInfo.ListSeparator[0]);
 
                        if (propValues.Length != 4)
                        {
                             throw new ArgumentException("Invalid Treshold", "value");
                        }
                 TypeConverter colorConverter =TypeDescriptor.GetConverter(typeof (Color));
                        return new Threshold(Convert.ToInt32(propValues[2]),Convert.ToInt32(propValues[1]),
                              (Color)colorConverter.ConvertFromString(context,culture,propValues[3]),Convert.ToBoolean(propValues[4]));
                  }
 
                  return base.ConvertFrom(context, culture, value);
            }
 
            public override object ConvertTo(ITypeDescriptorContext context,
                                             CultureInfo culture, object value, Type targetType)
            {
                  if (value != null)
                  {
                        if (!(value is Threshold))
                        {
                             throw new ArgumentException("Not of type Treshold", "value");
                        }
                  }
 
                  if (targetType == typeof (string))
                  {
                        if (value == null)
                        {
                             return String.Empty;
                        }
 
                        Threshold _treshold = (Threshold) value;
                        if (_treshold.IsEmpty)
                        {
                             return String.Empty;
                        }
                      TypeConverter colorConverter =TypeDescriptor.GetConverter(typeof (Color));
                             return String.Join(culture.TextInfo.ListSeparator,
                             new string[] {_treshold.Low.ToString(),_treshold.High.ToString(),
                                                      colorConverter.ConvertToString(context,
                                                      culture, _treshold.TresholdColor),_treshold.Flash.ToString()});
                  }
 
                  return base.ConvertTo(context, culture, value, targetType);
            }
      }

It inherits from ExpandableObjectConverter class and overrides 4 his methods. Function of this class is adding value convert support to property grid for design-time.

In web control you can implement such property for example:

If you something don't understand see to MSDN or ask your question here.

Feel free to subscribe to our RSS feed.