《C# GDI+ 破境之道》：第一境 GDI+基礎 —— 第二節：畫矩形

有了上一節畫線的基礎，畫矩形的各種邊線就特別好理解了，所以，本節在矩形邊線上，就不做過多的講解了，關注一下畫“隨機矩形”的具體實現就好。與畫線相比較，畫矩形稍微復雜的一點就是在於它多了很多填充的樣式。接下來，我們就來細細品味一番。

同樣，一個窗體項目，窗體的布局風格與上一節的保持一致：

namespace MikeWare.GdiPlus.Rectangles
{
    using System;
    using System.Collections.Generic;
    using System.Drawing;
    using System.Drawing.Drawing2D;
    using System.Windows.Forms;

    public partial class FormDrawRectangles : Form
    {
        private Random random = null;
        private Color penColor = Color.Transparent;

        public FormDrawRectangles()
        {
            InitializeComponent();
            random = new Random(DateTime.Now.Millisecond);
            penColor = GetRandomColor();
        }

        private Point GetRandomPoint()
        {
            return new Point(random.Next(0, ClientRectangle.Width), random.Next(0, ClientRectangle.Height - pnlToolbox.Height));
        }

        private Rectangle GetRandomRectangle()
        {
            var pointA = GetRandomPoint();
            var pointB = GetRandomPoint();

            return new Rectangle(Math.Min(pointA.X, pointB.X)
                , Math.Min(pointA.Y, pointB.Y)
                , Math.Abs(pointA.X - pointB.X)
                , Math.Abs(pointA.Y - pointB.Y));
        }

        private Color GetRandomColor()
        {
            return Color.FromArgb(random.Next(0, 256), random.Next(0, 256), random.Next(0, 256));
        }

        private void ShowInformation(string message)
        {
            lblInformation.Text = message;
        }

        private void btnChangePenColor_Click(object sender, EventArgs e)
        {
            if (colors.ShowDialog(this) == DialogResult.OK)
            {
                penColor = colors.Color;
            }
        }

        private void btnSwitchDoubleBuffered_Click(object sender, EventArgs e)
        {
            DoubleBuffered = !DoubleBuffered;

            ShowInformation($"二級緩沖：{DoubleBuffered}。");
        }

        private void btnDrawRandomRectangle_Click(object sender, EventArgs e)
        {
            var rectangle = GetRandomRectangle();

            var style = (DashStyle)(random.Next(0, 6));
            var dashCaps = new List<int> { 0, 2, 3 };
            var dashCap = (DashCap)dashCaps[random.Next(0, 3)];

            using (var g = CreateGraphics())
            using (var pen = new Pen(penColor, 4f))
            using (var brush = new LinearGradientBrush(rectangle, Color.Red, Color.Blue, LinearGradientMode.ForwardDiagonal))
            {
                g.Clear(SystemColors.AppWorkspace);
                g.SmoothingMode = SmoothingMode.HighQuality;
                pen.DashStyle = style;
                pen.DashCap = dashCap;
                g.DrawRectangle(pen, rectangle);
            }

            ShowInformation($"隨機矩形，{rectangle}，虛線冒：{dashCap.ToString()}，線條樣式：{style.ToString()}。");
        }

        ……    
    }
}

與上一節給出的窗體定義及輔助方法雷同，這里不做過多說明，增加了兩個輔助方法，一個是獲取隨機矩形Rectangle GetRandomRectangle()，一個是獲取隨機顏色Color GetRandomColor()，相信什么是矩形和顏色，生物老師都教過：）而且本節的重點也不在邊線的繪制上，其基本方法就是Graphics.DrawRectangle(Pen pen, Rectangle rect)，也直接給出了繪制“隨機矩形”的代碼，有了畫線的基礎，應該沒什么問題了。

下面，重點來了：

1、繪制具有漸變色填充的矩形

private void btnFillLinearGradientColor_Click(object sender, EventArgs e)
{
    var rectangle1 = GetRandomRectangle();
    var rectangle2 = GetRandomRectangle();

    var gradient = (LinearGradientMode)(random.Next(0, 4));
    var angle = (random.Next(0, 361));

    using (var g = CreateGraphics())
    {
        g.Clear(SystemColors.AppWorkspace);
        g.SmoothingMode = SmoothingMode.HighQuality;
        using (var brush = new LinearGradientBrush(rectangle1, GetRandomColor(), GetRandomColor(), gradient))
        {
            g.FillRectangle(brush, rectangle1);
        }

        using (var brush = new LinearGradientBrush(rectangle2, GetRandomColor(), GetRandomColor(), angle, 0 == angle % 2))
        {
            g.FillRectangle(brush, rectangle2);
        }
    }

    ShowInformation($"漸變色填充，{rectangle1}，LinearGradient：{gradient}；{rectangle2}，Angle：{angle}。");
}

繪制漸變色填充，關鍵在於構造一個合適的LinearGradientBrush，然后調用Graphics.FillRectangle(Brush brush, Rectangle rect)就可以了。

        //
        // Summary:
        //     Initializes a new instance of the System.Drawing.Drawing2D.LinearGradientBrush
        //     class with the specified points and colors.
        //
        // Parameters:
        //   point1:
        //     A System.Drawing.PointF structure that represents the starting point of the linear
        //     gradient.
        //
        //   point2:
        //     A System.Drawing.PointF structure that represents the endpoint of the linear
        //     gradient.
        //
        //   color1:
        //     A System.Drawing.Color structure that represents the starting color of the linear
        //     gradient.
        //
        //   color2:
        //     A System.Drawing.Color structure that represents the ending color of the linear
        //     gradient.
        public LinearGradientBrush(PointF point1, PointF point2, Color color1, Color color2);
//
        // Summary:
        //     Initializes a new instance of the System.Drawing.Drawing2D.LinearGradientBrush
        //     class with the specified points and colors.
        //
        // Parameters:
        //   point1:
        //     A System.Drawing.Point structure that represents the starting point of the linear
        //     gradient.
        //
        //   point2:
        //     A System.Drawing.Point structure that represents the endpoint of the linear gradient.
        //
        //   color1:
        //     A System.Drawing.Color structure that represents the starting color of the linear
        //     gradient.
        //
        //   color2:
        //     A System.Drawing.Color structure that represents the ending color of the linear
        //     gradient.
        public LinearGradientBrush(Point point1, Point point2, Color color1, Color color2);
//
        // Summary:
        //     Creates a new instance of the System.Drawing.Drawing2D.LinearGradientBrush based
        //     on a rectangle, starting and ending colors, and an orientation mode.
        //
        // Parameters:
        //   rect:
        //     A System.Drawing.RectangleF structure that specifies the bounds of the linear
        //     gradient.
        //
        //   color1:
        //     A System.Drawing.Color structure that represents the starting color for the gradient.
        //
        //   color2:
        //     A System.Drawing.Color structure that represents the ending color for the gradient.
        //
        //   linearGradientMode:
        //     A System.Drawing.Drawing2D.LinearGradientMode enumeration element that specifies
        //     the orientation of the gradient. The orientation determines the starting and
        //     ending points of the gradient. For example, LinearGradientMode.ForwardDiagonal
        //     specifies that the starting point is the upper-left corner of the rectangle and
        //     the ending point is the lower-right corner of the rectangle.
        public LinearGradientBrush(RectangleF rect, Color color1, Color color2, LinearGradientMode linearGradientMode);
//
        // Summary:
        //     Creates a new instance of the System.Drawing.Drawing2D.LinearGradientBrush class
        //     based on a rectangle, starting and ending colors, and orientation.
        //
        // Parameters:
        //   rect:
        //     A System.Drawing.Rectangle structure that specifies the bounds of the linear
        //     gradient.
        //
        //   color1:
        //     A System.Drawing.Color structure that represents the starting color for the gradient.
        //
        //   color2:
        //     A System.Drawing.Color structure that represents the ending color for the gradient.
        //
        //   linearGradientMode:
        //     A System.Drawing.Drawing2D.LinearGradientMode enumeration element that specifies
        //     the orientation of the gradient. The orientation determines the starting and
        //     ending points of the gradient. For example, LinearGradientMode.ForwardDiagonal
        //     specifies that the starting point is the upper-left corner of the rectangle and
        //     the ending point is the lower-right corner of the rectangle.
        public LinearGradientBrush(Rectangle rect, Color color1, Color color2, LinearGradientMode linearGradientMode);
//
        // Summary:
        //     Creates a new instance of the System.Drawing.Drawing2D.LinearGradientBrush class
        //     based on a rectangle, starting and ending colors, and an orientation angle.
        //
        // Parameters:
        //   rect:
        //     A System.Drawing.RectangleF structure that specifies the bounds of the linear
        //     gradient.
        //
        //   color1:
        //     A System.Drawing.Color structure that represents the starting color for the gradient.
        //
        //   color2:
        //     A System.Drawing.Color structure that represents the ending color for the gradient.
        //
        //   angle:
        //     The angle, measured in degrees clockwise from the x-axis, of the gradient's orientation
        //     line.
        public LinearGradientBrush(RectangleF rect, Color color1, Color color2, float angle);
//
        // Summary:
        //     Creates a new instance of the System.Drawing.Drawing2D.LinearGradientBrush class
        //     based on a rectangle, starting and ending colors, and an orientation angle.
        //
        // Parameters:
        //   rect:
        //     A System.Drawing.Rectangle structure that specifies the bounds of the linear
        //     gradient.
        //
        //   color1:
        //     A System.Drawing.Color structure that represents the starting color for the gradient.
        //
        //   color2:
        //     A System.Drawing.Color structure that represents the ending color for the gradient.
        //
        //   angle:
        //     The angle, measured in degrees clockwise from the x-axis, of the gradient's orientation
        //     line.
        public LinearGradientBrush(Rectangle rect, Color color1, Color color2, float angle);
//
        // Summary:
        //     Creates a new instance of the System.Drawing.Drawing2D.LinearGradientBrush class
        //     based on a rectangle, starting and ending colors, and an orientation angle.
        //
        // Parameters:
        //   rect:
        //     A System.Drawing.RectangleF structure that specifies the bounds of the linear
        //     gradient.
        //
        //   color1:
        //     A System.Drawing.Color structure that represents the starting color for the gradient.
        //
        //   color2:
        //     A System.Drawing.Color structure that represents the ending color for the gradient.
        //
        //   angle:
        //     The angle, measured in degrees clockwise from the x-axis, of the gradient's orientation
        //     line.
        //
        //   isAngleScaleable:
        //     Set to true to specify that the angle is affected by the transform associated
        //     with this System.Drawing.Drawing2D.LinearGradientBrush; otherwise, false.
        public LinearGradientBrush(RectangleF rect, Color color1, Color color2, float angle, bool isAngleScaleable);
//
        // Summary:
        //     Creates a new instance of the System.Drawing.Drawing2D.LinearGradientBrush class
        //     based on a rectangle, starting and ending colors, and an orientation angle.
        //
        // Parameters:
        //   rect:
        //     A System.Drawing.Rectangle structure that specifies the bounds of the linear
        //     gradient.
        //
        //   color1:
        //     A System.Drawing.Color structure that represents the starting color for the gradient.
        //
        //   color2:
        //     A System.Drawing.Color structure that represents the ending color for the gradient.
        //
        //   angle:
        //     The angle, measured in degrees clockwise from the x-axis, of the gradient's orientation
        //     line.
        //
        //   isAngleScaleable:
        //     Set to true to specify that the angle is affected by the transform associated
        //     with this System.Drawing.Drawing2D.LinearGradientBrush; otherwise, false.
        public LinearGradientBrush(Rectangle rect, Color color1, Color color2, float angle, bool isAngleScaleable);

從LinearGradientBrush的一系列構造函數可以看出，LinearGradientBrush意在指出完成從一種顏色漸變到另一種顏色的漸變周期。

這里我們着重說一下LinearGradientBrush的第一個參數，無論是一個Rectangle還是兩個Point，他們描述的是漸變色完成的區間。為了理解和描述上的方便，我們假設繪制的是一個水平方向的漸變，

這個時候，漸變區間與我們要填充的矩形並沒有交集，我們可以這樣理解，這個漸變區間會以定義的區域為原點，向四周擴散，

然后在填充的時候，只保留了我們要填充的矩形區域可見，

OK，假設我已經把這個關系說清楚了：）在有就是LinearGradientMode這個枚舉，

    //
    // Summary:
    //     Specifies the direction of a linear gradient.
    public enum LinearGradientMode
    {
        //
        // Summary:
        //     Specifies a gradient from left to right.
        Horizontal = 0,
        //
        // Summary:
        //     Specifies a gradient from top to bottom.
        Vertical = 1,
        //
        // Summary:
        //     Specifies a gradient from upper left to lower right.
        ForwardDiagonal = 2,
        //
        // Summary:
        //     Specifies a gradient from upper right to lower left.
        BackwardDiagonal = 3
    }

它列舉了從第一種顏色過渡到第二種顏色的方向，從左到右，從上到下，從左上到右下，從右上到左下四個比較正規的方向；

關於LinearGradientBrush的另一個參數(float angle)，它用來指示顏色過渡的方向，結合LinearGradientMode理解，同時，指出，angle可以為負數，下圖幫助理解一下GDI+中的angle：

LinearGradientBrush類還有一些非常有用的屬性和方法，可以幫助完成一些更為復雜的任務，這里就不細說了，又需要的童鞋可以深入研究一下：）

        //
        // Summary:
        //     Gets or sets a System.Drawing.Drawing2D.ColorBlend that defines a multicolor
        //     linear gradient.
        //
        // Returns:
        //     A System.Drawing.Drawing2D.ColorBlend that defines a multicolor linear gradient.
        public ColorBlend InterpolationColors { get; set; }
        //
        // Summary:
        //     Gets or sets a System.Drawing.Drawing2D.Blend that specifies positions and factors
        //     that define a custom falloff for the gradient.
        //
        // Returns:
        //     A System.Drawing.Drawing2D.Blend that represents a custom falloff for the gradient.
        public Blend Blend { get; set; }
        //
        // Summary:
        //     Gets or sets a value indicating whether gamma correction is enabled for this
        //     System.Drawing.Drawing2D.LinearGradientBrush.
        //
        // Returns:
        //     The value is true if gamma correction is enabled for this System.Drawing.Drawing2D.LinearGradientBrush;
        //     otherwise, false.
        public bool GammaCorrection { get; set; }
        //
        // Summary:
        //     Gets a rectangular region that defines the starting and ending points of the
        //     gradient.
        //
        // Returns:
        //     A System.Drawing.RectangleF structure that specifies the starting and ending
        //     points of the gradient.
        public RectangleF Rectangle { get; }
        //
        // Summary:
        //     Gets or sets the starting and ending colors of the gradient.
        //
        // Returns:
        //     An array of two System.Drawing.Color structures that represents the starting
        //     and ending colors of the gradient.
        public Color[] LinearColors { get; set; }
        //
        // Summary:
        //     Gets or sets a System.Drawing.Drawing2D.WrapMode enumeration that indicates the
        //     wrap mode for this System.Drawing.Drawing2D.LinearGradientBrush.
        //
        // Returns:
        //     A System.Drawing.Drawing2D.WrapMode that specifies how fills drawn with this
        //     System.Drawing.Drawing2D.LinearGradientBrush are tiled.
        public WrapMode WrapMode { get; set; }
        //
        // Summary:
        //     Gets or sets a copy System.Drawing.Drawing2D.Matrix that defines a local geometric
        //     transform for this System.Drawing.Drawing2D.LinearGradientBrush.
        //
        // Returns:
        //     A copy of the System.Drawing.Drawing2D.Matrix that defines a geometric transform
        //     that applies only to fills drawn with this System.Drawing.Drawing2D.LinearGradientBrush.
        public Matrix Transform { get; set; }

        //
        // Summary:
        //     Creates an exact copy of this System.Drawing.Drawing2D.LinearGradientBrush.
        //
        // Returns:
        //     The System.Drawing.Drawing2D.LinearGradientBrush this method creates, cast as
        //     an object.
        public override object Clone();
        //
        // Summary:
        //     Multiplies the System.Drawing.Drawing2D.Matrix that represents the local geometric
        //     transform of this System.Drawing.Drawing2D.LinearGradientBrush by the specified
        //     System.Drawing.Drawing2D.Matrix in the specified order.
        //
        // Parameters:
        //   matrix:
        //     The System.Drawing.Drawing2D.Matrix by which to multiply the geometric transform.
        //
        //   order:
        //     A System.Drawing.Drawing2D.MatrixOrder that specifies in which order to multiply
        //     the two matrices.
        public void MultiplyTransform(Matrix matrix, MatrixOrder order);
        //
        // Summary:
        //     Multiplies the System.Drawing.Drawing2D.Matrix that represents the local geometric
        //     transform of this System.Drawing.Drawing2D.LinearGradientBrush by the specified
        //     System.Drawing.Drawing2D.Matrix by prepending the specified System.Drawing.Drawing2D.Matrix.
        //
        // Parameters:
        //   matrix:
        //     The System.Drawing.Drawing2D.Matrix by which to multiply the geometric transform.
        public void MultiplyTransform(Matrix matrix);
        //
        // Summary:
        //     Resets the System.Drawing.Drawing2D.LinearGradientBrush.Transform property to
        //     identity.
        public void ResetTransform();
        //
        // Summary:
        //     Rotates the local geometric transform by the specified amount. This method prepends
        //     the rotation to the transform.
        //
        // Parameters:
        //   angle:
        //     The angle of rotation.
        public void RotateTransform(float angle);
        //
        // Summary:
        //     Rotates the local geometric transform by the specified amount in the specified
        //     order.
        //
        // Parameters:
        //   angle:
        //     The angle of rotation.
        //
        //   order:
        //     A System.Drawing.Drawing2D.MatrixOrder that specifies whether to append or prepend
        //     the rotation matrix.
        public void RotateTransform(float angle, MatrixOrder order);
        //
        // Summary:
        //     Scales the local geometric transform by the specified amounts. This method prepends
        //     the scaling matrix to the transform.
        //
        // Parameters:
        //   sx:
        //     The amount by which to scale the transform in the x-axis direction.
        //
        //   sy:
        //     The amount by which to scale the transform in the y-axis direction.
        public void ScaleTransform(float sx, float sy);
        //
        // Summary:
        //     Scales the local geometric transform by the specified amounts in the specified
        //     order.
        //
        // Parameters:
        //   sx:
        //     The amount by which to scale the transform in the x-axis direction.
        //
        //   sy:
        //     The amount by which to scale the transform in the y-axis direction.
        //
        //   order:
        //     A System.Drawing.Drawing2D.MatrixOrder that specifies whether to append or prepend
        //     the scaling matrix.
        public void ScaleTransform(float sx, float sy, MatrixOrder order);
        //
        // Summary:
        //     Creates a linear gradient with a center color and a linear falloff to a single
        //     color on both ends.
        //
        // Parameters:
        //   focus:
        //     A value from 0 through 1 that specifies the center of the gradient (the point
        //     where the gradient is composed of only the ending color).
        //
        //   scale:
        //     A value from 0 through1 that specifies how fast the colors falloff from the starting
        //     color to focus (ending color)
        public void SetBlendTriangularShape(float focus, float scale);
        //
        // Summary:
        //     Creates a linear gradient with a center color and a linear falloff to a single
        //     color on both ends.
        //
        // Parameters:
        //   focus:
        //     A value from 0 through 1 that specifies the center of the gradient (the point
        //     where the gradient is composed of only the ending color).
        public void SetBlendTriangularShape(float focus);
        //
        // Summary:
        //     Creates a gradient falloff based on a bell-shaped curve.
        //
        // Parameters:
        //   focus:
        //     A value from 0 through 1 that specifies the center of the gradient (the point
        //     where the gradient is composed of only the ending color).
        //
        //   scale:
        //     A value from 0 through 1 that specifies how fast the colors falloff from the
        //     focus.
        public void SetSigmaBellShape(float focus, float scale);
        //
        // Summary:
        //     Creates a gradient falloff based on a bell-shaped curve.
        //
        // Parameters:
        //   focus:
        //     A value from 0 through 1 that specifies the center of the gradient (the point
        //     where the starting color and ending color are blended equally).
        public void SetSigmaBellShape(float focus);
        //
        // Summary:
        //     Translates the local geometric transform by the specified dimensions. This method
        //     prepends the translation to the transform.
        //
        // Parameters:
        //   dx:
        //     The value of the translation in x.
        //
        //   dy:
        //     The value of the translation in y.
        public void TranslateTransform(float dx, float dy);
        //
        // Summary:
        //     Translates the local geometric transform by the specified dimensions in the specified
        //     order.
        //
        // Parameters:
        //   dx:
        //     The value of the translation in x.
        //
        //   dy:
        //     The value of the translation in y.
        //
        //   order:
        //     The order (prepend or append) in which to apply the translation.
        public void TranslateTransform(float dx, float dy, MatrixOrder order);

2、繪制系統畫刷填充矩形

private void btnFillWithSystemBrushes_Click(object sender, EventArgs e)
{
    var rectangle = GetRandomRectangle();

    var systemBrushes = new List<Brush> {
    SystemBrushes.GradientInactiveCaption ,
    SystemBrushes.Window                  ,
    SystemBrushes.ScrollBar               ,
    SystemBrushes.MenuText                ,
    SystemBrushes.MenuHighlight           ,
    SystemBrushes.MenuBar                 ,
    SystemBrushes.Menu                    ,
    SystemBrushes.InfoText                ,
    SystemBrushes.Info                    ,
    SystemBrushes.InactiveCaptionText     ,
    SystemBrushes.InactiveBorder          ,
    SystemBrushes.InactiveCaption         ,
    SystemBrushes.HotTrack                ,
    SystemBrushes.HighlightText           ,
    SystemBrushes.Highlight               ,
    SystemBrushes.GrayText                ,
    SystemBrushes.WindowText              ,
    SystemBrushes.GradientActiveCaption   ,
    SystemBrushes.ActiveBorder            ,
    SystemBrushes.ActiveCaption           ,
    SystemBrushes.ActiveCaptionText       ,
    SystemBrushes.AppWorkspace            ,
    SystemBrushes.ButtonFace              ,
    SystemBrushes.ButtonHighlight         ,
    SystemBrushes.WindowFrame             ,
    SystemBrushes.ButtonShadow            ,
    SystemBrushes.ControlLightLight       ,
    SystemBrushes.ControlLight            ,
    SystemBrushes.ControlDark             ,
    SystemBrushes.ControlDarkDark         ,
    SystemBrushes.ControlText             ,
    SystemBrushes.Desktop                 ,
    SystemBrushes.Control                 ,};

    var brush = systemBrushes[random.Next(0, systemBrushes.Count)];

    using (var g = CreateGraphics())
    {
        g.Clear(SystemColors.AppWorkspace);
        g.SmoothingMode = SmoothingMode.HighQuality;
        g.FillRectangle(brush, rectangle);
    }

    ShowInformation($"畫刷填充，{rectangle}，畫刷名稱：{(brush as SolidBrush)?.Color.Name}。");
}

本示例取用系統畫刷SystemBrushes來作為填充，其實就是Windows系統的一些畫刷配置，比如桌面背景色、按鈕顏色等。除非制作自定義控件或組件，否則，其它場景可能很少應用。不過，這個示例也同樣適用於SolidBrush，就是純色畫刷。沒什么特表之處，一筆帶過吧。

3、繪制鑲嵌填充矩形

private void btnFillWithHatchBrush_Click(object sender, EventArgs e)
{
    var rectangle = GetRandomRectangle();

    var style = (HatchStyle)(random.Next(0, 53));
    var foreColor = GetRandomColor();
    var backColor = GetRandomColor();

    using (var g = CreateGraphics())
    using (var brush = new HatchBrush(style, foreColor, backColor))
    {
        g.Clear(SystemColors.AppWorkspace);
        g.SmoothingMode = SmoothingMode.HighQuality;
        g.FillRectangle(brush, rectangle);
    }

    ShowInformation($"鑲嵌填充，{rectangle}，前景色：{foreColor}，背景色：{backColor}，填充樣式：{style.ToString()}。");
}

System.Drawing.Drawing2D.HatchBrush是一個比較有意思的畫刷，它根據兩種顏色和不同的鑲嵌樣式，組合出各種不同的圖案，比較適合作為場景的背景，建議多玩兒玩兒。

技術上沒什么特別點，主要是支持的樣式比較多，就不一一介紹了。

namespace System.Drawing.Drawing2D
{
    //
    // Summary:
    //     Specifies the different patterns available for System.Drawing.Drawing2D.HatchBrush
    //     objects.
    public enum HatchStyle
    {
        //
        // Summary:
        //     A pattern of horizontal lines.
        Horizontal = 0,
        //
        // Summary:
        //     Specifies hatch style System.Drawing.Drawing2D.HatchStyle.Horizontal.
        Min = 0,
        //
        // Summary:
        //     A pattern of vertical lines.
        Vertical = 1,
        //
        // Summary:
        //     A pattern of lines on a diagonal from upper left to lower right.
        ForwardDiagonal = 2,
        //
        // Summary:
        //     A pattern of lines on a diagonal from upper right to lower left.
        BackwardDiagonal = 3,
        //
        // Summary:
        //     Specifies horizontal and vertical lines that cross.
        Cross = 4,
        //
        // Summary:
        //     Specifies the hatch style System.Drawing.Drawing2D.HatchStyle.Cross.
        LargeGrid = 4,
        //
        // Summary:
        //     Specifies hatch style System.Drawing.Drawing2D.HatchStyle.SolidDiamond.
        Max = 4,
        //
        // Summary:
        //     A pattern of crisscross diagonal lines.
        DiagonalCross = 5,
        //
        // Summary:
        //     Specifies a 5-percent hatch. The ratio of foreground color to background color
        //     is 5:95.
        Percent05 = 6,
        //
        // Summary:
        //     Specifies a 10-percent hatch. The ratio of foreground color to background color
        //     is 10:90.
        Percent10 = 7,
        //
        // Summary:
        //     Specifies a 20-percent hatch. The ratio of foreground color to background color
        //     is 20:80.
        Percent20 = 8,
        //
        // Summary:
        //     Specifies a 25-percent hatch. The ratio of foreground color to background color
        //     is 25:75.
        Percent25 = 9,
        //
        // Summary:
        //     Specifies a 30-percent hatch. The ratio of foreground color to background color
        //     is 30:70.
        Percent30 = 10,
        //
        // Summary:
        //     Specifies a 40-percent hatch. The ratio of foreground color to background color
        //     is 40:60.
        Percent40 = 11,
        //
        // Summary:
        //     Specifies a 50-percent hatch. The ratio of foreground color to background color
        //     is 50:50.
        Percent50 = 12,
        //
        // Summary:
        //     Specifies a 60-percent hatch. The ratio of foreground color to background color
        //     is 60:40.
        Percent60 = 13,
        //
        // Summary:
        //     Specifies a 70-percent hatch. The ratio of foreground color to background color
        //     is 70:30.
        Percent70 = 14,
        //
        // Summary:
        //     Specifies a 75-percent hatch. The ratio of foreground color to background color
        //     is 75:25.
        Percent75 = 15,
        //
        // Summary:
        //     Specifies a 80-percent hatch. The ratio of foreground color to background color
        //     is 80:100.
        Percent80 = 16,
        //
        // Summary:
        //     Specifies a 90-percent hatch. The ratio of foreground color to background color
        //     is 90:10.
        Percent90 = 17,
        //
        // Summary:
        //     Specifies diagonal lines that slant to the right from top points to bottom points
        //     and are spaced 50 percent closer together than System.Drawing.Drawing2D.HatchStyle.ForwardDiagonal,
        //     but are not antialiased.
        LightDownwardDiagonal = 18,
        //
        // Summary:
        //     Specifies diagonal lines that slant to the left from top points to bottom points
        //     and are spaced 50 percent closer together than System.Drawing.Drawing2D.HatchStyle.BackwardDiagonal,
        //     but they are not antialiased.
        LightUpwardDiagonal = 19,
        //
        // Summary:
        //     Specifies diagonal lines that slant to the right from top points to bottom points,
        //     are spaced 50 percent closer together than, and are twice the width of System.Drawing.Drawing2D.HatchStyle.ForwardDiagonal.
        //     This hatch pattern is not antialiased.
        DarkDownwardDiagonal = 20,
        //
        // Summary:
        //     Specifies diagonal lines that slant to the left from top points to bottom points,
        //     are spaced 50 percent closer together than System.Drawing.Drawing2D.HatchStyle.BackwardDiagonal,
        //     and are twice its width, but the lines are not antialiased.
        DarkUpwardDiagonal = 21,
        //
        // Summary:
        //     Specifies diagonal lines that slant to the right from top points to bottom points,
        //     have the same spacing as hatch style System.Drawing.Drawing2D.HatchStyle.ForwardDiagonal,
        //     and are triple its width, but are not antialiased.
        WideDownwardDiagonal = 22,
        //
        // Summary:
        //     Specifies diagonal lines that slant to the left from top points to bottom points,
        //     have the same spacing as hatch style System.Drawing.Drawing2D.HatchStyle.BackwardDiagonal,
        //     and are triple its width, but are not antialiased.
        WideUpwardDiagonal = 23,
        //
        // Summary:
        //     Specifies vertical lines that are spaced 50 percent closer together than System.Drawing.Drawing2D.HatchStyle.Vertical.
        LightVertical = 24,
        //
        // Summary:
        //     Specifies horizontal lines that are spaced 50 percent closer together than System.Drawing.Drawing2D.HatchStyle.Horizontal.
        LightHorizontal = 25,
        //
        // Summary:
        //     Specifies vertical lines that are spaced 75 percent closer together than hatch
        //     style System.Drawing.Drawing2D.HatchStyle.Vertical (or 25 percent closer together
        //     than System.Drawing.Drawing2D.HatchStyle.LightVertical).
        NarrowVertical = 26,
        //
        // Summary:
        //     Specifies horizontal lines that are spaced 75 percent closer together than hatch
        //     style System.Drawing.Drawing2D.HatchStyle.Horizontal (or 25 percent closer together
        //     than System.Drawing.Drawing2D.HatchStyle.LightHorizontal).
        NarrowHorizontal = 27,
        //
        // Summary:
        //     Specifies vertical lines that are spaced 50 percent closer together than System.Drawing.Drawing2D.HatchStyle.Vertical
        //     and are twice its width.
        DarkVertical = 28,
        //
        // Summary:
        //     Specifies horizontal lines that are spaced 50 percent closer together than System.Drawing.Drawing2D.HatchStyle.Horizontal
        //     and are twice the width of System.Drawing.Drawing2D.HatchStyle.Horizontal.
        DarkHorizontal = 29,
        //
        // Summary:
        //     Specifies dashed diagonal lines, that slant to the right from top points to bottom
        //     points.
        DashedDownwardDiagonal = 30,
        //
        // Summary:
        //     Specifies dashed diagonal lines, that slant to the left from top points to bottom
        //     points.
        DashedUpwardDiagonal = 31,
        //
        // Summary:
        //     Specifies dashed horizontal lines.
        DashedHorizontal = 32,
        //
        // Summary:
        //     Specifies dashed vertical lines.
        DashedVertical = 33,
        //
        // Summary:
        //     Specifies a hatch that has the appearance of confetti.
        SmallConfetti = 34,
        //
        // Summary:
        //     Specifies a hatch that has the appearance of confetti, and is composed of larger
        //     pieces than System.Drawing.Drawing2D.HatchStyle.SmallConfetti.
        LargeConfetti = 35,
        //
        // Summary:
        //     Specifies horizontal lines that are composed of zigzags.
        ZigZag = 36,
        //
        // Summary:
        //     Specifies horizontal lines that are composed of tildes.
        Wave = 37,
        //
        // Summary:
        //     Specifies a hatch that has the appearance of layered bricks that slant to the
        //     left from top points to bottom points.
        DiagonalBrick = 38,
        //
        // Summary:
        //     Specifies a hatch that has the appearance of horizontally layered bricks.
        HorizontalBrick = 39,
        //
        // Summary:
        //     Specifies a hatch that has the appearance of a woven material.
        Weave = 40,
        //
        // Summary:
        //     Specifies a hatch that has the appearance of a plaid material.
        Plaid = 41,
        //
        // Summary:
        //     Specifies a hatch that has the appearance of divots.
        Divot = 42,
        //
        // Summary:
        //     Specifies horizontal and vertical lines, each of which is composed of dots, that
        //     cross.
        DottedGrid = 43,
        //
        // Summary:
        //     Specifies forward diagonal and backward diagonal lines, each of which is composed
        //     of dots, that cross.
        DottedDiamond = 44,
        //
        // Summary:
        //     Specifies a hatch that has the appearance of diagonally layered shingles that
        //     slant to the right from top points to bottom points.
        Shingle = 45,
        //
        // Summary:
        //     Specifies a hatch that has the appearance of a trellis.
        Trellis = 46,
        //
        // Summary:
        //     Specifies a hatch that has the appearance of spheres laid adjacent to one another.
        Sphere = 47,
        //
        // Summary:
        //     Specifies horizontal and vertical lines that cross and are spaced 50 percent
        //     closer together than hatch style System.Drawing.Drawing2D.HatchStyle.Cross.
        SmallGrid = 48,
        //
        // Summary:
        //     Specifies a hatch that has the appearance of a checkerboard.
        SmallCheckerBoard = 49,
        //
        // Summary:
        //     Specifies a hatch that has the appearance of a checkerboard with squares that
        //     are twice the size of System.Drawing.Drawing2D.HatchStyle.SmallCheckerBoard.
        LargeCheckerBoard = 50,
        //
        // Summary:
        //     Specifies forward diagonal and backward diagonal lines that cross but are not
        //     antialiased.
        OutlinedDiamond = 51,
        //
        // Summary:
        //     Specifies a hatch that has the appearance of a checkerboard placed diagonally.
        SolidDiamond = 52
    }
}

4、繪制紋理填充矩形

private void btnFillWithTextureBrush_Click(object sender, EventArgs e)
{
    var rectangle = GetRandomRectangle();

    var wrapMode = (WrapMode)(random.Next(0, 5));

    var image = Icon.ToBitmap();

    using (var g = CreateGraphics())
    using (var brush = new TextureBrush(image, wrapMode))
    {
        g.Clear(SystemColors.AppWorkspace);
        g.SmoothingMode = SmoothingMode.HighQuality;
        g.FillRectangle(brush, rectangle);
    }

    ShowInformation($"紋理填充，{rectangle}，WrapMode：{wrapMode}。");
}

紋理填充的關鍵在於對System.Drawing.TextureBrush這個畫刷以及System.Drawing.Drawing2D.WrapMode的使用，

namespace System.Drawing
{
    //
    // Summary:
    //     Each property of the System.Drawing.TextureBrush class is a System.Drawing.Brush
    //     object that uses an image to fill the interior of a shape. This class cannot
    //     be inherited.
    public sealed class TextureBrush : Brush
    {
        //
        // Summary:
        //     Initializes a new System.Drawing.TextureBrush object that uses the specified
        //     image.
        //
        // Parameters:
        //   bitmap:
        //     The System.Drawing.Image object with which this System.Drawing.TextureBrush object
        //     fills interiors.
        public TextureBrush(Image bitmap);
        //
        // Summary:
        //     Initializes a new System.Drawing.TextureBrush object that uses the specified
        //     image and wrap mode.
        //
        // Parameters:
        //   image:
        //     The System.Drawing.Image object with which this System.Drawing.TextureBrush object
        //     fills interiors.
        //
        //   wrapMode:
        //     A System.Drawing.Drawing2D.WrapMode enumeration that specifies how this System.Drawing.TextureBrush
        //     object is tiled.
        public TextureBrush(Image image, WrapMode wrapMode);
        //
        // Summary:
        //     Initializes a new System.Drawing.TextureBrush object that uses the specified
        //     image and bounding rectangle.
        //
        // Parameters:
        //   image:
        //     The System.Drawing.Image object with which this System.Drawing.TextureBrush object
        //     fills interiors.
        //
        //   dstRect:
        //     A System.Drawing.RectangleF structure that represents the bounding rectangle
        //     for this System.Drawing.TextureBrush object.
        public TextureBrush(Image image, RectangleF dstRect);
        //
        // Summary:
        //     Initializes a new System.Drawing.TextureBrush object that uses the specified
        //     image and bounding rectangle.
        //
        // Parameters:
        //   image:
        //     The System.Drawing.Image object with which this System.Drawing.TextureBrush object
        //     fills interiors.
        //
        //   dstRect:
        //     A System.Drawing.Rectangle structure that represents the bounding rectangle for
        //     this System.Drawing.TextureBrush object.
        public TextureBrush(Image image, Rectangle dstRect);
        //
        // Summary:
        //     Initializes a new System.Drawing.TextureBrush object that uses the specified
        //     image, wrap mode, and bounding rectangle.
        //
        // Parameters:
        //   image:
        //     The System.Drawing.Image object with which this System.Drawing.TextureBrush object
        //     fills interiors.
        //
        //   wrapMode:
        //     A System.Drawing.Drawing2D.WrapMode enumeration that specifies how this System.Drawing.TextureBrush
        //     object is tiled.
        //
        //   dstRect:
        //     A System.Drawing.RectangleF structure that represents the bounding rectangle
        //     for this System.Drawing.TextureBrush object.
        public TextureBrush(Image image, WrapMode wrapMode, RectangleF dstRect);
        //
        // Summary:
        //     Initializes a new System.Drawing.TextureBrush object that uses the specified
        //     image, wrap mode, and bounding rectangle.
        //
        // Parameters:
        //   image:
        //     The System.Drawing.Image object with which this System.Drawing.TextureBrush object
        //     fills interiors.
        //
        //   wrapMode:
        //     A System.Drawing.Drawing2D.WrapMode enumeration that specifies how this System.Drawing.TextureBrush
        //     object is tiled.
        //
        //   dstRect:
        //     A System.Drawing.Rectangle structure that represents the bounding rectangle for
        //     this System.Drawing.TextureBrush object.
        public TextureBrush(Image image, WrapMode wrapMode, Rectangle dstRect);
        //
        // Summary:
        //     Initializes a new System.Drawing.TextureBrush object that uses the specified
        //     image, bounding rectangle, and image attributes.
        //
        // Parameters:
        //   image:
        //     The System.Drawing.Image object with which this System.Drawing.TextureBrush object
        //     fills interiors.
        //
        //   dstRect:
        //     A System.Drawing.RectangleF structure that represents the bounding rectangle
        //     for this System.Drawing.TextureBrush object.
        //
        //   imageAttr:
        //     An System.Drawing.Imaging.ImageAttributes object that contains additional information
        //     about the image used by this System.Drawing.TextureBrush object.
        public TextureBrush(Image image, RectangleF dstRect, ImageAttributes imageAttr);
        //
        // Summary:
        //     Initializes a new System.Drawing.TextureBrush object that uses the specified
        //     image, bounding rectangle, and image attributes.
        //
        // Parameters:
        //   image:
        //     The System.Drawing.Image object with which this System.Drawing.TextureBrush object
        //     fills interiors.
        //
        //   dstRect:
        //     A System.Drawing.Rectangle structure that represents the bounding rectangle for
        //     this System.Drawing.TextureBrush object.
        //
        //   imageAttr:
        //     An System.Drawing.Imaging.ImageAttributes object that contains additional information
        //     about the image used by this System.Drawing.TextureBrush object.
        public TextureBrush(Image image, Rectangle dstRect, ImageAttributes imageAttr);

        //
        // Summary:
        //     Gets or sets a copy of the System.Drawing.Drawing2D.Matrix object that defines
        //     a local geometric transformation for the image associated with this System.Drawing.TextureBrush
        //     object.
        //
        // Returns:
        //     A copy of the System.Drawing.Drawing2D.Matrix object that defines a geometric
        //     transformation that applies only to fills drawn by using this System.Drawing.TextureBrush
        //     object.
        public Matrix Transform { get; set; }
        //
        // Summary:
        //     Gets or sets a System.Drawing.Drawing2D.WrapMode enumeration that indicates the
        //     wrap mode for this System.Drawing.TextureBrush object.
        //
        // Returns:
        //     A System.Drawing.Drawing2D.WrapMode enumeration that specifies how fills drawn
        //     by using this System.Drawing.Drawing2D.LinearGradientBrush object are tiled.
        public WrapMode WrapMode { get; set; }
        //
        // Summary:
        //     Gets the System.Drawing.Image object associated with this System.Drawing.TextureBrush
        //     object.
        //
        // Returns:
        //     An System.Drawing.Image object that represents the image with which this System.Drawing.TextureBrush
        //     object fills shapes.
        public Image Image { get; }

        //
        // Summary:
        //     Creates an exact copy of this System.Drawing.TextureBrush object.
        //
        // Returns:
        //     The System.Drawing.TextureBrush object this method creates, cast as an System.Object
        //     object.
        public override object Clone();
        //
        // Summary:
        //     Multiplies the System.Drawing.Drawing2D.Matrix object that represents the local
        //     geometric transformation of this System.Drawing.TextureBrush object by the specified
        //     System.Drawing.Drawing2D.Matrix object in the specified order.
        //
        // Parameters:
        //   matrix:
        //     The System.Drawing.Drawing2D.Matrix object by which to multiply the geometric
        //     transformation.
        //
        //   order:
        //     A System.Drawing.Drawing2D.MatrixOrder enumeration that specifies the order in
        //     which to multiply the two matrices.
        public void MultiplyTransform(Matrix matrix, MatrixOrder order);
        //
        // Summary:
        //     Multiplies the System.Drawing.Drawing2D.Matrix object that represents the local
        //     geometric transformation of this System.Drawing.TextureBrush object by the specified
        //     System.Drawing.Drawing2D.Matrix object by prepending the specified System.Drawing.Drawing2D.Matrix
        //     object.
        //
        // Parameters:
        //   matrix:
        //     The System.Drawing.Drawing2D.Matrix object by which to multiply the geometric
        //     transformation.
        public void MultiplyTransform(Matrix matrix);
        //
        // Summary:
        //     Resets the Transform property of this System.Drawing.TextureBrush object to identity.
        public void ResetTransform();
        //
        // Summary:
        //     Rotates the local geometric transformation of this System.Drawing.TextureBrush
        //     object by the specified amount. This method prepends the rotation to the transformation.
        //
        // Parameters:
        //   angle:
        //     The angle of rotation.
        public void RotateTransform(float angle);
        //
        // Summary:
        //     Rotates the local geometric transformation of this System.Drawing.TextureBrush
        //     object by the specified amount in the specified order.
        //
        // Parameters:
        //   angle:
        //     The angle of rotation.
        //
        //   order:
        //     A System.Drawing.Drawing2D.MatrixOrder enumeration that specifies whether to
        //     append or prepend the rotation matrix.
        public void RotateTransform(float angle, MatrixOrder order);
        //
        // Summary:
        //     Scales the local geometric transformation of this System.Drawing.TextureBrush
        //     object by the specified amounts. This method prepends the scaling matrix to the
        //     transformation.
        //
        // Parameters:
        //   sx:
        //     The amount by which to scale the transformation in the x direction.
        //
        //   sy:
        //     The amount by which to scale the transformation in the y direction.
        public void ScaleTransform(float sx, float sy);
        //
        // Summary:
        //     Scales the local geometric transformation of this System.Drawing.TextureBrush
        //     object by the specified amounts in the specified order.
        //
        // Parameters:
        //   sx:
        //     The amount by which to scale the transformation in the x direction.
        //
        //   sy:
        //     The amount by which to scale the transformation in the y direction.
        //
        //   order:
        //     A System.Drawing.Drawing2D.MatrixOrder enumeration that specifies whether to
        //     append or prepend the scaling matrix.
        public void ScaleTransform(float sx, float sy, MatrixOrder order);
        //
        // Summary:
        //     Translates the local geometric transformation of this System.Drawing.TextureBrush
        //     object by the specified dimensions. This method prepends the translation to the
        //     transformation.
        //
        // Parameters:
        //   dx:
        //     The dimension by which to translate the transformation in the x direction.
        //
        //   dy:
        //     The dimension by which to translate the transformation in the y direction.
        public void TranslateTransform(float dx, float dy);
        //
        // Summary:
        //     Translates the local geometric transformation of this System.Drawing.TextureBrush
        //     object by the specified dimensions in the specified order.
        //
        // Parameters:
        //   dx:
        //     The dimension by which to translate the transformation in the x direction.
        //
        //   dy:
        //     The dimension by which to translate the transformation in the y direction.
        //
        //   order:
        //     The order (prepend or append) in which to apply the translation.
        public void TranslateTransform(float dx, float dy, MatrixOrder order);
    }
}

namespace System.Drawing.Drawing2D
{
    //
    // Summary:
    //     Specifies how a texture or gradient is tiled when it is smaller than the area
    //     being filled.
    public enum WrapMode
    {
        //
        // Summary:
        //     Tiles the gradient or texture.
        Tile = 0,
        //
        // Summary:
        //     Reverses the texture or gradient horizontally and then tiles the texture or gradient.
        TileFlipX = 1,
        //
        // Summary:
        //     Reverses the texture or gradient vertically and then tiles the texture or gradient.
        TileFlipY = 2,
        //
        // Summary:
        //     Reverses the texture or gradient horizontally and vertically and then tiles the
        //     texture or gradient.
        TileFlipXY = 3,
        //
        // Summary:
        //     The texture or gradient is not tiled.
        Clamp = 4
    }
}

TextureBrush這個畫刷的主要成分是Image，由於我們還沒接觸Image，這里就簡單實現一下使用范例，等以后對Image有足夠的了解，這個畫刷也就非常簡單了。本示例就簡單的將窗體的Icon作為Image使用了。

5、繪制路徑過渡填充矩形

private void btnFillWithPathGradientBrush_Click(object sender, EventArgs e)
{
    var rectangle = GetRandomRectangle();

    var wrapMode = (WrapMode)(random.Next(0, 5));

    var points = new Point[] { GetRandomPoint(), GetRandomPoint(), GetRandomPoint(), GetRandomPoint(), GetRandomPoint() };

    using (var g = CreateGraphics())
    using (var pen = new Pen(penColor, 2f))
    using (var brush = new PathGradientBrush(points, wrapMode))
    {
        g.Clear(SystemColors.AppWorkspace);
        g.SmoothingMode = SmoothingMode.HighQuality;
        g.DrawRectangle(pen, rectangle);
        g.FillRectangle(brush, rectangle);
    }

    ShowInformation($"路徑填充，{rectangle}，WrapMode：{wrapMode}。");
}

路徑過渡填充的關鍵在於對System.Drawing.Drawing2D.PathGradientBrush的使用以及與紋理填充一樣的WrapMode。

namespace System.Drawing.Drawing2D
{
    //
    // Summary:
    //     Encapsulates a System.Drawing.Brush object that fills the interior of a System.Drawing.Drawing2D.GraphicsPath
    //     object with a gradient. This class cannot be inherited.
    public sealed class PathGradientBrush : Brush
    {
        //
        // Summary:
        //     Initializes a new instance of the System.Drawing.Drawing2D.PathGradientBrush
        //     class with the specified points.
        //
        // Parameters:
        //   points:
        //     An array of System.Drawing.PointF structures that represents the points that
        //     make up the vertices of the path.
        public PathGradientBrush(PointF[] points);
        //
        // Summary:
        //     Initializes a new instance of the System.Drawing.Drawing2D.PathGradientBrush
        //     class with the specified points.
        //
        // Parameters:
        //   points:
        //     An array of System.Drawing.Point structures that represents the points that make
        //     up the vertices of the path.
        public PathGradientBrush(Point[] points);
        //
        // Summary:
        //     Initializes a new instance of the System.Drawing.Drawing2D.PathGradientBrush
        //     class with the specified path.
        //
        // Parameters:
        //   path:
        //     The System.Drawing.Drawing2D.GraphicsPath that defines the area filled by this
        //     System.Drawing.Drawing2D.PathGradientBrush.
        public PathGradientBrush(GraphicsPath path);
        //
        // Summary:
        //     Initializes a new instance of the System.Drawing.Drawing2D.PathGradientBrush
        //     class with the specified points and wrap mode.
        //
        // Parameters:
        //   points:
        //     An array of System.Drawing.PointF structures that represents the points that
        //     make up the vertices of the path.
        //
        //   wrapMode:
        //     A System.Drawing.Drawing2D.WrapMode that specifies how fills drawn with this
        //     System.Drawing.Drawing2D.PathGradientBrush are tiled.
        public PathGradientBrush(PointF[] points, WrapMode wrapMode);
        //
        // Summary:
        //     Initializes a new instance of the System.Drawing.Drawing2D.PathGradientBrush
        //     class with the specified points and wrap mode.
        //
        // Parameters:
        //   points:
        //     An array of System.Drawing.Point structures that represents the points that make
        //     up the vertices of the path.
        //
        //   wrapMode:
        //     A System.Drawing.Drawing2D.WrapMode that specifies how fills drawn with this
        //     System.Drawing.Drawing2D.PathGradientBrush are tiled.
        public PathGradientBrush(Point[] points, WrapMode wrapMode);

        //
        // Summary:
        //     Gets or sets a copy of the System.Drawing.Drawing2D.Matrix that defines a local
        //     geometric transform for this System.Drawing.Drawing2D.PathGradientBrush.
        //
        // Returns:
        //     A copy of the System.Drawing.Drawing2D.Matrix that defines a geometric transform
        //     that applies only to fills drawn with this System.Drawing.Drawing2D.PathGradientBrush.
        public Matrix Transform { get; set; }
        //
        // Summary:
        //     Gets or sets a System.Drawing.Drawing2D.ColorBlend that defines a multicolor
        //     linear gradient.
        //
        // Returns:
        //     A System.Drawing.Drawing2D.ColorBlend that defines a multicolor linear gradient.
        public ColorBlend InterpolationColors { get; set; }
        //
        // Summary:
        //     Gets or sets a System.Drawing.Drawing2D.Blend that specifies positions and factors
        //     that define a custom falloff for the gradient.
        //
        // Returns:
        //     A System.Drawing.Drawing2D.Blend that represents a custom falloff for the gradient.
        public Blend Blend { get; set; }
        //
        // Summary:
        //     Gets a bounding rectangle for this System.Drawing.Drawing2D.PathGradientBrush.
        //
        // Returns:
        //     A System.Drawing.RectangleF that represents a rectangular region that bounds
        //     the path this System.Drawing.Drawing2D.PathGradientBrush fills.
        public RectangleF Rectangle { get; }
        //
        // Summary:
        //     Gets or sets the center point of the path gradient.
        //
        // Returns:
        //     A System.Drawing.PointF that represents the center point of the path gradient.
        public PointF CenterPoint { get; set; }
        //
        // Summary:
        //     Gets or sets an array of colors that correspond to the points in the path this
        //     System.Drawing.Drawing2D.PathGradientBrush fills.
        //
        // Returns:
        //     An array of System.Drawing.Color structures that represents the colors associated
        //     with each point in the path this System.Drawing.Drawing2D.PathGradientBrush fills.
        public Color[] SurroundColors { get; set; }
        //
        // Summary:
        //     Gets or sets the color at the center of the path gradient.
        //
        // Returns:
        //     A System.Drawing.Color that represents the color at the center of the path gradient.
        public Color CenterColor { get; set; }
        //
        // Summary:
        //     Gets or sets the focus point for the gradient falloff.
        //
        // Returns:
        //     A System.Drawing.PointF that represents the focus point for the gradient falloff.
        public PointF FocusScales { get; set; }
        //
        // Summary:
        //     Gets or sets a System.Drawing.Drawing2D.WrapMode that indicates the wrap mode
        //     for this System.Drawing.Drawing2D.PathGradientBrush.
        //
        // Returns:
        //     A System.Drawing.Drawing2D.WrapMode that specifies how fills drawn with this
        //     System.Drawing.Drawing2D.PathGradientBrush are tiled.
        public WrapMode WrapMode { get; set; }

        //
        // Summary:
        //     Creates an exact copy of this System.Drawing.Drawing2D.PathGradientBrush.
        //
        // Returns:
        //     The System.Drawing.Drawing2D.PathGradientBrush this method creates, cast as an
        //     object.
        public override object Clone();
        //
        // Summary:
        //     Updates the brush's transformation matrix with the product of brush's transformation
        //     matrix multiplied by another matrix.
        //
        // Parameters:
        //   matrix:
        //     The System.Drawing.Drawing2D.Matrix that will be multiplied by the brush's current
        //     transformation matrix.
        public void MultiplyTransform(Matrix matrix);
        //
        // Summary:
        //     Updates the brush's transformation matrix with the product of the brush's transformation
        //     matrix multiplied by another matrix.
        //
        // Parameters:
        //   matrix:
        //     The System.Drawing.Drawing2D.Matrix that will be multiplied by the brush's current
        //     transformation matrix.
        //
        //   order:
        //     A System.Drawing.Drawing2D.MatrixOrder that specifies in which order to multiply
        //     the two matrices.
        public void MultiplyTransform(Matrix matrix, MatrixOrder order);
        //
        // Summary:
        //     Resets the System.Drawing.Drawing2D.PathGradientBrush.Transform property to identity.
        public void ResetTransform();
        //
        // Summary:
        //     Rotates the local geometric transform by the specified amount. This method prepends
        //     the rotation to the transform.
        //
        // Parameters:
        //   angle:
        //     The angle (extent) of rotation.
        public void RotateTransform(float angle);
        //
        // Summary:
        //     Rotates the local geometric transform by the specified amount in the specified
        //     order.
        //
        // Parameters:
        //   angle:
        //     The angle (extent) of rotation.
        //
        //   order:
        //     A System.Drawing.Drawing2D.MatrixOrder that specifies whether to append or prepend
        //     the rotation matrix.
        public void RotateTransform(float angle, MatrixOrder order);
        //
        // Summary:
        //     Scales the local geometric transform by the specified amounts. This method prepends
        //     the scaling matrix to the transform.
        //
        // Parameters:
        //   sx:
        //     The transform scale factor in the x-axis direction.
        //
        //   sy:
        //     The transform scale factor in the y-axis direction.
        public void ScaleTransform(float sx, float sy);
        //
        // Summary:
        //     Scales the local geometric transform by the specified amounts in the specified
        //     order.
        //
        // Parameters:
        //   sx:
        //     The transform scale factor in the x-axis direction.
        //
        //   sy:
        //     The transform scale factor in the y-axis direction.
        //
        //   order:
        //     A System.Drawing.Drawing2D.MatrixOrder that specifies whether to append or prepend
        //     the scaling matrix.
        public void ScaleTransform(float sx, float sy, MatrixOrder order);
        //
        // Summary:
        //     Creates a gradient with a center color and a linear falloff to each surrounding
        //     color.
        //
        // Parameters:
        //   focus:
        //     A value from 0 through 1 that specifies where, along any radial from the center
        //     of the path to the path's boundary, the center color will be at its highest intensity.
        //     A value of 1 (the default) places the highest intensity at the center of the
        //     path.
        //
        //   scale:
        //     A value from 0 through 1 that specifies the maximum intensity of the center color
        //     that gets blended with the boundary color. A value of 1 causes the highest possible
        //     intensity of the center color, and it is the default value.
        public void SetBlendTriangularShape(float focus, float scale);
        //
        // Summary:
        //     Creates a gradient with a center color and a linear falloff to one surrounding
        //     color.
        //
        // Parameters:
        //   focus:
        //     A value from 0 through 1 that specifies where, along any radial from the center
        //     of the path to the path's boundary, the center color will be at its highest intensity.
        //     A value of 1 (the default) places the highest intensity at the center of the
        //     path.
        public void SetBlendTriangularShape(float focus);
        //
        // Summary:
        //     Creates a gradient brush that changes color starting from the center of the path
        //     outward to the path's boundary. The transition from one color to another is based
        //     on a bell-shaped curve.
        //
        // Parameters:
        //   focus:
        //     A value from 0 through 1 that specifies where, along any radial from the center
        //     of the path to the path's boundary, the center color will be at its highest intensity.
        //     A value of 1 (the default) places the highest intensity at the center of the
        //     path.
        //
        //   scale:
        //     A value from 0 through 1 that specifies the maximum intensity of the center color
        //     that gets blended with the boundary color. A value of 1 causes the highest possible
        //     intensity of the center color, and it is the default value.
        public void SetSigmaBellShape(float focus, float scale);
        //
        // Summary:
        //     Creates a gradient brush that changes color starting from the center of the path
        //     outward to the path's boundary. The transition from one color to another is based
        //     on a bell-shaped curve.
        //
        // Parameters:
        //   focus:
        //     A value from 0 through 1 that specifies where, along any radial from the center
        //     of the path to the path's boundary, the center color will be at its highest intensity.
        //     A value of 1 (the default) places the highest intensity at the center of the
        //     path.
        public void SetSigmaBellShape(float focus);
        //
        // Summary:
        //     Applies the specified translation to the local geometric transform in the specified
        //     order.
        //
        // Parameters:
        //   dx:
        //     The value of the translation in x.
        //
        //   dy:
        //     The value of the translation in y.
        //
        //   order:
        //     The order (prepend or append) in which to apply the translation.
        public void TranslateTransform(float dx, float dy, MatrixOrder order);
        //
        // Summary:
        //     Applies the specified translation to the local geometric transform. This method
        //     prepends the translation to the transform.
        //
        // Parameters:
        //   dx:
        //     The value of the translation in x.
        //
        //   dy:
        //     The value of the translation in y.
        public void TranslateTransform(float dx, float dy);
    }
}

從它的構造函數可以看出，其實它就是需要指定一些關鍵點，有了這些點，它就可以構造一個GraphicsPath，路徑可以作為矢量的描述，也就是通常說的放大、縮小不失真。

本例中取了幾個隨機點，所以，填充看起來，比較抽象……

好了，到這里呢，關於矩形的基本畫法就已經全部介紹完了，感覺有點EZ？ BORED？那么我們就來利用現有的知識，再來耍個花活？

6、繪制會浮動的變色魔法箱

private Rectangle magicRectangle = Rectangle.Empty;
enum Directions : short { UP = 1, RIGHT = 2, DOWN = 4, LEFT = 8, };
private Directions direction = Directions.UP | Directions.RIGHT;
private Color magicColor = Color.FromArgb(0, 0, 255);
private int increament = 1;

private void btnMagicBox_Click(object sender, EventArgs e)
{
    direction = Directions.UP | Directions.RIGHT;

    magicRectangle = GetRandomRectangle();

    using (var g = CreateGraphics())
        g.Clear(SystemColors.AppWorkspace);

    timer.Enabled = !timer.Enabled;

    ShowInformation($"魔法箱，開始：{timer.Enabled}。");
}

private void timer_Tick(object sender, EventArgs e)
{
    using (var g = CreateGraphics())
    using (var brush = new SolidBrush(magicColor))
    {
        g.FillRectangle(new SolidBrush(SystemColors.AppWorkspace), magicRectangle);

        magicColor = Color.FromArgb(magicColor.R + increament, magicColor.G + increament, magicColor.B - increament);
        if (0 == magicColor.R || 255 == magicColor.R) increament = -increament;

        if (magicRectangle.Top <= ClientRectangle.Top && Directions.UP == (direction & Directions.UP))
            direction = direction ^ Directions.UP | Directions.DOWN;

        if (magicRectangle.Left <= ClientRectangle.Left && Directions.LEFT == (direction & Directions.LEFT))
            direction = direction ^ Directions.LEFT | Directions.RIGHT;

        if (magicRectangle.Right >= ClientRectangle.Right && Directions.RIGHT == (direction & Directions.RIGHT))
            direction = direction ^ Directions.RIGHT | Directions.LEFT;

        if (magicRectangle.Bottom >= ClientRectangle.Bottom - pnlToolbox.Height && Directions.DOWN == (direction & Directions.DOWN))
            direction = direction ^ Directions.DOWN | Directions.UP;

        if (Directions.UP == (direction & Directions.UP)) magicRectangle.Offset(0, -3);
        if (Directions.LEFT == (direction & Directions.LEFT)) magicRectangle.Offset(-3, 0);
        if (Directions.RIGHT == (direction & Directions.RIGHT)) magicRectangle.Offset(3, 0);
        if (Directions.DOWN == (direction & Directions.DOWN)) magicRectangle.Offset(0, 3);

        g.FillRectangle(brush, magicRectangle);
    }

}

原理也不復雜，點擊“魔法箱”按鈕，獲取一個隨機Rectangle賦值給magicRectangle，切換timer組件的Enable。在timer_Tick事件中，做五件事：

1. 將magicRectangle的當前位置填充成背景色；
2. 獲取一個變化的顏色，為了使顏色不那么跳躍，這里對magicColor的變化作了一些手腳；
3. 做碰撞檢測，以改變箱子的運動方向；
4. 根據箱子的運動方向，用Rectangle.Offset()方法修改矩形的位置；
5. 為矩形填充magicColor；

由於截圖也看不出動態效果，就不上圖了，有興趣的童鞋可以Run代碼看看效果：）

 

Okay，關於GDI+畫矩形的部分，我們就到此告一段落了。

其實說了半天，也沒多復雜，基本方法就是Graphics.FillRectangle(Brush brush, Rectangle rect)，區別就在於我們如何構造一個合適的Brush。

 

喜歡本系列叢書的朋友,可以點擊鏈接加入QQ交流群(994761602)【C# 破境之道】
方便各位在有疑問的時候可以及時給我個反饋。同時，也算是給各位志同道合的朋友提供一個交流的平台。
需要源碼的童鞋，也可以在群文件中獲取最新源代碼。