Directonary oder ArrayList ?

Hallo,

Ich habe eine 2 dimensionale Array

List[int,int];

die größe des Array sind ungefähr (360,600)

Ich wollte in diesem Array bestimmte Werte immer benutzen. (z.B. die Werte, die über bestimmen Zahl liegen) Die sind ungefähr 20 Stück.

Stat immer die Array zu prüfen, wollte ich die Werte in anderen Array (List, Directonary) kopieren.

aber:

-Wenn ich Array benutze, muss ich die Größe geben.

• bei Directonary kann ich ein Key und ein Value benutzen. Bei mir habe ich 3 Werte.

Ich weiß nicht wie ich die Werte kopieren kann.

Danke

1. Vergiss ArrayList, da type unsafe
2. Es heißt Dictionary (Wörterbuch) und hat nix mit einem Verzeichnis zu tun.
3. Versuch es doch einfach mit Dictionary wenn dus schon erwähnst.

du könntest dir auch selbst so ein array oder dictionary schreiben .... mit allen funktionen die du brauchst.

wenn du dich ein bisl reinließt sollte das recht schnell gehen schwer is das ansich nicht.
hat auch einen guten lern effekt und es dann genau das was du brauchst 😁

gruß

Ich wollte so benutzen.
Punkt(x,y) und sein Wert value;

Dictionary<Punkt,int>

Aber ich kann nicht so benutzen, weil ich kein Punkt Objekt gefunden habe.

Dictionary<int,int,int> // erste zwei Parameter für x,y Koordinate und letze Paremeter sein Wert.

Ich kann auch so nicht definieren, weil Dictionary 2 Parameter hat.

wie kann ich ein Punkt mit seinem Wert speichern ?

Danke

Es gibt ein Punkt-Struct: System.Drawing.Point (oder PointF).

Ansonsten kannst du dir auch selbst eins schreiben:

private struct MyPoint
{
    private int x;

    private int y;

    public MyPoint(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    public int X
    {
        get { return x; }
        set { x = value; }
    }

    public int Y
    {
        get { return y; }
        set { y = value; }
    }

    public bool Equals(MyPoint obj)
    {
        return obj.x == x && obj.y == y;
    }

    public override bool Equals(object obj)
    {
        if (obj.GetType() != typeof (MyPoint)) return false;
        return Equals((MyPoint) obj);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            return (x*397) ^ y;
        }
    }

    public static bool operator ==(MyPoint left, MyPoint right)
    {
        return left.Equals(right);
    }

    public static bool operator !=(MyPoint left, MyPoint right)
    {
        return !left.Equals(right);
    }
}

Wichtig ist nur, dass GetHashCode überschrieben ist, da das Struct als Dictionary-Key verwendet wird. Ansonsten leidet die Performance des Dict daramatisch.

Hallo,

(Mhm, da war wer schnelelr)

Die Eigene Klasse sollte IComparable<> implementieren:

public class Koordinate : IComparable<Kooerdinate>
{
  private int x;
  private int y;
  public int X{get{return x;}set{x=value;}}
  public int Y{get{return y;}set{y=value;}}

    #region IComparable<Kooerdinate> Member

    public int CompareTo(Kooerdinate other)
    {
      if(other == null) return (int)decimal.MinusOne;
      return int.Compare(this.X,other.X)+int.Compare(this.Y,other.Y);
    }

    #endregion
}

new Dictionary<Koordinate,int>();

Gruß
Juy Juka

also am besten immer die frameworkklasse /strukt verwenden. nimm lieber "Point" da da auch einige subtraktions/additions methoden sind usw....

mir war so, als wie wenn man auch dictionaries verschachteln kann...

Dictionary <Dictionary<int,int>,int>

dann hast du deinen punkt als key und den wert am punkt als value...

so hat jedert punkt nur einen wert..

Hi,

Natürlich kann man Dictionaries verschachteln, aber das ist in diesem Fall nicht so toll, da man

1. Dann auf einer Achse jeden Wert nur einmal verwenden kann (da er ja der Key vom Dictionary ist).
2. Die Abfrage ziemlich schwierig wird.

Ich würde auch nicht System.Drawing.Point benutzen, da

1. Point ein Value-Type ist und umständliches Boxing nötig ist, um Ihn in einem Dictionary zu verwenden.
2. Point für's Zeichnen gedacht ist und man des halt System.Drawing.dll einbinden muss, die (denke ich) nichts in der Business-Logik zu suchen hat (wenn das Dictionary nur zum Zeichnen gedacht ist, nehm ich das natürlich zurück).

Gruß
Juy Juka

also...

1.1: stimmt.. weil koordinaten-system.. ich vergas... 🤔
dann würd ich doch n struct mit <int,int> machen und die dann als keys setzen...

        struct punkt
        {
            int x;
            int y;
        }
[...]
Dictionary<punkt, int> XY = new Dictionary<punkt, int>();

dann kann jedem punkt nur ein wert zugeordnet werden und alles is schick 😁

1.2: schwierig isses nich.. nur nich ganz unumständlich...

zu den drawing pionts kann ich nichts sagn...

Hallo utz-being,

Dictionary <Dictionary<int,int>,int>  

wenn dann

Dictionary <int,Dictionary<int,int>>

herbivore

hmm? einem wert n punkt zuweisen?

is das nich genauso so... "unpraktisch"?
dann is ja wieder was gezwungen eindeutig, was man eventuell mehrfach braucht ...

also ich bin in diesem fall aber von dem verschachtelten Dictionary auch nicht überzeugt.

wobei es praktisch gesehen das gleiche macht und vllt sogar noch besser wie das von utz-being vorgeschlagene bespiel.

    struct punkt  
        {  
            int x;  
            int y;  
        }  
[...]  
Dictionary<punkt, int> XY = new Dictionary<punkt, int>();  

dann kann jedem punkt nur ein wert zugeordnet werden und alles is schick

Aber persönlich würde ich mich für die struct variante entscheiden.

Ich würde auch nicht System.Drawing.Point benutzen, da

1. Point ein Value-Type ist und umständliches Boxing nötig ist, um Ihn in einem Dictionary zu verwenden.

Was meinst du? Beim Einfügen interessiert es das Dictionary herzlich wenig ob reference oder value type.

Hi,

Das Dictionary kann nur Referenztypen behandeln. Will man einen Valuetype hinein geben, muss dieser "eingekapselt" werden, das nennt man Boxing (siehe MSDN) und ist suboptimal 🙂 auch mal das wort benütz.

Gruß
Juy Juka

Das Dictionary kann nur Referenztypen behandeln.

Quelle? Der Source des Dictionary ist komplett generisch, insofern gibt es kein Boxing. Boxing gibt es nur beim Hashtable.

Hi Jabe,

Jetzt wo du fragst ... Darüber hab ich noch garnicht nachgedacht.
Keine Ahnung, ob Generics bei Valuetypen Boxing auslöst oder nicht.
Da muss ich bei Gelegenheit mal nachforschen (jetzt hab ich leider keine Zeit).

Gruß
Juy Juka

Keine Ahnung, ob Generics bei Valuetypen Boxing auslöst oder nicht.

Nein, es wird kein Boxing ausgelöst.
Wenn ich mich recht erinnere, geht das ganze sogar so weit, dass der C# Compiler bei entsprechenden Constraints IL-Code erzeugt, der bei Wertetypen Schnittstellenmethoden ohne Boxing aufruft.

Jetzt wo du fragst ... Darüber hab ich noch garnicht nachgedacht.
Keine Ahnung, ob Generics bei Valuetypen Boxing auslöst oder nicht.
Da muss ich bei Gelegenheit mal nachforschen (jetzt hab ich leider keine Zeit).

Mir gings genauso. Musste auch erstmal schnell einen kleinen Test machen. 🙂
Wie schon von winSharp93 so halb gesagt:
Die Runtime erzeugt zur Lauftzeit den entsprechenden Code, wenn sie auf einen neuen, noch nicht generierten TType trifft, von daher passiert das auch mit Wertetypen.

ist suboptimal

öhm.. darf ich mir das mal leihen? 😁

um mal ans thema zu denken:
wo is eigentlich der thread-starter?