asp.net - tutorial - Al pasar int array como parámetro en el control de usuario web

tutorial django

Question

Tengo una matriz int como propiedad de un control de usuario web. Me gustaría establecer esa propiedad en línea si es posible usando la siguiente sintaxis:

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

Esto fallará en tiempo de ejecución porque esperará una matriz int real, pero en su lugar se pasa una cadena. Puedo hacer myintarray una cadena y analizarlo en el setter, pero me preguntaba si había una solución más elegante.

Answer 1

¿Has intentado buscar Convertidores de Tipo? Esta página se ve digna de ver: http://www.codeguru.com/columns/VB/article.php/c6529/

Además, Spring.Net parece tener un StringArrayConverter ( http://www.springframework.net/doc-latest/reference/html/objects-misc.html - sección 6.4) que, si puede alimentarlo a ASP.net por decorar la propiedad con un atributo TypeConverter, podría funcionar ...

Answer 2

@mathieu, muchas gracias por tu código. Lo modifiqué un poco para compilar:

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();
    }
}

Answer 3

Gran fragmento @mathieu. Necesitaba usar esto para convertir longs, pero en lugar de hacer un LongArrayConverter, escribí una versión que usa Generics.

public class ArrayConverter<T> : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
    {
        return sourceType == typeof(string);
    }

    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
    {
        string val = value as string;
        if (string.IsNullOrEmpty(val))
            return new T[0];

        string[] vals = val.Split('','');
        List<T> items = new List<T>();
        Type type = typeof(T);
        foreach (string s in vals)
        {
            T item = (T)Convert.ChangeType(s, type);
            items.Add(item);
        }
        return items.ToArray();
    }
}

Esta versión debería funcionar con cualquier tipo que sea convertible de cadena.

[TypeConverter(typeof(ArrayConverter<int>))]
public int[] Ints { get; set; }

[TypeConverter(typeof(ArrayConverter<long>))]
public long[] Longs { get; set; }

[TypeConverter(typeof(ArrayConverter<DateTime))]
public DateTime[] DateTimes { get; set; }

Answer 4

Haga lo que Bill estaba hablando con la lista, solo necesita crear una propiedad de Lista en su control de usuario. Entonces puedes implementarlo como Bill describió.

Answer 5

Implemente un convertidor de tipo, aquí hay uno, advertencia: rápido y sucio, no para uso de producción, 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();
    }
}

y marque la propiedad de su control:

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

Answer 6

Me parece que el enfoque lógico y más extensible es tomar una página de los controles asp: list:

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

Answer 7

Para agregar elementos secundarios que conforman su lista, debe tener su configuración de control de cierta manera:

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

Las Acciones anteriores son el nombre de la propiedad en la que estarán los elementos secundarios. Utilizo una ArrayList, ya que no he probado nada con ella:

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

cuando su contorl se inicializa tendrá los valores de los elementos secundarios. Aquellos que puedan hacer una mini clase que solo contenga ints.

Answer 8

Podría agregar a los eventos de la página dentro del aspx algo como esto:

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

Answer 9

Puede implementar una clase de convertidor de tipo que convierta entre matriz int y tipos de datos de cadena. A continuación, decore su propiedad int array con TypeConverterAttribute, especificando la clase que implementó. Visual Studio luego usará su convertidor de tipo para conversiones de tipo en su propiedad.

Answer 10

También podrías hacer algo como esto:

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>();
        }
    }
}

que dará como resultado:

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