关于Graphics也有了基本了解下面想说的的是学这个东东干什么呢，到底如何应用
目前常见应用
1、验证码（参照网上的）
2、打印排版（会提到关于条形码大小设置）
3、自定义控件
一、验证码
class ValidateCode
{
#region 定义和初始化配置字段 //用户存取验证码字符串
public string validationCode = String.Empty; //生成的验证码字符串
public char[] chars = null; /// <summary>
/// 获取随机验证码
/// </summary>
public String ValidationCode
{
get { return validationCode; }
} /// <summary>
/// 验证码字符串的长度
/// </summary>
private Int32 validationCodeCount = ; /// <summary>
/// 获取和设置验证码字符串的长度
/// </summary>
public Int32 ValidationCodeCount
{
get { return validationCodeCount; }
set { validationCodeCount = value; }
} /// <summary>
/// 画板对象
/// </summary>
Graphics dc = null; //验证码的宽度，默认为130
private int bgWidth = ; /// <summary>
/// 验证码的宽度，默认为130
/// </summary>
public Int32 Width
{
get { return bgWidth; }
set { bgWidth = value; }
} //验证码的宽度，默认为130
private int bgHeight = ; /// <summary>
/// 验证码的高度，默认为40
/// </summary>
public Int32 Height
{
get { return bgHeight; }
set { bgHeight = value; }
} //字体大小 字体最小值
private int fontMinSize = ; /// <summary>
/// 验证码字体的最小值，默认为20,建议不小于15像素
/// </summary>
public Int32 FontMinSize
{
get { return fontMinSize; }
set { fontMinSize = value; }
}
//字体大小 字体最大值
private Int32 fontMaxSize = ; /// <summary>
/// 验证码字体的最大值，默认为25
/// </summary>
public Int32 FontMaxSize
{
get { return fontMaxSize; }
set { fontMaxSize = value; }
} //验证码字体的颜色
private Color[] fontColor = { }; /// <summary>
/// 验证码字体的颜色，默认为系统自动生成字体颜色
/// </summary>
public Color[] FontColor
{
get { return fontColor; }
set { fontColor = value; }
} private Color backColor = Color.FromArgb(, , ); /// <summary>
/// 验证码的背景色，默认为Color.FromArgb(243, 251, 254)
/// </summary>
public Color BackgroundColor
{
get { return backColor; }
set { backColor = value; }
} //贝塞尔曲线的条数,默认为3条
private Int32 bezierCount = ; /// <summary>
/// 贝塞尔曲线的条数,默认为3条
/// </summary>
public Int32 BezierCount
{
get { return bezierCount; }
set { bezierCount = value; }
} //直线条数，默认为3条
private Int32 lineCount = ; /// <summary>
/// 直线条数，默认为3条
/// </summary>
public Int32 LineCount
{
get { return lineCount; }
set { lineCount = value; }
} //随机字符串列表
private String charCollection = "2,3,4,5,6,7,8,9,a,s,d,f,g,h,z,c,v,b,n,m,k,q,w,e,r,t,y,u,p,A,S,D,F,G,H,Z,C,V,B,N,M,K,Q,W,E,R,T,Y,U,P"; //定义验证码字符及出现频次 ,避免出现0 o j i l 1 x; /// <summary>
/// 随机字符串列表，请使用英文状态下的逗号分隔
/// </summary>
public String CharCollection
{
get { return charCollection; }
set { charCollection = value; }
} //验证码字符串个数，默认为4个字符
private Int32 intCount = ; /// <summary>
/// 验证码字符串个数，默认为4个字符
/// </summary>
public Int32 IntCount
{
get { return intCount; }
set { intCount = value; }
} //是否添加噪点，默认添加，噪点颜色为系统随机生成。
private Boolean isPixel = true;
/// <summary>
/// 是否添加噪点，默认添加，噪点颜色为系统随机生成。
/// </summary>
public Boolean IsPixel
{
get { return isPixel; }
set { isPixel = value; }
} //是否添加随机噪点字符串，默认添加
private Boolean isRandString = true;
/// <summary>
/// 是否添加随机噪点字符串，默认添加
/// </summary>
public Boolean IsRandString
{
get { return isRandString; }
set { isRandString = value; }
} /// <summary>
/// 随机背景字符串的个数
/// </summary>
public Int32 RandomStringCount
{
get; set;
} //随机背景字符串的大小
private Int32 randomStringFontSize = ;
/// <summary>
/// 随机背景字符串的大小
/// </summary>
public Int32 RandomStringFontSize
{
get { return randomStringFontSize; }
set { randomStringFontSize = value; }
} /// <summary>
/// 是否对图片进行扭曲
/// </summary>
public Boolean IsTwist
{
get; set;
} /// <summary>
/// 边框样式
/// </summary>
public enum BorderStyle
{
/// <summary>
/// 无边框
/// </summary>
None,
/// <summary>
/// 矩形边框
/// </summary>
Rectangle,
/// <summary>
/// 圆角边框
/// </summary>
RoundRectangle
} /// <summary>
/// 验证码字符串随机转动的角度 默认40
/// </summary>
private Int32 rotationAngle = ;
/// <summary>
/// 验证码字符串随机转动的角度的最大值
/// </summary>
public Int32 RotationAngle
{
get { return rotationAngle; }
set { rotationAngle = value; }
} /// <summary>
/// 设置或获取边框样式
/// </summary>
public BorderStyle Border
{
get; set;
} /// <summary>
/// 对验证码图片进行高斯模糊的阀值，如果设置为0
/// </summary>
private Double gaussianDeviation = ; /// <summary>
/// 对验证码图片进行高斯模糊的阀值，如果设置为0，则不对图片进行高斯模糊，该设置可能会对图片处理的性能有较大影响
/// </summary>
public Double GaussianDeviation
{
get { return gaussianDeviation; }
set { gaussianDeviation = value; }
}
private Int32 brightnessValue = ;
/// <summary>
/// 对图片进行暗度和亮度的调整，如果该值为0，则不调整。该设置会对图片处理性能有较大影响
/// </summary>
public Int32 BrightnessValue
{
get { return brightnessValue; }
set { brightnessValue = value; }
} #endregion private Point[] strPoint = null; Random random = new Random(); /// <summary>
/// 构造函数，用于初始化常用变量
/// </summary>
public void DrawValidationCode()
{
//随机对象
//Random类所取到的系统时钟种子接近甚至完全一样
//解决方案：new Random(Guid.NewGuid().GetHashCode());
random = new Random(Guid.NewGuid().GetHashCode());
//坐标数组
strPoint = new Point[validationCodeCount + ];
if (gaussianDeviation < )
gaussianDeviation = ;
} /// <summary>
/// 生成验证码
/// 思路：多张图片合成
/// 1.验证码背景图片
/// 1.1.背景包含
/// 1.1.1.背景颜色
/// 1.1.2.噪点
/// 1.1.3.干扰文字
/// 1.1.4.干扰线条（直线、曲线）
/// 2.验证码字符
/// 3.验证码图片扭曲
/// 4.验证码图片模糊
/// 5.验证码图片亮度
/// 6.验证码图片保持在内存流中
/// </summary>
/// <param name="target">用于存储图片的一般字节序列</param>
public MemoryStream CreateImage(string code)
{
MemoryStream target = new MemoryStream();
// 定义图片对象大小，
Bitmap bit = new Bitmap(bgWidth + , bgHeight + );
// 定义 Graphics（画板）根据图片对象
dc = Graphics.FromImage(bit);
/*
SmoothingModeAntiAlias 指定消除锯齿的呈现。
SmoothingModeDefault 指定默认模式。
SmoothingModeHighQuality 指定高质量、低速度呈现。
SmoothingModeHighSpeed 指定高速度、低质量呈现。
SmoothingModeInvalid 指定一个无效模式。
SmoothingModeNone 指定不消除锯齿。
*/
dc.SmoothingMode = SmoothingMode.HighQuality;
//文本的呈现模式
dc.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
// 插补模式
dc.InterpolationMode = InterpolationMode.HighQualityBilinear;
//合成图像的呈现质量
dc.CompositingQuality = CompositingQuality.HighQuality;
try
{
//清空画板，指定背景色（白色）
dc.Clear(Color.White);
DrawValidationCode();
//DrawImageUnscaled 在指定的位置使用图像的原始物理大小绘制指定的图像
// 验证码背景
dc.DrawImageUnscaled(DrawBackground(), , );
// 验证码字符
dc.DrawImageUnscaled(DrawRandomString(code), , );
//对图片文字进行扭曲
bit = AdjustRippleEffect(bit, );
//对图片进行高斯模糊
if (gaussianDeviation > )
{
Gaussian gau = new Gaussian();
bit = gau.FilterProcessImage(gaussianDeviation, bit);
}
//进行暗度和亮度处理
if (brightnessValue != )
{
//对图片进行调暗处理
bit = AdjustBrightness(bit, brightnessValue);
}
bit.Save(target, ImageFormat.Jpeg);
//输出图片流
return target; }
finally
{
//brush.Dispose();
bit.Dispose();
dc.Dispose();
}
} #region 画验证码背景，例如，增加早点，添加曲线和直线等
/// <summary>
/// 画验证码背景，例如，增加早点，添加曲线和直线等
/// 1.1.背景包含
/// 1.1.1.背景颜色
/// 1.1.2.噪点
/// 1.1.3.干扰文字
/// 1.1.4.干扰线条（直线、曲线）
/// </summary>
/// <returns>Bitmap 对象</returns>
private Bitmap DrawBackground()
{
Bitmap bit = new Bitmap(bgWidth + , bgHeight + );
Graphics g = Graphics.FromImage(bit);
g.SmoothingMode = SmoothingMode.HighQuality;
g.Clear(Color.White);
Rectangle rectangle = new Rectangle(, , bgWidth, bgHeight);
Brush brush = new SolidBrush(backColor);
//填充矩形
g.FillRectangle(brush, rectangle);
//画噪点
if (isPixel)
{
g.DrawImageUnscaled(DrawRandomPixel(), , );
}
// 背景干扰字符
g.DrawImageUnscaled(DrawRandBgString(), , );
//画曲线
//g.DrawImageUnscaled(DrawRandomBezier(bezierCount), 0, 0);
//画直线
//g.DrawImageUnscaled(DrawRandomLine(lineCount), 0, 0);
if (Border == BorderStyle.Rectangle)
{
//绘制边框
g.DrawRectangle(new Pen(Color.FromArgb(, , )), , , bgWidth, bgHeight);
}
else if (Border == BorderStyle.RoundRectangle)
{
//画圆角
DrawRoundRectangle(g, rectangle, Color.FromArgb(, , ), , );
}
return bit;
}
#endregion #region 画随机噪点
/// <summary>
/// 画随机噪点
/// 在指定区域中随机设置像素点的颜色
/// </summary>
/// <param name="pixNum">噪点的百分比</param>
/// <returns></returns>
public Bitmap DrawRandomPixel(Int32 pixNum)
{
Bitmap b = new Bitmap(bgWidth, bgHeight);
//透明化
b.MakeTransparent();
Graphics graph = Graphics.FromImage(b);
graph.SmoothingMode = SmoothingMode.HighQuality;
graph.InterpolationMode = InterpolationMode.HighQualityBilinear;
//画噪点
for (int i = ; i < (bgHeight * bgWidth) / pixNum; i++)
{
int x = random.Next(b.Width);
int y = random.Next(b.Height);
//设置随机像素点的颜色
b.SetPixel(x, y, GetRandomDeepColor());
//下移坐标重新画点
if ((x + ) < b.Width && (y + ) < b.Height)
{
//画图片的前景噪音点
graph.DrawRectangle(new Pen(Color.Silver), random.Next(b.Width), random.Next(b.Height), , );
}
}
return b;
}
#endregion #region 画干扰背景文字
/// <summary>
/// 画背景干扰文字
/// </summary>
/// <returns></returns>
private Bitmap DrawRandBgString()
{
Bitmap b = new Bitmap(bgWidth, bgHeight);
String[] randStr = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" };
//设置透明
b.MakeTransparent();
Graphics g = Graphics.FromImage(b);
g.Clear(Color.Transparent);
g.PixelOffsetMode = PixelOffsetMode.HighQuality;
g.SmoothingMode = SmoothingMode.HighQuality;
g.TextRenderingHint = TextRenderingHint.AntiAlias;
g.InterpolationMode = InterpolationMode.HighQualityBilinear;
//设置字体显示格式
StringFormat format = new StringFormat(StringFormatFlags.NoClip);
format.Alignment = StringAlignment.Center;
format.LineAlignment = StringAlignment.Center;
FontFamily f = new FontFamily(GenericFontFamilies.Serif);
Font textFont = new Font(f, randomStringFontSize, FontStyle.Underline);
int randAngle = ; //随机转动角度
for (int i = ; i < RandomStringCount; i++)
{
Brush brush = new System.Drawing.SolidBrush(GetRandomLightColor());
Point pot = new Point(random.Next(, bgWidth - ), random.Next(, bgHeight - ));
//随机转动的度数
float angle = random.Next(-randAngle, randAngle);
//转动画布
g.RotateTransform(angle);
g.DrawString(randStr[random.Next(randStr.Length)], textFont, brush, pot, format);
//转回去，为下一个字符做准备
g.RotateTransform(-angle);
//释放资源
brush.Dispose();
}
textFont.Dispose();
format.Dispose();
f.Dispose();
return b;
}
#endregion #region 随机生成贝塞尔曲线
/// <summary>
/// 随机生成贝塞尔曲线
/// </summary>
/// <param name="bmp">一个图片的实例</param>
/// <param name="lineNum">线条数量</param>
/// <returns></returns>
public Bitmap DrawRandomBezier(Int32 lineNum)
{
Bitmap b = new Bitmap(bgWidth, bgHeight);
b.MakeTransparent();
Graphics g = Graphics.FromImage(b);
g.Clear(Color.Transparent);
g.SmoothingMode = SmoothingMode.HighQuality;
g.PixelOffsetMode = PixelOffsetMode.HighQuality;
GraphicsPath gPath1 = new GraphicsPath();
Int32 lineRandNum = random.Next(lineNum);
for (int i = ; i < (lineNum - lineRandNum); i++)
{
Pen p = new Pen(GetRandomDeepColor());
Point[] point = {
new Point(random.Next(, (b.Width / )), random.Next(, (b.Height))),
new Point(random.Next((b.Width / ) * , (b.Width / ) * ), random.Next(, (b.Height))),
new Point(random.Next((b.Width / ) * , (b.Width / ) * ), random.Next(, (b.Height))),
new Point(random.Next((b.Width / ) * , b.Width), random.Next(, (b.Height)))
};
gPath1.AddBeziers(point);
g.DrawPath(p, gPath1);
p.Dispose();
}
for (int i = ; i < lineRandNum; i++)
{
Pen p = new Pen(GetRandomDeepColor());
Point[] point = {
new Point(random.Next(, b.Width), random.Next(, b.Height)),
new Point(random.Next((b.Width / ) * , b.Width), random.Next(, b.Height)),
new Point(random.Next((b.Width / ) * , b.Width), random.Next(, b.Height)),
new Point(random.Next(, b.Width), random.Next(, b.Height))
};
gPath1.AddBeziers(point);
g.DrawPath(p, gPath1);
p.Dispose();
}
return b;
}
#endregion #region 画直线
/// <summary>
/// 画直线
/// </summary>
/// <param name="bmp">一个bmp实例</param>
/// <param name="lineNum">线条个数</param>
/// <returns></returns>
public Bitmap DrawRandomLine(Int32 lineNum)
{
if (lineNum < ) throw new ArgumentNullException("参数bmp为空！");
Bitmap b = new Bitmap(bgWidth, bgHeight);
b.MakeTransparent();
Graphics g = Graphics.FromImage(b);
g.Clear(Color.Transparent);
g.PixelOffsetMode = PixelOffsetMode.HighQuality;
g.SmoothingMode = SmoothingMode.HighQuality;
for (int i = ; i < lineNum; i++)
{
Pen p = new Pen(GetRandomDeepColor());
Point pt1 = new Point(random.Next(, (b.Width / ) * ), random.Next(b.Height));
Point pt2 = new Point(random.Next((b.Width / ) * , b.Width), random.Next(b.Height));
g.DrawLine(p, pt1, pt2);
p.Dispose();
}
return b;
}
#endregion #region 写入验证码的字符串
/// <summary>
/// 写入验证码的字符串
/// </summary>
private Bitmap DrawRandomString(string Code)
{
if (fontMaxSize >= (bgHeight / ) * )
throw new ArgumentException("字体最大值参数FontMaxSize与验证码高度相近，这会导致描绘验证码字符串时出错，请重新设置参数！");
Bitmap b = new Bitmap(bgWidth, bgHeight);
b.MakeTransparent();
Graphics g = Graphics.FromImage(b);
g.Clear(Color.Transparent);
g.PixelOffsetMode = PixelOffsetMode.Half;
g.SmoothingMode = SmoothingMode.HighQuality;
g.TextRenderingHint = TextRenderingHint.SingleBitPerPixelGridFit;
g.InterpolationMode = InterpolationMode.HighQualityBilinear;
chars = Code.ToCharArray(); //拆散字符串成单字符数组
validationCode = chars.ToString();
//设置字体显示格式
StringFormat format = new StringFormat(StringFormatFlags.NoClip);
format.Alignment = StringAlignment.Center;
format.LineAlignment = StringAlignment.Center;
FontFamily f = new FontFamily(GenericFontFamilies.Monospace);
Int32 charNum = chars.Length;
Point sPoint = new Point();
Int32 fontSize = ;
validationCodeCount = charNum;
for (int i = ; i < validationCodeCount; i++)
{
//定义字体
Font textFont = new Font(f, random.Next(fontMinSize, fontMaxSize), FontStyle.Bold);
//定义画刷，用于写字符串
//Brush brush = new SolidBrush(GetRandomDeepColor());
Int32 textFontSize = Convert.ToInt32(textFont.Size);
fontSize = textFontSize;
//Point point = new Point(random.Next((bgWidth / charNum) * i + 5, (bgWidth / charNum) * (i + 1)), random.Next(bgHeight / 5 + textFontSize / 2, bgHeight - textFontSize / 2));
// 字符位置坐标
Point point = new Point(random.Next((bgWidth / charNum) * i + , (bgWidth / charNum) * (i + ) - (textFontSize / )), random.Next(bgHeight / + textFontSize / , bgHeight - textFontSize / ));
//如果当前字符X坐标小于字体的二分之一大小
if (point.X < textFontSize / )
{
point.X = point.X + textFontSize / ;
}
//防止文字叠加
if (i > && (point.X - sPoint.X < (textFontSize / + textFontSize / )))
{
point.X = point.X + textFontSize;
}
//如果当前字符X坐标大于图片宽度，就减去字体的宽度
if (point.X > (bgWidth - textFontSize / ))
{
point.X = bgWidth - textFontSize / ;
}
sPoint = point;
float angle = random.Next(-rotationAngle, rotationAngle);//转动的度数
g.TranslateTransform(point.X, point.Y);
g.RotateTransform(angle); Rectangle myretang = new Rectangle(, , Convert.ToInt32(textFont.Size), Convert.ToInt32(textFont.Size));
Color c = GetRandomDeepColor();
//设置渐变画刷
LinearGradientBrush mybrush2 = new LinearGradientBrush(myretang, c, GetLightColor(c, ), random.Next());
g.DrawString(chars[i].ToString(), textFont, mybrush2, , , format); g.RotateTransform(-angle);//转回去
g.TranslateTransform(-point.X, -point.Y);//移动光标到指定位置，每个字符紧凑显示，避免被软件识别
strPoint[i] = point;
textFont.Dispose();
mybrush2.Dispose();
}
return b;
}
#endregion #region 增加或減少亮度
/// <summary>
/// 增加或減少亮度
/// </summary>
/// <param name="img">System.Drawing.Image Source </param>
/// <param name="valBrightness">0~255</param>
/// <returns></returns>
public System.Drawing.Bitmap AdjustBrightness(System.Drawing.Image img, int valBrightness)
{
// 讀入欲轉換的圖片並轉成為 Bitmap
System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap(img);
for (int y = ; y < bitmap.Height; y++)
{
for (int x = ; x < bitmap.Width; x++)
{
// 取得每一個 pixel
var pixel = bitmap.GetPixel(x, y);
// 判斷 如果處理過後 255 就設定為 255 如果小於則設定為 0
var pR = ((pixel.R + valBrightness > ) ? : pixel.R + valBrightness) < ? : ((pixel.R + valBrightness > ) ? : pixel.R + valBrightness);
var pG = ((pixel.G + valBrightness > ) ? : pixel.G + valBrightness) < ? : ((pixel.G + valBrightness > ) ? : pixel.G + valBrightness);
var pB = ((pixel.B + valBrightness > ) ? : pixel.B + valBrightness) < ? : ((pixel.B + valBrightness > ) ? : pixel.B + valBrightness);
// 將改過的 RGB 寫回
System.Drawing.Color newColor = System.Drawing.Color.FromArgb(pixel.A, pR, pG, pB);
bitmap.SetPixel(x, y, newColor);
}
}
// 回傳結果
return bitmap;
}
#endregion #region 水波纹效果
/// <summary>
/// 水波纹效果
/// </summary>
/// <param name="src"></param>
/// <param name="nWave">坡度</param>
/// www.it165.net
/// <returns></returns>
public Bitmap AdjustRippleEffect(Bitmap src, short nWave)
{
int nWidth = src.Width;
int nHeight = src.Height;
// 透过公式进行水波纹的採样
PointF[,] fp = new PointF[nWidth, nHeight];
Point[,] pt = new Point[nWidth, nHeight];
Point mid = new Point();
mid.X = nWidth / ;
mid.Y = nHeight / ;
double newX, newY;
double xo, yo;
//先取样将水波纹座标跟RGB取出
for (int x = ; x < nWidth; ++x)
for (int y = ; y < nHeight; ++y)
{
xo = ((double)nWave * Math.Sin(2.0 * 3.1415 * (float)y / 128.0));
yo = ((double)nWave * Math.Cos(2.0 * 3.1415 * (float)x / 128.0));
newX = (x + xo);
newY = (y + yo);
if (newX > && newX < nWidth)
{
fp[x, y].X = (float)newX;
pt[x, y].X = (int)newX;
}
else
{
fp[x, y].X = (float)0.0;
pt[x, y].X = ;
}
if (newY > && newY < nHeight)
{
fp[x, y].Y = (float)newY;
pt[x, y].Y = (int)newY;
}
else
{
fp[x, y].Y = (float)0.0;
pt[x, y].Y = ;
}
}
//进行合成
Bitmap bSrc = (Bitmap)src.Clone();
// 依照 Format24bppRgb 每三个表示一 Pixel 0: 蓝 1: 绿 2: 红
BitmapData bitmapData = src.LockBits(new Rectangle(, , src.Width, src.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
BitmapData bmSrc = bSrc.LockBits(new Rectangle(, , bSrc.Width, bSrc.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
int scanline = bitmapData.Stride;
IntPtr Scan0 = bitmapData.Scan0;
IntPtr SrcScan0 = bmSrc.Scan0;
//指针在c#中是不提倡使用的，有关指针的操作被认为是不安全的(unsafe)。因此运行这段代码之前，先要改一个地方，否则编译不过无法运行。
//修改方法：找到你的项目，在项目图标上点右键，选项目属性（Properties）,Build标签页里把Allow unsafe code勾选上
unsafe
{
//指针
byte* p = (byte*)(void*)Scan0;
byte* pSrc = (byte*)(void*)SrcScan0;
int nOffset = bitmapData.Stride - src.Width * ;
int xOffset, yOffset;
for (int y = ; y < nHeight; ++y)
{
for (int x = ; x < nWidth; ++x)
{
xOffset = pt[x, y].X;
yOffset = pt[x, y].Y;
if (yOffset >= && yOffset < nHeight && xOffset >= && xOffset < nWidth)
{
p[] = pSrc[(yOffset * scanline) + (xOffset * )];
p[] = pSrc[(yOffset * scanline) + (xOffset * ) + ];
p[] = pSrc[(yOffset * scanline) + (xOffset * ) + ];
}
p += ;
}
p += nOffset;
}
}
src.UnlockBits(bitmapData);
bSrc.UnlockBits(bmSrc);
return src;
}
#endregion #region 生成随机字符串
/// <summary>
/// 生成随机字符串
/// </summary>
/// <returns></returns>
public string GetRandomString(Int32 textLength)
{
string[] randomArray = charCollection.Split(','); //将字符串生成数组
int arrayLength = randomArray.Length;
string randomString = "";
for (int i = ; i < textLength; i++)
{
randomString += randomArray[random.Next(, arrayLength)];
}
return randomString; //长度是textLength +1
}
#endregion #region 随机生成颜色值
/// <summary>
/// 生成随机深颜色
/// </summary>
/// <returns></returns>
public Color GetRandomDeepColor()
{
int nRed, nGreen, nBlue;
// nBlue,nRed nGreen 相差大一点 nGreen 小一些
//int high = 255;
int redLow = ;
int greenLow = ;
int blueLow = ;
nRed = random.Next(redLow);
nGreen = random.Next(greenLow);
nBlue = random.Next(blueLow);
Color color = Color.FromArgb(nRed, nGreen, nBlue);
return color;
}
/// <summary>
/// 生成随机浅颜色
/// </summary>
/// <returns>randomColor</returns>
public Color GetRandomLightColor()
{
int nRed, nGreen, nBlue;
//越大颜色越浅
int low = ; //色彩的下限
int high = ; //色彩的上限
nRed = random.Next(high) % (high - low) + low;
nGreen = random.Next(high) % (high - low) + low;
nBlue = random.Next(high) % (high - low) + low;
Color color = Color.FromArgb(nRed, nGreen, nBlue);
return color;
}
/// <summary>
/// 获取与当前颜色值相加后的颜色
/// </summary>
/// <param name="c"></param>
/// <returns></returns>
public Color GetLightColor(Color c, Int32 value)
{
int nRed = c.R, nGreen = c.G, nBlue = c.B;
//越大颜色越浅
if (nRed + value < && nRed + value > )
{
nRed = c.R + ;
}
if (nGreen + value < && nGreen + value > )
{
nGreen = c.G + ;
}
if (nBlue + value < && nBlue + value > )
{
nBlue = c.B + ;
}
Color color = Color.FromArgb(nRed, nGreen, nBlue);
return color;
}
#endregion #region 绘制圆角矩形
/// <summary>
/// C# GDI+ 绘制圆角矩形
/// </summary>
/// <param name="g">Graphics 对象</param>
/// <param name="rectangle">Rectangle 对象，圆角矩形区域</param>
/// <param name="borderColor">边框颜色</param>
/// <param name="borderWidth">边框宽度</param>
/// <param name="r">圆角半径</param>
private static void DrawRoundRectangle(Graphics g, Rectangle rectangle, Color borderColor, float borderWidth, int r)
{
// 如要使边缘平滑，请取消下行的注释
g.SmoothingMode = SmoothingMode.HighQuality;
Pen p = new Pen(borderColor, borderWidth);
// 调用 getRoundRectangle 得到圆角矩形的路径，然后再进行绘制
g.DrawPath(p, getRoundRectangle(rectangle, r));
}
#endregion #region 根据普通矩形得到圆角矩形的路径
/// <summary>
/// 根据普通矩形得到圆角矩形的路径
/// </summary>
/// <param name="rectangle">原始矩形</param>
/// <param name="r">半径</param>
/// <returns>图形路径</returns>
private static GraphicsPath getRoundRectangle(Rectangle rectangle, int r)
{
int l = * r;
// 把圆角矩形分成八段直线、弧的组合，依次加到路径中
GraphicsPath gp = new GraphicsPath();
gp.AddLine(new Point(rectangle.X + r, rectangle.Y), new Point(rectangle.Right - r, rectangle.Y));
gp.AddArc(new Rectangle(rectangle.Right - l, rectangle.Y, l, l), 270F, 90F);
gp.AddLine(new Point(rectangle.Right, rectangle.Y + r), new Point(rectangle.Right, rectangle.Bottom - r));
gp.AddArc(new Rectangle(rectangle.Right - l, rectangle.Bottom - l, l, l), 0F, 90F);
gp.AddLine(new Point(rectangle.Right - r, rectangle.Bottom), new Point(rectangle.X + r, rectangle.Bottom));
gp.AddArc(new Rectangle(rectangle.X, rectangle.Bottom - l, l, l), 90F, 90F);
gp.AddLine(new Point(rectangle.X, rectangle.Bottom - r), new Point(rectangle.X, rectangle.Y + r));
gp.AddArc(new Rectangle(rectangle.X, rectangle.Y, l, l), 180F, 90F);
return gp;
}
#endregion
}
调用
private void frmValidateCode_Load(object sender, EventArgs e)
{
ValidateCode vCode = new ValidateCode();
string code = vCode.GetRandomString();
MemoryStream stream = vCode.CreateImage(code);
pictureBox1.Image = new Bitmap(stream);
}
效果