[C#] Generic Dictionary and Rectangle

[Thorsten (Gast)]

Hallo, ich arbeite mich weiter in C# ein und komme bei meinem 
generischen Wörterbuch. In meiner Übung möchte ich mir eine Erweiterung 
für die Klasse Rectangle erstellen, damit ich später hoffentlich 
komfortabler die Daten an das Rechteck binden kann, dazu möchte ich das 
generische Wörterbuch benutzen.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Drawing;

namespace GenericDict
{

    public class MyRectangle
    {
        
        public MyRectangle(int id, string name, Rectangle rect, Color colour)
        {
            ID = id;
            Name = name;
            Rect = rect;
            Colour = colour;
            //Draw = draw

        }

        private int m_id;

        public int ID
        {
            get { return m_id; }
            set { m_id = value; }
        }

        private string m_name;

        public string Name
        {
            get { return m_name; }
            set { m_name = value; }
        }
   
                private Rectangle m_rect;

                public Rectangle Rect
                {
                    get { return m_rect; }
                    set { m_rect = value; }
                }

        private Color m_colour;

                public Color Colour
                {
                    get { return m_colour; }
                    set { m_colour = value; }
                }
       
    }


    class Program
    {
        static void Main(string[] args)
        {


            List<int> myInts = new List<int>();

            myInts.Add(1);
            myInts.Add(2);
            myInts.Add(3);

            for (int i = 0; i < myInts.Count; i++)
            {
                Console.WriteLine("MyInts: {0}", myInts[i]);
            }

            Dictionary<int, MyRectangle> MyRectangles = new Dictionary<int, MyRectangle>();

            MyRectangle rect1 = new MyRectangle(1, "Rect 1", Rectangle, Color.Green);             
           
            MyRectangles.Add(rect1.ID, rect1);
           

            foreach (KeyValuePair<int, MyRectangle> MyKeyVal in MyRectangles)
            {
                Console.WriteLine(
                    "My ID: {0}, Name: {1} Color: {2}",
                    MyKeyVal.Key,
                    MyKeyVal.Value.Name, MyKeyVal.Value.Colour);
            }

            Console.ReadKey();
        
        
        }
    }
}

Die Zeile mit dem erstellen des Eintrag macht mir Proleme. Name und 
Farbe funktioniert wunderbar, aber wie komme ich nun an die 
Eigenschaften vom Rechteck? Ich möchte die Position X, Y, Höhe, Breite 
verändern, aber ein Zugriff klappt nicht.

MyRectangle rect1 = new MyRectangle(1, "Rect 1", Rectangle.X.Value = 1, Color.Green);

Kann mir jemand ein Tipp geben?

[Dennis R. (dennis_r93)]

Du erstellst erst ein neues Rechteck als separates Objekt mit deinen 
gewünschten Eigenschaften.
Dieses Rechteck übergibst du dann an den Konstruktor.

[Lang (Gast)]

Wo erstellst du ein Objekt vom Typ Rectangle?
Und wo befüllst du dann dieses Objekt?

Bin ein bisschen raus auf C# und hab keine IDE hier, daher aus dem Bauch 
heraus:

Rectangle r = new Rectangle();
r.X.Value = blah;

MyRectangle rect1 = new MyRectangle(1, "Rect 1", r, Color.Green);

Und auf jeden Fall noch mit folgenden Beschäftigen:

Interfaces

Grundregel 1: Programming against an interface not an implementation!!!

[Thorsten (Gast)]

Super, Vielen Dank, ohne ein Objekt vom Typ Rectangle wird es schwer was 
zu schreiben, jetzt klappt es.

Ok, die Sache mit den Interfaces kommt als nächstes dran.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Drawing;

namespace GenericDict
{

    public class MyRectangle
    {
        
        public MyRectangle(int id, string name, Rectangle rect, Color colour)
        {
            ID = id;
            Name = name;
            Rect = rect;
            Colour = colour;
            //Draw = draw

        }

        private int m_id;

        public int ID
        {
            get { return m_id; }
            set { m_id = value; }
        }

        private string m_name;

        public string Name
        {
            get { return m_name; }
            set { m_name = value; }
        }
   
                private Rectangle m_rect;

                public Rectangle Rect
                {
                    get { return m_rect; }
                    set { m_rect = value; }
                }

        private Color m_colour;

                public Color Colour
                {
                    get { return m_colour; }
                    set { m_colour = value; }
                }
       
    }


    class Program
    {
        static void Main(string[] args)
        {


            List<int> myInts = new List<int>();

            myInts.Add(1);
            myInts.Add(2);
            myInts.Add(3);

            for (int i = 0; i < myInts.Count; i++)
            {
                Console.WriteLine("MyInts: {0}", myInts[i]);
            }

            Dictionary<int, MyRectangle> MyRectangles = new Dictionary<int, MyRectangle>();
            Rectangle r = new Rectangle();
            r.X = 10;
            r.Y = 10;
            r.Height = 10;
            r.Width = 15;

            MyRectangle rect1 = new MyRectangle(1, "Rect 1", r,  Color.Green);             
           
            

            MyRectangles.Add(rect1.ID, rect1);
           

            foreach (KeyValuePair<int, MyRectangle> MyKeyVal in MyRectangles)
            {
                Console.WriteLine(
                    "My ID: {0}, Name: {1} Color: {2} Rect{3}",
                    MyKeyVal.Key,
                    MyKeyVal.Value.Name, MyKeyVal.Value.Colour,MyKeyVal.Value.Rect);
            }

            Console.ReadKey();
        
        
        }
    }
}

[Thorsten (Gast)]

Hallo, ich hab mir nun viele Beispiele und Tutorials durchgelesen zu 
Interfaces. Ich bin mir noch etwas unsicher, ob ich den Wink auf 
Interfaces für meine Aufgabenstellung richtig verstanden hab.

Mit dem Interface kann ich mir neue Eigenschaften zur Rechteckklasse 
schaffen, wie z.B. eine ID, Farbe und Anzeige, wenn ich nun andere 
Geometrien wie Kreis, Elipse Dreieck, dann könnte ich die sehr leicht 
über das Interface mit den gleichen Eigenschaften meines Rechteckes 
generieren.

Stimmt soweit mein Verständnis?

[Lang (Gast)]

Ja, im Grunde ist es wie mit dem Leben.

Ein Interface ist ein Vertrag. Die Grundlage eines jeden Handelns.
Mit dem Vertrag beschreibst du nur, was dein Objekt nachher können soll 
und nicht wie es das umsetzt.

Wie du schon sagtest, du definierst bspw. Farbe, Umfang, Fläche als 
Attribut in einem Interface. Dann muss deine Klasse später diese 
Attribute implementieren, wie genau, das ist dann Aufgabe der Klasse.

In einem generischen Dictionary kannst du dann alle Objekte ablegen, die 
deinem Vertrag entsprechen. Egal ob Kreis, Rechteck oder was auch immer. 
Denn dir ist beispielsweise nur wichtig, die Flächen zu haben.

Wenn man erstmal alles unter Vertrag gestellt hat, ist man bald sehr 
flexibler wenn es um Erweiterungen geht.

Daher auch bei einfachen Sachen erstmal angewöhnen einen Vertrag zu 
erstellen, dann geht das einem in Fleisch und Blut über und steht nicht 
mehr wie ein Ochs vorm Berg, wenn es komplizierter wird.

Gleiches gilt im übrigen auch im .NET Framework, dort gab/gibt es 
Interfaces wie bspw. IDictionary. Denn nach welchen Algorithmen nachher 
das Dictionary umgesetzt wird, ist erstmal egal.
Man kann dann bspw. bei Anwendungsstart in einer Factory ein Objekt 
welches IDictionary implementiert erstellen, je nachdem was man für 
einen Anwendungsfall hat. Die eine Umsetzung des Dictionary ist evtl. 
beim Füllen schneller, jedoch beim Auslesen langsamer, ein anderes genau 
anders herum.

Ich hoffe du erkennst die Vorteile von Schnittstellen (aber auch ein 
paar Nachteile wie erstmaliger Mehraufwand und etwas komplexer)

[Thorsten (Gast)]

Hallo, danke für deine Antwort.

Ja der Mehraufwand ist erstmal gegeben, aber dafür schaffe ich so die 
Möglichkeit der Vielfachvererbung.

Ich fühle mich noch etwas unsicher, aber das Prinzip hab ich wohl 
verstanden. Etwas schwierig finde ich noch den Unterschied zwischen 
Abstrakte Klasse und Interfaces. In den Beispielen sehen Sie noch sehr 
identisch aus, deshalb hapert es noch etwas, trotzdem werde ich meine 
jetztige Klasse als Interface auslegen, damit ich mehr Erfahrung sammle 
und parallel die Möglichkeit erhalte besser das Interface zuerweiteren 
um nicht später nochmal alles neu zumachen.

[c# (Gast)]

Meine persönliche Meinung:

Für Anfänger ist die Verwendung von Interfaces sinnlos und nur zu 
schreibender Mehraufwand. Der Einsatz von Interfaces ist erst sinnvoll 
und zwingend notwendig wenn man konsequent in der Anwendung auf einen DI 
Container wie zum Beispiel Autofac oder Ninject setzt. Ohne die 
Verwendung des Paradigmas Inversion of Control sollte man sich erstmal 
anderen Thematiken der Sprache C# zuwenden...