Hilfe bei Performance (was ist schneller z.B. int[,] oder List<List<int>>)

Hallo,

ich bin zurzeit an einem Projekt beschäftigt, bei dem große Matrizen vorkommen (ca. 4000 x 4000).

Also ich habe ein Objekt: Field[,] Bsp = new Field[4000,4000] (in Field gibt es vier bool Werte)

Jetzt wollte ich fragen ob es nicht schneller ist, wenn ich List<List<Field>> benutze.

In der Matrix werden nur Werte zugewiesen bzw. geschaut auf welchem Wert sie sind.

Hoffe mir kann wer einen Ratschlag geben.

Schon mal vielen Dank

Quaneu

Hallo,

am schnellsten sind jagged Arrays T[][]

Siehe auch meine Anmerkungen dazu in Performancebetrachtungen Fortran - C# (Abschnitt Matritzenmultiplikation).

mfG Gü

Edit: Link-Anzeige

Vielen Dank für die schnelle Antwort. Werd ich mir gleich anschauen.

Also ich habe den Ausdruck Matrix aus der Mathematik einfach übernommen, denn ich brauche die X und Y Pos in einem "Bild".

Programmiere nämlich gerade an einem LineSearch Algorithmus.
Und um ein Bild zu erstellen habe ich eben eine Matrix in der Informationen stehen, ob da eine Linie oder Bauteil ist usw.

Jetzt hab ich mal geschaut, gibt es in c# jagged Arrays T[][] eiegntlich?
Weil ich das irgendwie in MSDN nicht finde...

Weil ich das irgendwie in MSDN nicht finde...

Ach nein? MSDN

Ok... vielleicht weil er nur nach deutschen "texten gesucht hat.

Vielen Dank... dann hoffe ich, dass es was bringt.

Hallo,

damit du nicht den ganzen anderen Thread lesen musst gibt es noch zwei interessante Informationen:*Vor-/Rückwertschleife *Range-Check-Elimination

Beide Punkte werden im selben Thread behandelt -> direkter Link dazu Performancebetrachtungen Fortran - C#

Wenn dies berücksichtigt wird dann gehts mit C# nicht mehr schneller 😉

mfG Gü

Vielen vielen Dank für Deine Hilfe...
Werde mir das jetzt alles zu Gemüte führen und versuchen es umzusetzen... denn ein Durchlauf dauert jetzt über 20 Min...

Nur aus reinem Interesse, wieso ist denn z.B. int[][] schneller als int[,].
Für mich (als Laie) ist das das selbe... bzw. wüsste ich nicht wieso es schneller ist.

Nur aus reinem Interesse, wieso ist denn z.B. int[][] schneller als int[,].
Für mich (als Laie) ist das das selbe... bzw. wüsste ich nicht wieso es schneller ist.

Diese Variante der rectangular Arrays ist jedoch langsamer als die Variante mit jagged Arrays. Der Grund liegt darin dass es eigene IL-Anweisungen für zero-based one dimensional Arrays gibt und diese effizient* umgesetzt werden. Beim rectangular Array erfolgt der Zugriff auf die Elemente mit Methoden die ein object zurückgeben. Daher kommt das Castingproblem eventuell auch noch dazu.

Einfacher ausgedrückt: für int[][] wird spezieller Code kompiliert der schneller ist.

mfG Gü

Ich kann mich nur nochmals für die schnelle und ausführliche Hilfe bedanken.
Dann werde ich mich jetzt mal ans umschreiben machen...

Viele Grüße

Quaneu

Nun hab ich ein Problem bei der Umstellung auf jagged Arrays T[][]. Also ich habe eine Klasse die wie folgt def. ist:

public class Field
        {
            #region private elements
            Pos[,] field;
            #endregion


            #region constructor
            public Field(int zeilen, int spalten)
            {
                field = new Pos[zeilen,spalten];


                for (int i = 0; i < zeilen; i++)
                {
                    for (int k = 0; k < spalten; k++)
                    {
                        field[i][k] = new Pos();
                    }
                }
            }
            #endregion

            public Pos this[int Y,int X]
            {
                get
                {
                    return field[Y, X];
                }
            }

            public Field Copy()
            {
                Field copy = new Field(field.GetLength(0), field.GetLength(1));

                for (int z = 0; z < field.GetLength(0); z++)
                {
                    for (int s = 0; s < field.GetLength(1); s++)
                    {
                        copy.field[z, s] = field[z, s].Copy();
                    }
                }



                return copy;
            }

            #region internal class
            public class Pos
            {
                #region constructor
                public Pos()
                {
                    L = false;
                    V = false;
                    H = false;
                    C = false;
                }
                #endregion


                public Pos Copy()
                {
                    Pos p = new Pos();
                    p.L = this.L;
                    p.V = this.V;
                    p.H = this.H;
                    p.C = this.C;
                    return p;
                }

                #region properties
                public bool V { get; set; }
                public bool H { get; set; }
                public bool C { get; set; }
                public bool L { get; set; }
                #endregion
            }
            #endregion
        }

Also im Code habe ich dann:

Field[,] raster =new Field[2000,3000];

Nun habe ich bei der Umstellung in folgedem Abschnitt ein Problem:

            public Pos this[int Y,int X]
            {
                get
                {
                    return field[Y, X];
                }
            }

Da ich auf raster[x][y] zugreifen muss.

Hallo,

Nun habe ich bei der Umstellung in folgedem Abschnitt ein Problem:

Und welches?

mfG Gü

Wie ich es umsetzte... also bei indexing des jagged Arrays.
So das ich wie bei raster[5,6].C auf den eintrag zugreifen kann eben bei raster[z]~~.C auf den entsprechenden komme.

Hallo Quaneu,

raster[i,j] entspricht bei jagged Arrays raster_[j]. Wo ist das Problem?

herbivore

Wenn ich aber raster_[j].C will klappt das nicht. Musste ja dafür bei meiner Klasse Field dafür eben

public Pos this[int Y][int X]
{
get
    {
        return field[Y][ X];
    }
}

Nur weiß ich nicht wie ich es eben bei [][] mache.

Hallo Quaneu,

für mich sieht es so aus, als würde der Thread jetzt in Richtung [Hinweis] Wie poste ich richtig? Punkt 1.1.1 und [Hinweis] Syntaxfehler selbst lösen (Compilerfehlermeldungen) gehen.

Wie du einen Indexer deklarierst und wie du ihn implementierst sind zwei Paar Schuh. Deklarieren kannst du ihn nur mehrdimensional, nicht jagged. Aber in der Implementierung eines mehrdimensional deklarierten Indexers kannst du natürlich auf ein jagged-Array zurückgreifen.

Da es dir um Performance ging, würde ich allerdings anmerken, dass so ein Wrapper sich negativ auf die Performance auswirkt. Die Gewinne durch ein jagged-Array hast du nur, wenn du auch direkt darauf zugreifst.

herbivore