Class Brush

Class Brush

Namespace: Aspose.Imaging
Assembly: Aspose.Imaging.dll (25.2.0)

Die Basisklasse für Pinsel.

[JsonObject(MemberSerialization.OptIn)]
public abstract class Brush : DisposableObject, IDisposable

Vererbung

objectDisposableObjectBrush

Abgeleitet

HatchBrush, SolidBrush, TransformBrush

Implementiert

IDisposable

Vererbte Mitglieder

DisposableObject.Dispose(), DisposableObject.ReleaseManagedResources(), DisposableObject.ReleaseUnmanagedResources(), DisposableObject.VerifyNotDisposed(), DisposableObject.Disposed, object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()

Konstruktoren

Brush()

protected Brush()

Eigenschaften

Opazität

Erhält oder setzt die Opazität des Pinsels. Der Wert sollte zwischen 0 und 1 liegen. Ein Wert von 0 bedeutet, dass der Pinsel vollständig sichtbar ist, ein Wert von 1 bedeutet, dass der Pinsel vollständig undurchsichtig ist.

public float Opacity { get; set; }

Eigenschaftswert

float

Beispiele

Dieses Beispiel verwendet die Graphics-Klasse, um primitive Formen auf der Bildoberfläche zu erstellen. Um die Operation zu demonstrieren, erstellt das Beispiel ein neues Bild im PNG-Format und zeichnet primitive Formen auf der Bildoberfläche mit den von der Graphics-Klasse bereitgestellten Draw-Methoden.```csharp [C#]

                                                                                                                                                                                                                                                            // Erstellt eine Instanz von FileStream
                                                                                                                                                                                                                                                            using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                // Erstellt eine Instanz von PngOptions und setzt ihre verschiedenen Eigenschaften
                                                                                                                                                                                                                                                                Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                // Setzt die Quelle für PngOptions
                                                                                                                                                                                                                                                                pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                // Erstellt eine Instanz von Image 
                                                                                                                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    // Erstellt und initialisiert eine Instanz der Graphics-Klasse
                                                                                                                                                                                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                    // Löscht die Grafikoberfläche
                                                                                                                                                                                                                                                                    graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                    // Zeichnet einen Bogen, indem das Pen-Objekt mit schwarzer Farbe, 
                                                                                                                                                                                                                                                                    // ein Rechteck um den Bogen, Startwinkel und Sweep-Winkel angegeben werden
                                                                                                                                                                                                                                                                    graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                    // Zeichnet eine Bezier, indem das Pen-Objekt mit blauer Farbe und Koordinatenpunkten angegeben wird.
                                                                                                                                                                                                                                                                    graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                    // Zeichnet eine Kurve, indem das Pen-Objekt mit grüner Farbe und einem Array von Punkten angegeben wird
                                                                                                                                                                                                                                                                    graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                    // Zeichnet eine Ellipse unter Verwendung des Pen-Objekts und eines umgebenden Rechtecks
                                                                                                                                                                                                                                                                    graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                    // Zeichnet eine Linie 
                                                                                                                                                                                                                                                                    graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                    // Zeichnet ein Tortenstück
                                                                                                                                                                                                                                                                    graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                    // Zeichnet ein Polygon, indem das Pen-Objekt mit roter Farbe und einem Array von Punkten angegeben wird
                                                                                                                                                                                                                                                                    graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                    // Zeichnet ein Rechteck
                                                                                                                                                                                                                                                                    graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                    // Erstellt ein SolidBrush-Objekt und setzt seine verschiedenen Eigenschaften
                                                                                                                                                                                                                                                                    Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                    brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                    brush.Opacity = 100;

                                                                                                                                                                                                                                                                    // Zeichnet einen String unter Verwendung des SolidBrush-Objekts und der Schriftart an einem bestimmten Punkt
                                                                                                                                                                                                                                                                    graphics.DrawString("Dieses Bild wurde mit der Aspose.Imaging API erstellt", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                    // speichert alle Änderungen.
                                                                                                                                                                                                                                                                    image.Save();
                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                            }

## Methoden

### <a id="Aspose_Imaging_Brush_DeepClone"></a> DeepClone\(\)

Erstellt einen neuen Deep Clone des aktuellen Aspose.Imaging.Brush.

```csharp
public virtual Brush DeepClone()

Gibt zurück

Brush

Ein neuer Aspose.Imaging.Brush, der der Deep Clone dieser Aspose.Imaging.Brush-Instanz ist.

Equals(object)

Überprüft, ob die Objekte gleich sind.

public override bool Equals(object obj)

Parameter

obj object

Das andere Objekt.

Gibt zurück

bool

Das Ergebnis des Gleichheitsvergleichs.

Equals(Brush)

Überprüft, ob die Objekte gleich sind.

protected bool Equals(Brush other)

Parameter

other Brush

Das andere Objekt.

Gibt zurück

bool

Das Ergebnis des Gleichheitsvergleichs.

GetHashCode()

Erhält den Hash-Code des aktuellen Objekts.

public override int GetHashCode()

Gibt zurück

int

Der Hash-Code.

 Deutsch