Grafikprogrammierung unter .NET

[Gast]

Hallo =)

Also ... eigentlich komme ich aus dem PHP/Web Sektor, muss jetzt aber gezwungenermaßen grafisch ein paar Statistiken (flüssig in Echtzeit, d.h. GD2 auf PHP fällt flach) auswerten bzw. visualisieren. Das fängt an bei Balkendiagrammen, später auch komplexere Ringdiagramme.

Und wenn ich mich schonmal dazu komme, mich mit Softwareprogrammierung fürn PC zu beschäftigen, dann dachte ich dass ich das Ganze gewissenhaft mache und so neben PHP auch noch ne neue Sprache kennenlerne.

Kurz und knapp: C++ ist imho etwas overkill, vb und delphi aber zu simpel. Nach recherchieren stand ich vor der Wahl: Java oder C#.
Da ich durch einen bekannten an 2 C#/.NET Bücher kam, habe ich mich dann dafür entschieden.

Soweit, so gut. Mittlerweile hab ichs schon geschafft mich in die grundlegenden Dinge einzulesen, sowie die Statistikdaten in XML-Form von einem Server zu holen und zu parsen. Was jetzt kommt, ist eben der grafische Teil, und da Blick ich noch garnicht durch; was für Möglichkeiten hab ich denn jetzt in C# bzw. unter .Net?
Man hört allgemein von GDI, SDL, OpenGL und DirectX (oder gibts sogar noch mehr?). Die letzten beiden sind wohl eher für 3D geeignet (was ja nicht heißt, dass die sich nicht auch für 2D Sachen verwenden lassen).

Doch mir fehlt einfach komplett der Überblick. Welche der Bibliotheken kann man unter .NET "out-of-the-box" programmieren (ich benutze übrigens die c# VS 2005 EE). Es scheint mir so, als wäre z.B. SDL ein externes Projekt. GDI ähnelt wohl etwas der GD2.

Es ist nich so, dass ich mich nicht bei wiki eingelesen hätte, nur ist dort immer allgemein erklärt und nicht sprachenspezifisch. Die meisten Beispiele für Grafikanwendungen sind verständlicherweise eh nur für C++ zu finden wie es mir scheint.

Ich hoffe, ihr könnt da etwas Licht ins Dunkle bringen :)

Achja: ich habe ja gesagt, dass ich mich damit gewissenhaft beschäftigen will, um so vllt später auch noch einen nutzen zu haben. Und da ich eh schonmal nen Tetrisklon oder änhliches coden wollte, würde ich auch eine komplexere der oben 4 genannten Wege nehmen, um es später noch weiterverwendet zu können.

Danke!

[Metzler]

Ganz trivial ist GDI. Nimm eine Picturebox, erzeug dir im Code ein Image, leg auf das Image ein Graphics-Device (das ist im Prinzip nix anderes als dein Wrapper für die GDI) und los gehts. Graphics bietet von Haus aus viele Methoden wie drawRectangle, drawLine, drawString etc. etc. Anschließend muss du glaub nur noch das Image auf in der Picturebox neu setzen (Picturebox.Image = deinimage; ). Fertig.
Je nachdem wie schnell das ganze sein muss, solltest du auch an DirectX denken, normalerweiße reicht aber Graphics. Bedenke zusätzlich: Ein kompletter redraw ist schweine lahm. Dementsprechend setz die Clip-Region, bevor du zeichnest auf den Bereich, der wirklich geupdatet werden muss!

[Elemental]

Mit nem graphics-Objekt aus dem System.Drawing namespace geht das echt gut. Zu meinen Anfangszeiten mit C# hab ich da auch mal so ne kleine Lib für PieChart,BarChart und StackedBarChart geschrieben.

kleines Beispiel:

/// <summary>
/// draws a chart in a bitmap
/// </summary>
/// <param name="size">size of the bitmap</param>
/// <returns>a bitmap that holds the chart</returns>
public Bitmap DrawChart(Size size)
{
// Create a new bitmap
Bitmap bitmap = new Bitmap(size.Width, size.Height, PixelFormat.Format32bppArgb);

using( Graphics graphics = Graphics.FromImage(bitmap) )
{
//draw chart in bitmap
DrawChart(graphics, size);
}

return bitmap;
}


/// <summary>
/// draws a chart
/// </summary>
/// <param name="graphics">graphics object to draw</param>
/// <param name="size">desired size of the chart</param>
public void DrawChart(Graphics graphics, Size size)
{
//color background
SolidBrush brush = new SolidBrush(m_BGColor);
graphics.FillRectangle(brush, 0, 0, size.Width, size.Height);
brush.Dispose();

/*
... hier war Code, der für das Beispiel unnötig ist...
*/

//draw the pie chart
float start = 0.0f;
float end = 0.0f;
double current = 0.0;
for(int i = 0; i < m_DataSource.Count; i++)
{
current += m_DataSource[i].Value;
start = end;
end = (float) (current / total) * 360.0f;

SolidBrush sliceBrush = new SolidBrush(m_DataSource[i].SliceColor);
graphics.FillPie(sliceBrush, iPieOriginX, iPieOriginY, iPieWidth, iPieHeight, start, end - start);
sliceBrush.Dispose();
}
}



mfG
Elemental

[Gast]

Ganz trivial ist GDI.

GDI+

Wobei es immer gut ist, sich mit GDI auszukennen, wenn man Windows Entwickler ist.