suma - Cómo establecer la longitud de la matriz en c#dinámicamente

recorrer matriz c#

Question

Todavía soy nuevo en C # y he estado luchando con varios problemas en los arreglos. Tengo una matriz de objetos de metadatos (pares de valores de nombre) y me gustaría saber cómo crear solo el número de objetos de "propiedad de entrada" que realmente necesito. En este bucle, he establecido arbitrariamente el número de elementos en 20 y trato de rescatar cuando la entrada se vuelve nula, pero el servicio web en el extremo receptor no le gusta ningún elemento nulo pasado

private Update BuildMetaData(MetaData[] nvPairs)
{
    Update update = new Update();
    InputProperty[] ip = new InputProperty[20];  // how to make this "dynamic"
    int i;
    for (i = 0; i < nvPairs.Length; i++)
    {
        if (nvPairs[i] == null) break;
        ip[i] = new InputProperty();
        ip[i].Name = "udf:" + nvPairs[i].Name;
        ip[i].Val = nvPairs[i].Value;
    }
    update.Items = ip;
    return update;
}

En resumen, digamos que solo tengo 3 pares de valores de nombre en la matriz de entrada anterior? En lugar de asignar 20 elementos para la matriz llamada ip, cómo puede codificar esto para que ip sea tan grande como debe ser. El objeto de actualización se pasa a través de otro servicio web, por lo que la serialización es importante (es decir, no puedo usar namevaluecollection, etc.).

ps ¿Es la única forma de hacer un seguimiento de una pregunta publicada a través de la función "agregar comentarios"?

Answer 1

¿Tiene que ser una matriz? Si usa un ArrayList o uno de los otros objetos disponibles en C #, no tendrá esta limitación para el contenido. Hashtable, IDictionnary, IList, etc. permiten un número dinámico de elementos.

Answer 2

Normalmente, las matrices requieren constantes para inicializar su tamaño. Podría barrer sobre nvPairs una vez para obtener la longitud, luego crear "dinámicamente" una matriz usando una variable para longitud como esta.

InputProperty[] ip = (InputProperty[])Array.CreateInstance(typeof(InputProperty), length);

Aunque no lo recomendaría. Sólo quédate con el

List<InputProperty> ip = ...
...
update.Items = ip.ToArray();

solución. No es mucho menos eficaz, y mucho mejor aspecto.

Answer 3

O en C # 3.0 usando System.Linq puede omitir la lista intermedia:

private Update BuildMetaData(MetaData[] nvPairs)
{
        Update update = new Update();
        var ip = from nv in nvPairs
                 select new InputProperty()
                 {
                     Name = "udf:" + nv.Name,
                     Val = nv.Value
                 };
        update.Items = ip.ToArray();
        return update;
}

Answer 4

Podría usar la Lista dentro del método y transformarla en una matriz al final. Pero creo que si hablamos de un valor máximo de 20, su código es más rápido.

    private Update BuildMetaData(MetaData[] nvPairs)
    {
        Update update = new Update();
        List<InputProperty> ip = new List<InputProperty>();
        for (int i = 0; i < nvPairs.Length; i++)
        {
            if (nvPairs[i] == null) break;
            ip[i] = new InputProperty();
            ip[i].Name = "udf:" + nvPairs[i].Name;
            ip[i].Val = nvPairs[i].Value;
        }
        update.Items = ip.ToArray();
        return update;
    }

Answer 5

Puede crear una matriz dinámicamente de esta manera:

 static void Main()
    {
        // Create a string array 2 elements in length:
        int arrayLength = 2;
        Array dynamicArray = Array.CreateInstance(typeof(int), arrayLength);
        dynamicArray.SetValue(234, 0);                              //  → a[0] = 234;
        dynamicArray.SetValue(444, 1);                              //  → a[1] = 444;
        int number = (int)dynamicArray.GetValue(0);                      //  → number = a[0];


        int[] cSharpArray = (int[])dynamicArray;
        int s2 = cSharpArray[0];

    }

Answer 6

Si no desea usar una List , ArrayList u otra colección de tamaño dinámico y luego convertirla a una matriz (ese es el método que recomendaría, por cierto), entonces tendrá que asignar la matriz a su tamaño máximo posible, realice un seguimiento de la cantidad de elementos que coloca, y luego cree una nueva matriz con solo esos elementos:

private Update BuildMetaData(MetaData[] nvPairs)
{
    Update update = new Update();
    InputProperty[] ip = new InputProperty[20];  // how to make this "dynamic"
    int i;
    for (i = 0; i < nvPairs.Length; i++)
    {
        if (nvPairs[i] == null) break;
        ip[i] = new InputProperty(); 
        ip[i].Name = "udf:" + nvPairs[i].Name;
        ip[i].Val = nvPairs[i].Value;
    }
    if (i < nvPairs.Length)
    {
        // Create new, smaller, array to hold the items we processed.
        update.Items = new InputProperty[i];
        Array.Copy(ip, update.Items, i);
    }
    else
    {
        update.Items = ip;
    }
    return update;
}

Un método alternativo sería asignar siempre update.Items = ip; y luego cambiar el tamaño si es necesario:

update.Items = ip;
if (i < nvPairs.Length)
{
    Array.Resize(update.Items, i);
}

Es menos código, pero es probable que termine haciendo la misma cantidad de trabajo (es decir, creando una nueva matriz y copiando los elementos antiguos).

Answer 7

Use Array.CreateInstance para crear una matriz dinámicamente.

    private Update BuildMetaData(MetaData[] nvPairs)
    {
        Update update = new Update();
        InputProperty[] ip = Array.CreateInstance(typeof(InputProperty), nvPairs.Count()) as InputProperty[];
        int i;
        for (i = 0; i < nvPairs.Length; i++)
        {
            if (nvPairs[i] == null) break;
            ip[i] = new InputProperty();
            ip[i].Name = "udf:" + nvPairs[i].Name;
            ip[i].Val = nvPairs[i].Value;
        }
        update.Items = ip;
        return update;
    }

Answer 8

Utilizar esta:

 Array.Resize(ref myArr, myArr.Length + 5);

Answer 9

InputProperty[] ip = new InputProperty[nvPairs.Length]; 

O bien, puede utilizar una lista como tal:

List<InputProperty> list = new List<InputProperty>();
InputProperty ip = new (..);
list.Add(ip);
update.items = list.ToArray();

Otra cosa que me gustaría señalar, en C # puede descuidar su uso de la variable int en un bucle for justo dentro del bucle:

for(int i = 0; i<nvPairs.Length;i++
{
.
.
}

Y solo porque estoy de humor, aquí hay una forma más limpia de hacer este método IMO:

private Update BuildMetaData(MetaData[] nvPairs)
{
        Update update = new Update();
        var ip = new List<InputProperty>();

        foreach(var nvPair in nvPairs)
        {
            if (nvPair == null) break;
            var inputProp = new InputProperty
            {
               Name = "udf:" + nvPair.Name,
               Val = nvPair.Value
            };
            ip.Add(inputProp);
        }
        update.Items = ip.ToArray();
        return update;
}