Verlauf Komplexer Zahlen berechnen

  • VB.NET
  • .NET (FX) 4.5–4.8

Es gibt 43 Antworten in diesem Thema. Der letzte Beitrag () ist von Farliam.

    Verlauf Komplexer Zahlen berechnen

    Hey zusammen,

    habe mich vor kurzem mit dem bekannten Mandelbrot auseinander gesetzt. Muss gestehen das es etwas mein Interesse geweckt hatte,
    nun habe ich die Tage versucht selber bestimmte Bereiche und Berechnungen zu finden, die schöne, wiederholende und fortlaufende Bilder erzeugen.

    Kleine Auswahl von den schönsten :



    und diese würde ich nun gerne in Farbe haben.

    Zur Zeit nehme ich den Wert der größten Berechnungstiefe, erweitere ihn auf den Bereich 0-255 und nehme ihn mal den Wert der Iterationen des Punktes. Diesen füge ich (wie man sieht, für R,G,B) ein.
    Ich möchte keinen Farbverlauf erstellen, und einfach dort eine Farbe "grabben". Mir wäre eine Berechnung für die einzelnen Anteile lieber. Nur weiß ich nicht, welche Parameter ich für die weitere 2 einfügen sollte.

    Die Bilder entstehen ähnlich wie das Mandelbrot, also zwischen xmin,xmax,ymin und ymax. Nur die Berechnungen sind anders:



    Kann ich vielleicht diese Werte der aktuellen Berechnung verwenden? Bei einem Zoom müssten dann die Farben eigentlich/theoretisch fortlaufend sein?

    Eine letzte Frage habe ich:

    Als nächstes möchte ich eine Automatische Zoomfunktion erstellen. Sprich mal wählt einen Punkt aus, eine bestimmte Tiefe und das Programm berechnet das Bild, speichert es und zoomt weiter rein. Ziel ist dass diese Bilder dann z.B. zu einer MP4 zugeschnitten werden. Ist das mit wenig Aufwand realisierbar?

    LG
    @Farliam Mit einem komplexeren GIF-Maker kannst Du die Dauern der Frames vorgeben.
    Frag mal Frau Google nach csharp gif maker frame duration.
    Eine andere Herangehensweise wäre, die Bilder als 8 BPP zu generieren und dann nur noch die Palette zu verändern.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    Okay das mit dem Video hab ich jetzt hinbekommen.




    Nur ist mir ein neues Problem aufgefallen. Scheinbar habe ich da einen Denkfehler, nur komme ich seit gestern Abend nicht auf die Lösung.

    Der Zoom in die Obere Linke Ecke funktioniert super. Zoome ich jedoch rechts unten(xmin,xmax,ymin,ymax) im Plusbereich, Schwenkt das Bild, wenn sich die Werte gegen 0 nähern auf die Mitte. Das dürfte eigentlich nicht sein.
    Nach jedem Zoom, berechne ich den Wert den gezoomt wird neu. Also je kleiner die Bereiche, desto kleiner Wird der Zoomfaktor.

    Normalerweiße dürfte der Wert nicht auf 0 springen, bei dem Video sieht man auch (glaube ca bei 0:26) dass sich die erste Stelle nicht mehr verändert, da der Faktor Zoom sich fortlaufend anpasst.

    Nachtrag
    So kann mir natürlich niemand helfen. Ich glaube das Problem liegt an meiner Berechnung. @RodFromGermany

    Ich versuche den Absoluten Wert zwischen xmin und xmax herauszufinden. Gehen wir nun davon aus dass xmin im negativen, und xmax im positiven Bereich liegt. Dann sollte es ja mit:

    VB.NET-Quellcode

    1. Math.Abs(xmin) + xmax


    richtig sein.

    Zur Zeit verwende ich dafür folgende Funktion:

    VB.NET-Quellcode

    1. Private Function GetAbsolute(ByVal val1 As Double, ByVal val2 As Double) As Double
    2. Dim result As Double
    3. Dim big As Double = Math.Max(val1, val2)
    4. Dim small As Double = Math.Min(val1, val2)
    5. If big > 0 And small > 0 Then
    6. result = big - small
    7. ElseIf big > 0 And small < 0 Then
    8. result = Math.Abs(small) + big
    9. Else
    10. result = Math.Abs(Math.Abs(big) - Math.Abs(small))
    11. End If
    12. Return result
    13. End Function


    Ich erstelle mal ein neues Projekt, und teste diese Funktion solo. Aber vielleicht erkennt ihr ja auf den ersten Blick das Problem.

    Vielleicht gehört es hier nicht hin, aber ich weiß nicht woran es liegt. Ich habe über Nacht das Programm mal laufen lassen, und 6000 Frames mit einem Seitenverhältnis von 6k Pixel erstellen lassen.
    Das ganze sieht bei mir auf dem PC auch super aus. Wenn ich es aber auf Youtube hochlade, gibt das am Anfang der reinste Pixelbrei. Gegen 1:22 wird die Qualität dann auch besser, doch zu beginn ist es mehr als schlecht.

    Hier ein Vergleich :

    Spoiler anzeigen




    Das Bild entspricht dem ersten Frame.


    Könnte der Qualitätsunterschied an meiner Auflösung liegen? Wobei Lokal die MP4 scharf und sauber abgespielt wird.

    LG

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „Farliam“ ()

    Farliam schrieb:

    VB.NET-Quellcode

    1. Private Function GetAbsolute(ByVal val1 As Double, ByVal val2 As Double) As Double
    Beschreib mal verbal, ohne software-technische Begriffe, was diese Funktion machen soll, das erschließt sich mir nämlich nicht.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    Also eigentlich nur (Pseudo-Code): math.Abs(val1-val2), oder? :D
    Wenn das Leben wirklich nur aus Nullen und Einsen besteht, dann laufen sicherlich genügen Nullen frei herum. :D
    Signature-Move 8o
    kein Problem mit privaten Konversationen zu Thema XY :thumbup:

    Farliam schrieb:

    den Absoluten Betrag zwischen den 2 Werten
    berechne ich mit (max - min) mit max >= min, also ist der Betrag >= 0.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    Ja gut, ich hatte da Probleme. Deswegen hatte ich mir die Funktion geschrieben. Hab ja sowohl Abs als auch Max & Min in der Funktion verwendet.
    Diese "Funktion" :D tut tzd. was sie soll.

    Zoom Funktion in einen bestimmten Bereich. Den man mit der Maus auf der Bitmap/Box ect. anklickt.

    Also ich habe vorgegeben:

    xmin,xmax - der Wert dazwischen entspricht der Breite der z.B. Bitmap
    ymin,ymax - die Höhe der Bitmap

    Ich wähle jetzt einen Punkt auf der Bitmap - Nun soll dieser Punkt die neue Mitte sein. Ich hole mir die einzelnen Bereiche(xstep) für einen Pixel Abs(xmax-xmin) ... und teile dies durch die Breite der Grafik.
    Nun hole ich den neuen Punkt der Bitmap. (Bitmapbreite/2) -( mousex * stepx)
    Das sollte nun eigentlich xmin sein. xmax hole ich mir dann mit :(Bitmapbreite/2) -( mousex * stepx) + (stepx * Grafikbreite)

    Funktioniert, nur wie gesagt im oberen linken Quadrat.

    Farliam schrieb:

    Diese "Funktion" tut tzd. was sie soll.
    Dann teste mal explizit den Fall, dass min < 0 ist.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    @Farliam Sorry, das Ergebnis ist korrekt, da steht ja ein + da.
    Mit max - min bist Du allerdings auf der sicheren Seite, denn in einem Jahr fängst Du bei Deinem Code an zu grübeln, warum das so geschrieben steht.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    Ja, ich habe mitlerweile auch der Fehler gefunden bei der Zoomfunktion.

    Der Bereich wurde ja ausgewählt, nach dem man mit der Maus 2 mal geklickt hat. Also einen Quader in dem Bereich gezogen hat. Mein Fehler war, das ich nach dem ersten Klick die Werte direkt in xmin,und ymin Geschrieben habe.

    Damit ich das Ursprüngliche Seitenverhältnis beibehalte, rechne ich erst nach dem 2ten Klick die richtige Daten aus. Da ich aber beim ersten Klick schon die Orginalen xmin,ymin überschrieben habe, konnte ich am Ende natürlich auch nicht mehr das Orginale Seitenverhältniss herausfinden.

    @RodFromGermany Eine letzte Frage habe ich an dich. Nehmen wir mal an. Ich finde beim manuellen suchen irgendwann einen tollen Bereich. Gehen wir mal davon aus, das dieser Bereich (Abs(xmin+xmax) auch der Ursprunglichen Auflösung z.B. 1440p aufgeteilt auf xmin:-3.0 xmax:2.0 und ymin:-2.0 und ymax:2.0 gleicht.

    Nun möchte ich meiner Zoomfunktion den Befehl geben, diesen Bereich wieder zu finden - bei einer Auflösung von 1880p.
    Nun weiß ich das meine Berechnung für Fraktal xyz in dem Bereich x(-25,25) und y(-25,25) ein Synchrones Bild ergibt, also nichts verzerrt ist.

    Nach meiner Umrechnung auf 1080p ergibt das ein neues Seitenverhältnis von: x(-48,48) und y(-27,27). Sollte mal stimmen. <- Nenne diesen Bereich jetzt mal Ebne A.

    Um meinen Gesuchten Bereich zu finden hätte ich jetzt 2 Ideen, oder Ansätze.

    Die Ebne A neu Ausrichten. So dass der gesuchte Bereich (relativ) mittig liegt.
    Ausrechnen wie oft der Abs(xmin,xmax) in den Betrag der Ebne A passt.
    Diesen Wert nehme ich mal den Wert Abs(xmin,xmax) / BildgrößeBreite.
    Diesen Wert teile ich wieder durch 2.
    Nun starte ich den zoom, und ziehe diesen Wert immer wieder von xmin,xmax ab.
    Irgendwann sollte ich dann den gesuchten Bereich finden?

    Die andere Idee wo ich hätte, wo mir auch viel lieber wäre.
    Statt das Bild so auszurichten, dass es mittig liegt. Die gesuchten Werte direkt ausrechnen.
    Dann sollte ja keine gerade Bewegung nach unten entstehen, sondern z.B. leicht versetzt.
    Nur fällt mir dazu gerade absolut keine Idee ein.

    Farliam schrieb:

    Nun möchte ich meiner Zoomfunktion den Befehl geben, diesen Bereich wieder zu finden - bei einer Auflösung von 1880p.
    Was nennst Du einen Bereich?
    Nach welchen Kriterien findest Du einen Befreich?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    @RodFromGermany
    Ein Bereich sind die 4 Werte (xmin,ymin,xmax,ymax) Dabei entspricht xmin,ymin dem Pixel 0,0 und xmax,ymax meiner Bildbreite/Bildhöhe.
    Ich finde den Bereich durch zoomen. Genau wie bei dem Apfelbrot. Das sieht dann ungefähr so aus :



    Auf dem Bild, der Verlauf. Dies soll der Zoomverlauf werden.
    Und die Ideen die ich hatte, Funktionieren so ja natürlich nicht.

    Aber hatte ich gestern Abend eine neue Idee :


    Nach jedem Zoomvorgang -> Der immer wieder in den vorherigen Bereich zoomt. Nehme ich den Betrag der vorherigen.

    Ungefähr so :

    VB.NET-Quellcode

    1. If zoomVerlaufRectangle.Count = 0 Then
    2. 'Erster Zoomverlauf
    3. zoomVerlaufRectangle.Add(New Tuple(Of Double, Double)(p1.X, p1.Y))
    4. Else
    5. Dim xp As Double = (zoomVerlaufRectangle.Item(zoomVerlaufRectangle.Count - 1).Item1 / BildBreite)
    6. Dim difxp As Double = xp * p1.X
    7. Dim yp As Double = (zoomVerlaufRectangle.Item(zoomVerlaufRectangle.Count - 1).Item2 / BildHöhe)
    8. Dim difyp As Double = yp * p1.Y
    9. zoomVerlaufRectangle.Add(New Tuple(Of Double, Double)(xp + difxp, yp + difyp))
    10. Dim anzeigeX, anzeigeY As Double
    11. For Each t As Tuple(Of Double, Double) In zoomVerlaufRectangle
    12. anzeigeX += t.Item1
    13. anzeigeY += t.Item2
    14. Next
    15. zoomFaktorX = anzeigeX / BildBreite
    16. zoomFaktorY = anzeigeY / BildHöhe
    17. End If


    Wenn ich dann mal etwas zoome bekomme ich als Ergebnis des Verlaufes :

    (184, 255)
    (75,072, 101,235) 'Pixel innerhalb des ersten Element
    (26,125056, 37,65942) 'Innerhalb des zweiten....
    (6,191638272, 14,34823902)
    (3,021519476736, 6,0980015835)
    (1,35364072557773, 2,414808627066)
    (0,596955559979778, 1,05527137002784)
    (0,24176700179181, 0,444269246781722)
    (0,0979156357256831, 0,182150391180506)
    (0,0387745917473705, 0,076685314686993)
    (0,0166730744513693, 0,0312876083922931)
    (0,00660253748274225, 0,012483755748525)
    (0,00254857946833851, 0,00556775506384213)


    Nach diesem Verlauf, müsste der gesuchte Pixel : 299.765091454961, 418,563184672448 in Ebne A den letzten Zoombereich repräsentieren?
    Ergibt Steps für X,Y -> ZFX:0,296765091454961ZFY:0,418563184672448

    Die Nachkommastellen werden verfallen nicht, im Autozoom ziehe ich erst einen Betrag ab, wenn die Steperwerte > 1 sind, danach wird der Betrag abgezogen. Und es geht wieder von vorne los.

    Hab über Nacht es laufen lassen, und es zoomt nicht dort hin wo es hin soll.
    ?(
    LG

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „Farliam“ ()

    @Farliam OK, wie bei der Mandelbrod-Menge.
    Wenn Du den Bereich schon mal hattest, wäre es vielleicht sinnvoll, wenn Du die erzoomten Techtecke in einer History-List ablegen würdest, da könntest Du hin- und her navigieren.
    Ich weiß nicht, wie Du navigierst, aber Du könntest auch Tastendrücke und / oder Maus-Zoom-Aktionen speichern.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    @RodFromGermany Klar den Verlauf hab ich ja auch, und kann hin und her springen. Funktioniert auch super.

    Doch ich wollte wenn ich z.B. beim manuellen reinzoomen einen tollen Bereich sehe, den Bereich wo ich ihn gefunden habe speichern. Alles auf Anfang setzen, und mein Programm soll von selber den Eben angesprochenen Punkt finden.

    Das ganze soll ziemlich smooth ablaufen. Also maximal immer 2Pixel reinzoomen.
    Ich habe das ganze nochmal überarbeitet. Und ich brauche nicht nur die linke Ecke, ich brauche auch die rechte untere Ecke. Da das Bild ja von allen 4 Seiten dann Pixel verlieren muss.

    Hier einmal die Funktion die nach dem Auswählen des manuellen Zoomvorgang immer wieder aufgerufen wird :

    Spoiler anzeigen

    VB.NET-Quellcode

    1. If zoomVerlaufL.Count = 0 Then
    2. 'Erster Zoomverlauf
    3. zoomVerlaufL.Add(New Tuple(Of Double, Double)(p1.X, p1.Y))
    4. zoomVerlaufR.Add(New Tuple(Of Double, Double)(p2.X, p2.Y))
    5. Label12.Text = zoomVerlaufL.Item(zoomVerlaufL.Count - 1).ToString & vbCrLf & vbCrLf &
    6. zoomVerlaufR.Item(zoomVerlaufR.Count - 1).ToString
    7. Else
    8. 'LTuple
    9. Dim bCount As Double = zoomVerlaufL.Count * BildBreite 'In Ebne 3 sollte ja auch ein Pixel der AnzahlEbne * Bildbreite entsprechen?
    10. Dim hCount As Double = zoomVerlaufR.Count * BildHöhe
    11. Dim xp As Double = (zoomVerlaufL.Item(zoomVerlaufL.Count - 1).Item1 / bCount)
    12. Dim difxp As Double = xp * p1.X
    13. Dim yp As Double = (zoomVerlaufL.Item(zoomVerlaufL.Count - 1).Item2 / hCount)
    14. Dim difyp As Double = yp * p1.Y
    15. 'RTuple
    16. Dim xl As Double = ((zoomVerlaufR.Item(zoomVerlaufR.Count - 1).Item1 / bCount))
    17. Dim difxl As Double = xl * p2.X
    18. Dim yl As Double = ((zoomVerlaufR.Item(zoomVerlaufR.Count - 1).Item2 / hCount))
    19. Dim difyl As Double = yl * p2.Y
    20. zoomVerlaufL.Add(New Tuple(Of Double, Double)(xp + difxp, yp + difyp))
    21. zoomVerlaufR.Add(New Tuple(Of Double, Double)(xl - difxl, yl - difyl))
    22. ''N
    23. Dim xRT, xLT As Double
    24. Dim yRT, yLT As Double
    25. xRT = zoomVerlaufR(0).Item1
    26. yRT = zoomVerlaufR(0).Item2
    27. yLT = zoomVerlaufL(0).Item2
    28. xLT = zoomVerlaufL(0).Item1
    29. For i As Integer = 1 To zoomVerlaufL.Count - 1
    30. xLT += zoomVerlaufL(i).Item1
    31. yLT += zoomVerlaufL(i).Item2
    32. xRT -= zoomVerlaufR(i).Item1
    33. yRT -= zoomVerlaufR(i).Item2
    34. Next
    35. zoomFaktorLX = Math.Abs(xLT / BildBreite)
    36. zoomFaktorRX = Math.Abs(xRT / BildBreite)
    37. zoomFaktorLY = Math.Abs(yLT / BildHöhe)
    38. zoomFaktorRY = Math.Abs(yRT / BildHöhe)
    39. End If

    Die Werte sehen für mich eigentlich Relativ richtig aus. Zmd. Was in den 2 Listen mit den Tuple drinnen liegt :

    VB.NET-Quellcode

    1. LTuple:(360, 220)
    2. RTuple:(700, 560)
    3. LTuple:(0,46656, 0,24794)
    4. RTuple:(0,3703, 0,39088)
    5. LTuple:(0,00026617248, 0,0001450449)
    6. RTuple:(0,000146731375, 0,00014921844)
    7. LTuple:(9,81880704E-08, 5,21839318E-08)
    8. RTuple:(4,05141629861111E-08, 4,25604150533333E-08)
    9. LTuple:(2,623462506E-11, 1,428535133025E-11)
    10. RTuple:(8,8219589902257E-12, 8,985567628135E-12)


    Zeile 10 entspricht hier der 5ten Zoom Ebne. Demnach entspricht dort der Pixel -> 8,8219589902257E-12

    Das ganze Addiere ich unten zusammen, bzw ziehe es ab. (RTuple - Rechte untere Ecke)



    So bekomme ich die Werte auf dem Bild.

    Wenn die LZoomWerte(4 Stück) > 1 sind, wird 1 Pixel abgezoben. Bei LFX linke Breite,LFY=linke höhe,RFX=rechteBreite,....



    Nur leider funktioniert das überhaupt nicht. Auch wenn mein gesuchter Bereich sehr weit unten links ist, Zoomt mein Programm dauerhaft nach oben Links.

    Die Werte werden von einem Thread verwendet. Hier:

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Dim m As SingleThreadInfoMat = DirectCast(s, SingleThreadInfoMat)
    2. Dim xLCut, yLCut As Double
    3. Dim xRCut, yRCut As Double
    4. For i As Integer = 0 To AutoIterationen
    5. xLCut += zoomFaktorLX * ZoomStep
    6. yLCut += zoomFaktorLY * ZoomStep
    7. xRCut += zoomFaktorRX * ZoomStep
    8. yRCut += zoomFaktorRY * ZoomStep
    9. Dim nRx As Integer = CInt(Math.Truncate(xRCut))
    10. Dim nRy As Integer = CInt(Math.Truncate(yRCut))
    11. Dim nLx As Integer = CInt(Math.Truncate(xLCut))
    12. Dim nLy As Integer = CInt(Math.Truncate(yLCut))
    13. xLCut -= nLx
    14. yLCut -= nLy
    15. xRCut -= nRx
    16. yRCut -= nRy


    Nach dem der Thread das Bild berechnet(Thread macht keine Probleme, keine Threadverletzungen) hat, kommt folgender Teil :

    VB.NET-Quellcode

    1. Dim p1 As New Point(nLx, nLy)
    2. Dim p2 As New Point(BildBreite - nRx - 1, BildHöhe - nRy - 1)
    3. xmin = NumberRange(p1.X, p1.Y).Item1
    4. ymin = NumberRange(p1.X, p1.Y).Item2
    5. xmax = NumberRange(p2.X, p2.Y).Item1
    6. ymax = NumberRange(p2.X, p2.Y).Item2
    7. Dim xSteps As Double = GetAbsolute(xmin, xmax) / BildBreite
    8. Dim ySteps As Double = GetAbsolute(ymin, ymax) / BildHöhe
    9. Dim xVal, yVal As Double
    10. For x As Integer = 0 To BildBreite - 1
    11. For y As Integer = 0 To BildHöhe - 1
    12. xVal = Math.Min(xmin, x * xSteps) + Math.Max(xmin, x * xSteps)
    13. yVal = Math.Min(ymin, y * ySteps) + Math.Max(ymin, y * ySteps)
    14. NumberRange(x, y) = New Tuple(Of Double, Double)(xVal, yVal)
    15. Next
    16. Next


    Meine ganzen Complexen Zahlen befinden sich in einem Array(Bildbreite,Bildhöhe) As Tuple(Of Double,Double)
    Das habe ich gemacht, damit ich nicht immer wieder die Position umrechnen muss. Picturebox <> Bildbreite.
    So rechne ich einmal die Relative Position von der Picturebox zur Bitmap aus, und hole mir dann die Werte aus meinem Array.



    Hast du eine andere Idee, wie ich einen smoothen Zoom in einen Bereich machen kann - den ich über das manuelle suchen entdeckt habe?

    LG

    Farliam schrieb:

    Und ich brauche nicht nur die linke Ecke, ich brauche auch die rechte untere Ecke.
    Das ist doch einfach ein Rectangle oder ein eigenes RectangleD (4 Double-Werte).
    Vielleicht ist es sogar besser, Du stellst alles auf RectangleD um.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!