Passing int array as parameter in web user control

I have an int array as a property of a Web User Control. I'd like to set that property inline if possible using the following syntax:

<uc1:mycontrol runat="server" myintarray="1,2,3" />

This will fail at runtime because it will be expecting an actual int array, but a string is being passed instead. I can make `myintarray` a string and parse it in the setter, but I was wondering if there was a more elegant solution.

Have you tried looking into Type Converters? This page looks worth a look:

[To see links please register here]

Also, Spring.Net seems to have a StringArrayConverter (

[To see links please register here]

- section 6.4) which, if you can feed it to ASP.net by decorating the property with a TypeConverter attribute, might work..

Seems to me that the logical—and more extensible—approach is to take a page from the `asp:` list controls:

<uc1:mycontrol runat="server">
<uc1:myintparam>1</uc1:myintparam>
<uc1:myintparam>2</uc1:myintparam>
<uc1:myintparam>3</uc1:myintparam>
</uc1:mycontrol>

Do do what Bill was talking about with the list you just need to create a List<int> property on your user control. Then you can implement it as Bill described.

To add child elements that make your list you need to have your control setup a certain way:

[ParseChildren(true, "Actions")]
[PersistChildren(false)]
[ToolboxData("<{0}:PageActionManager runat=\"server\" ></PageActionManager>")]
[NonVisualControl]
public class PageActionManager : Control
{


The Actions above is the name of the cproperty the child elements will be in. I use an ArrayList, as I have not testing anything else with it.:

private ArrayList _actions = new ArrayList();
public ArrayList Actions
{
get
{
return _actions;
}
}

when your contorl is initialized it will have the values of the child elements. Those you can make a mini class that just holds ints.

You could add to the page events inside the aspx something like this:

<script runat="server">
protected void Page_Load(object sender, EventArgs e)
{
YourUserControlID.myintarray = new Int32[] { 1, 2, 3 };
}
</script>

You can implement a type converter class that converts between int array and string data types.
Then decorate your int array property with the TypeConverterAttribute, specifying the class that you implemented. Visual Studio will then use your type converter for type conversions on your property.

@mathieu, thanks so much for your code. I modified it somewhat in order to compile:

public class IntArrayConverter : System.ComponentModel.TypeConverter
{
public override bool CanConvertFrom(System.ComponentModel.ITypeDescriptorContext context, Type sourceType)
{
return sourceType == typeof(string);
}
public override object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
{
string val = value as string;
string[] vals = val.Split(',');
System.Collections.Generic.List<int> ints = new System.Collections.Generic.List<int>();
foreach (string s in vals)
ints.Add(Convert.ToInt32(s));
return ints.ToArray();
}
}

Implement a type converter, here is one, warning : quick&dirty, not for production use, etc :

public class IntArrayConverter : System.ComponentModel.TypeConverter
{
public override bool CanConvertFrom(System.ComponentModel.ITypeDescriptorContext context, Type sourceType)
{
return sourceType == typeof(string);
}
public override object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
{
string val = value as string;
string[] vals = val.Split(',');
System.Collections.Generic.List<int> ints = new System.Collections.Generic.List<int>();
foreach (string s in vals)
ints.Add(Convert.ToInt32(s));
return ints.ToArray();
}
}

and tag the property of your control :

private int[] ints;
[TypeConverter(typeof(IntsConverter))]
public int[] Ints
{
get { return this.ints; }
set { this.ints = value; }
}

You could also do something like this:


namespace InternalArray
{
/// <summary>
/// Item for setting value specifically
/// </summary>

public class ArrayItem
{
public int Value { get; set; }
}

public class CustomUserControl : UserControl
{

private List<int> Ints {get {return this.ItemsToList();}
/// <summary>
/// set our values explicitly
/// </summary>
[PersistenceMode(PersistenceMode.InnerProperty), TemplateContainer(typeof(List<ArrayItem>))]
public List<ArrayItem> Values { get; set; }

/// <summary>
/// Converts our ArrayItem into a List<int>
/// </summary>
/// <returns></returns>
private List<int> ItemsToList()
{
return (from q in this.Values
select q.Value).ToList<int>();
}
}
}

which will result in:

<xx:CustomUserControl runat="server">
<Values>
<xx:ArrayItem Value="1" />
</Values>
</xx:CustomUserControl>