Wie Array-Länge in c # setzen dynamisch

Question

Ich bin noch neu in C # und ich habe mit verschiedenen Themen auf Arrays zu kämpfen. Ich habe eine Reihe von Metadaten-Objekten (Name Wertepaare), und ich würde gerne wissen, wie nur die Anzahl der „InputProperty“ Objekte erstellen, die ich wirklich brauchen. In dieser Schleife habe stelle ich willkürlich die Anzahl der Elemente bis 20 und ich versuche, aus der Klemme zu helfen, wenn der Eintrag null wird aber der Web-Dienst auf dem empfangenden Ende dieses mögen keine Nullelemente an sie übergeben:

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

Zusammenfassend sagt ich 3 Namevalue Paare nur in dem obigen Eingang Array? Anstatt 20 Elemente für das Array mit dem Namen IP zuweisen, wie kann codiert dies so ip nur so groß ist, wie es sein muss. Das Update-Objekt wird über eine andere Webservice übergeben so Serialisierung wichtig ist (das heißt ich kann nicht verwenden Namevaluecollection, etc.).

P. S. Ist der einzige Weg, auf eine gepostete Frage durch die „kommentieren“ Anlage followup?

Answer 1

Wenn Sie nicht über eine List, ArrayList oder andere dynamisch große Sammlung und dann konvertieren in ein Array verwendet werden soll (das ist die Methode, die ich empfehlen würde, übrigens), dann werden Sie die zuteilen müssen Array auf seine maximal mögliche Größe, zu verfolgen, wie viele Elemente, die Sie in sie setzen, und dann mit nur diese Elemente in eine neue Array erstellen:

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

Eine alternative Methode wäre, immer update.Items = ip; zuweisen und dann die Größe, falls erforderlich:

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

Es ist weniger Code, wird aber wahrscheinlich tun die gleiche Menge an Arbeit, am Ende (das heißt ein neues Array Erstellen und Kopieren der alten Artikel).

Answer 2

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

Alternativ können Sie eine Liste wie so verwenden:

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

Eine andere Sache Ich mag würde, darauf hinzuweisen, in C # Sie Ihre int-Variable Verwendung in einer for-Schleife rechts innerhalb der Schleife delcare können:

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

Und nur weil ich in der Stimmung bin, hier ist ein sauberer Weg, um diese Methode zu tun 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;
}

Answer 3

Hat wird brauchen ein Array zu sein? Wenn Sie eine Arraylist oder eines der anderen Objekte in C # verwenden, werden Sie diese Einschränkung nicht begnügen müssen mit. Hashtable, IDictionnary, IList, etc .. alles erlauben eine dynamische Anzahl von Elementen.

Answer 4

verwenden:

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

Answer 5

Sie könnten Liste verwenden innerhalb der Methode und verwandeln es am Ende zu einem Array. Aber ich denke, wenn wir etwas über einen max-Wert von 20, Code schneller sprechen.

    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 6

oder in C # 3.0 mit System.Linq Sie die Zwischenliste überspringen können:

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 7

Verwenden Array.CreateInstance ein Array dynamisch zu erstellen.

    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

Normalerweise Arrays erfordern Konstanten ihrer Größe zu initialisieren. Sie könnten einmal fegen über nvPairs die Länge zu bekommen, dann „dynamisch“ ein Array erstellen Sie eine Variable für Länge wie diese verwendet wird.

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

Ich würde es nicht empfehlen, though. Just-Stick mit dem

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

Lösung. Es ist nicht so viel weniger performant, und viel besser an.

Answer 9

Sie können ein Array erstellen auf diese Weise dynamisch:

 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];

    }