Punkte zeichnen

Also ich möchte gerne ein paar Punkte mit Hilfe von GDI+ zeichnen dazu habe ich mir ein graphics Onjekt erszeugt:
Graphics my = this.CreateGraphics();
und dann mit der rectangle Funktion einen Punkt gezeichnet.
Das hat auch alles geklappt nur leider empfinde ich das als extrem langsam.
Gibt es eigentlich kein SetPixel oder sowas, bzw. etwas anderes um schnell mehrere Pixel zu zeichnen?

Vielen Dank für eure Antworten.

SetPixel gibt es nur bei Bitmaps. Du müsstest also auf ein Bitmap zeichnen und das in einer PictureBox anzeigen. Set/GetPixel bei Bitmaps ist aber extrem langsam!!!
Warum empfindest du das zeichnen mit GDI+ als extrem langsam? Ich muss bei meinem Projekt sehr viel zeichnen und es ist "noch zumutbar".

Naja gut um ehrlich zu sein weiß ich auch nicht ob das zeichnen so langsam ist,
wenn nicht würde da aber bedeuten das C# sehr langsam ist oder mein Compiler mieß ist (SharpDevelop-IDE).
Ich habe die beliebte mandelbrot/Apfelmännchen-rechnung gemacht.
einaml in der Schule in C (WinApi)
und gerade in C#, der Algorithmus ist der gleiche aber das in c läuft bedeutend schneller.
ich werde mal die Zeit ohne Zeichnen messen mal sehen was rauß kommt.
Will jemand wetten abschließen?

ich habe mal die Zeit gestoppt damit ihr wisst wovon ich rede:
C: 41,5 SEC
C#: >3,5 MIN
mit graphik

ich empfinde das nicht als Peanuts
also ich muss sagen ich hätte nicht gedacht das es sooo lange braucht,
es liegt anscheinend wirklich am Compiler, es ist unmöglich das die Zeichenmethide so lange braucht.
Ich bin aber trotzdem confused ich hätte erwartet das es ein Kopf an Kopf rennen gibt X(
ich werde jetzt mal mit VS2005 kompilieren.

mfg

Ich bin SCHOCKIERT:

also mit VS2005 hat das Proggie nur 33 sec. gebraucht,

das heisst für mich das SharpDevelop unbrauchbar ist für rechenintensive sachen!!
Also ich bin echt schockiert.
Schade ich war immer begeistert von #Develop. kann jemand Gründe dafür liefern??
Vlt. auch mal den Thread in ein anderes Forum schieben ha tnix mehr mit Grafik zu tun, wie ich festgestellt habe.

mfg 🙁 🙁 🙁 🙁 🙁 🙁

EDIT:
Okay der Vergleich war etwas ungerecht.
In VS war die Codeoptimierung ein und in #Develop nicht.
Also mit Codeoptimierung schafft es #Develop auch auf 1min.30 sec aber das ist trotzdem das 3 fache 🙁

Hallo MasterOfDesaster,

die IDE ist egal, für die Laufzeit kommt es nur die Compileroptionen und auf das Framework (Version) an.

herbivore

die IDE ist sicherlich egal aber, der Compiler ist entscheidend, und das ist ja nicht der selbe, einstellungen sind soweit identisch.

Hallo MasterOfDesaster,

ich gehe davon aus, dass alle IDEs den gleichen Compiler bzw. die gleichen Compiler-Klassen verwenden. Lasse mich aber auch eines besseren belehren.

herbivore

wenn VS nicht einen eigenen hat (was sehr sehr unwarscheinlich ist) verwenden beiden den mitgelieferten Compiler.

Auserdem darf man bei einem .Net Programm nicht den Ersten lauf zählen da dieser um einiges langsammer ist als die volgenden.

wenn du wilst kannst du ja mal den Code Posten dan manchen wir uns unser eigenes Bild

hier ist mal der Code:

    class Program
    {
        static void Main(string[] args)
        {
            double xmin = -0.745468;
            double xmax = -0.745385;
            double ymin = 0.112975;
            double ymax = 0.113044;

            complex Xn = new complex();
            complex C = new complex();

            int test = 0;

            for (int x = 0; x <= 1280; x++)
                for (int y = 0; y <= 1024; y++)
                {
                    C.real = ((double)x / (double)1280 * (xmax - xmin)) + xmin;
                    C.imag = ((double)y / (double)1024 * (ymax - ymin)) + ymin;


                    Xn.imag = 0;
                    Xn.real = 0;

                    for (int counter = 0; counter <= 500; counter++)
                    {
                        Xn = (Xn * Xn) + C;
                      
                        if (Xn.betragsquadr() > 4)
                        {
                            test = 1;
                            //hier würde jetzt ein roter Punkt entstehen
                            break;
                        }
                    }
                    if (test == 0)
                    {
                        //und hier würde ein schwarzer Pkt entstehen 
                    }
                    else
                        test = 0;
                }
            Console.WriteLine("Fertig");
     
        }
    }

    public class complex
    {
        public double imag;
        public double real;

        public static complex operator +(complex rhs, complex lhs)
        {
            complex result = new complex();
            result.imag = rhs.imag + lhs.imag;
            result.real = rhs.real + lhs.real;
            return result;
        }

        public static complex operator *(complex rhs, complex lhs)
        {
            complex result = new complex();
            result.real = (rhs.real * lhs.real) - (rhs.imag * lhs.imag);
            result.imag = (rhs.real * lhs.imag) + (rhs.imag * lhs.real);
            return result;
        }

        public double betragsquadr()
        {
            return (this.imag * this.imag + this.real * this.real);
        }

    }

ach ja und noch was könnte es sein das du ein Debug Build mit einem Reales verglichen hast?

so habe deinen Code mal getestet Braucht bei mit ohne optimierung ca.23,7 Sekunden mit nur 10,7 Sekunden was genau soll da langsam sein?

Du hast recht ich habe jetzt nochmal schritt für schritt alles systematisch probiert.
und ich bin jetzt bei gleichen Compiler, unterschieldicher IDE ungefähr bei den selben Werten, ich war gestern blind. 8o 8o
Im übrigen das was so lange dauert ist tatsächlich das zeichnen, das finde ich inakzeptabel.
Die berechnung geht relativ schnell.
Ich werde es mal mit Bitmaps probieren vlt. geht ds schneller.
danke für die Hilfe

Wenn du mit SetPixel Bildpunkte zeichnest, ist das natürlich langsam (wegen des Marshalling, Bereichsprüfung und der Formatkonvertierung). Schreibe lieber direkt in das Bitmap (LockBits).