4、C#进阶：MD5加密、进程、线程、GDI+、XML、委托

MD5加密

将字符串进行加密，无法解密。网上的解密方式也都是在库里找，找不到也没有。

protected void Page_Load(object sender, EventArgs e)
{
string s = "123";
Response.Write(getMd5(s));
}
public string getMd5(string str)
{
MD5 md5 = MD5.Create();//MD5抽象类无法实例化 实例化该方法
byte[] buffer = Encoding.Default.GetBytes(str); //将字符串转换为字节数组
byte[] mdbuffer = md5.ComputeHash(buffer); //调用ComputeHash方法把数组传进去
//将字节数组中每个元素ToString();
StringBuilder result = new StringBuilder();
for (int i = 0; i < mdbuffer.Length; i++)
{
result.Append(mdbuffer[i].ToString("x2")); //ToString得到十进制字符串 ToString("x")十六进制字符串 ToString("x2")对齐
}
return result.ToString();
}

进制

表示某一位置上的数运算时是逢X进一位。二进制就是逢二进一， 十进制是逢十进一，十六进制是逢十六进一，以此类推.

so：二进制001010101只有0和1计算机中的数据都是二进制表示，四进制以0、1、2、3四个数字表示任何实数。十进制0~9数字组成，十六进制0~9以及ABCEDF组成（表示十进制数）10~15

ToString的特殊方法

时间：now.ToString("yyyy-MM-dd hh:mm:ss") 年-月-日 时：分：秒 具体可以自定单独写f y m d t 意义不同前者都可实现

字符型转换：int.ToString("n"); 640,000.00; int.ToString("C"); ￥640,000.00; .ToString("x");16进制

Directory类

用来操作文件夹的

Directory.CreateDirectory("d:/ccc/cc"); //创建文件夹

Directory.Delete("d:/ccc",true); //true删除非空文件夹

Directory.Move(@"d:/ccc", @"d:/cccc"); //剪切操作 源目录没了 必须同一卷轴d盘

string[] s = Directory.GetFiles(@"D:\项目\Web\Images\shiji"); //获得文件夹目录下所有文件全路径

string[] s = Directory.GetFiles(@"D:\项目\Web\Images\shiji","*.jpg"); //获得文件夹目录下指定后缀名文件全路径

string[] s = Directory.GetDirectories(@"D:\项目\Web\Images"); //获得文件夹目录下的文件夹的全路径

Directory.Exists(@"D:\项目\Web\Images") //是否存在某文件夹

进程

我们可以把计算机中每一个运行的应用程序当作是一个进程

///获得当前程序中正在运行的进程
Process[] pros = Process.GetProcesses();
foreach (var item in pros)
{
　　　　//item.Kill(); //关闭所有进程.
　　　　//item.ProcessName; //进程名
Console.Write(item.ToString());
}
//通过进程打开一些程序
Process.Start("calc"); //打开计算器
Process.Start("notepad"); //打开记事本
//打开指定文件
ProcessStartInfo pro = new ProcessStartInfo(@"d:\11.txt");
Process pr = new Process();
pr.StartInfo = pro;
pr.Start();

线程

每一个进程是由多个线程组成的。

单线程：让程序做多件事时，会引发卡死 假死状态。

多线程：让一个程序同时处理多个事情，后台运行程序，提高程序的运行效率。

前台线程：只有所有的前台线程都关闭才能完成程序关闭。(winform多窗口时)

后台线程：只要所有的前台线程结束，后台线程自动结束。

//实例化Thread类，并传入一个指向线程所要运行的方法。（这时线程已经产生，但还没有运行）
//调用Thread类的Start方法，标记线程可以被CPU执行了，但具体执行事件由CPU决定。
Thread th = new Thread(Test); //创建一个线程去执行这个方法。
th.IsBackground = true; //将线程设置为后台线程，前台关闭后 线程结束。
th.Start(); //标记准备就绪，可以随意被执行，具体什么时候执行由CPU决定。
//在.net下是不允许跨线程访问的。
//有时候需要手动释放线程 关闭时 判断线程是否关闭
if (th != null)
{
th.Abort(); //结束这个线程 不能再Start()
}
Thread.Sleep(3000); //睡眠3秒后执行
//线程执行带参数方法
Thread.Start("123")； object类型参数 在start后括号写参数

多用于大量数据时，多分一个线程去搜索数据，然后存储到缓存里，页面再用异步获取缓存中的数据。

GDI+

是一种绘图装置接口，可以用来绘制图片。

画直线

Graphics g = this.CreateGraphics(); //创建GDI对象
Pen pen = new Pen(Brushes.Yellow); //创建画笔
Point p1 = new Point(30, 50); //创建两个点
Point p2 = new Point(250, 250);
g.DrawLine(pen, p1, p2);

画验证码

/// <summary>
/// 字符
/// </summary>
/// <param name="len">几位</param>
/// <returns></returns>
public static string validation(int cd)
{
var ran = new Random();
int num, tem;
string rtuStr = "";
for (int i = 0; i < cd; i++)
{
num = ran.Next();
if (i % 2 == 1)
tem = num % 10 + '0'; //数字
else
tem = num % 26 + 'A'; //字母
rtuStr += Convert.ToChar(tem).ToString();
}
//写入cookie
HttpCookie cookie = new HttpCookie("check");
cookie.Value = rtuStr.ToLower();
HttpContext.Current.Response.Cookies.Add(cookie);
return rtuStr;
}

/// <summary>
/// 生成图像
/// </summary>
/// <param name="check">字符</param>
public static byte[] drawImg(string check)
{
Bitmap img = new Bitmap(90, 34);
var ht = Graphics.FromImage(img);
ht.Clear(Color.White);
ht.DrawLine(new Pen(Color.SpringGreen), 1, 1, 90, 34);
Font font = new Font("微软雅黑", 20, FontStyle.Bold);
var jianbian = new LinearGradientBrush(new Rectangle(0, 0, img.Width, img.Height), Color.Teal, Color.Snow, 2f, true);
ht.DrawString(check, font, jianbian, 0, 0);
ht.DrawRectangle(new Pen(Color.Aqua), 0, 0, img.Width - 1, img.Height - 1);
MemoryStream ms = new MemoryStream();
img.Save(ms, ImageFormat.Jpeg);
ht.Dispose();
img.Dispose();
return ms.ToArray();
}

mvc中调用

public ActionResult ShowValidate()
{
var check = Common.Validate.validation(4);
byte[] buffer = Common.Validate.drawImg(check);
return File(buffer, "image/jpeg");
}

前台

<img src="/Login/ShowValidate" id="img" onclick="changeCode()" class="validateImg">

if (validateCode.toLowerCase() == getCode()) {
return true;
}

function changeCode() {
$("#img").attr("src", $("#img").attr("src") + "?");
}

function getCode() {
var cookies = document.cookie.split(";");
for (var i = 0; i < cookies.length; i++) {
var validate = cookies[i].split("=");
if (validate[0].replace(/(^\s*)|(\s*$)/g, "") == "check") {
return validate[1].replace(/(^\s*)|(\s*$)/g,"");
}
}
}

XML文件

可扩展标记性语言，用来保存轻量级数据。

XML的标签是成对出现的、并且是区分大小写的。

XML文档必须包含根节点，且只有一个。

创建XML文件

//创建XML对象
XmlDocument doc = new XmlDocument();
//创建文档描述信息
XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "utf-8", null);
doc.AppendChild(dec);

//创建根节点
XmlElement books = doc.CreateElement("Books");
doc.AppendChild(books);

//创建子节点
XmlElement book1 = doc.CreateElement("Book");
books.AppendChild(book1); //将子节点添加到books

//给book1子节点追加子节点
XmlElement name1 = doc.CreateElement("Name");
name1.InnerText = "c#"; //赋值 文本值
book1.AppendChild(name1);

XmlElement price1 = doc.CreateElement("Price");
price1.InnerXml = "<b>10.0</b>"; //赋值 html标签
book1.AppendChild(price1);

XmlElement items = doc.CreateElement("Items");
//给节点增加属性
items.SetAttribute("Name", "c#");
items.SetAttribute("Price", "10.0");
book1.AppendChild(items);

doc.Save("Books.xml"); //保存

//创建后
<?xml version="1.0" encoding="utf-8"?>
<Books>
<Book>
<Name>c#</Name>
<Price>
<b>10.0</b>
</Price>
<Items Name="c#" Price="10.0" />
</Book>
</Books>

向已有XML文件中追加

XmlDocument doc = new XmlDocument();
if (File.Exists("Books.xml"))
{
doc.Load("Books.xml"); //加载 xml
XmlElement books = doc.DocumentElement; //得到根节点
//再建立元素进行追加
}

获取XML文件

XmlDocument doc = new XmlDocument();
doc.Load("Books.xml");

XmlElement books = doc.DocumentElement;
XmlNodeList xnl = books.ChildNodes; //得到所有节点

foreach (XmlNode v in xnl) //遍历得到所有节点值
{
Console.WriteLine(v.InnerText);
}

XmlNodeList xnl1 = doc.SelectNodes("Books/Book/Items"); //查找节点列表
foreach (XmlNode node in xnl1)
{
Console.WriteLine(node.Attributes["Name"].Value); //得到name属性的值
Console.WriteLine(node.Attributes["Price"].Value); //得到price属性的值
}

删除XML文件

XmlDocument doc = new XmlDocument();
doc.Load("Books.xml");

XmlNode xnl = doc.SelectSingleNode("Books/Book"); //查找单一节点
xnl.RemoveAll(); //删除全部
doc.Save("Books.xml");
Console.ReadKey();

LinqToXml

//兼容传统方法创建
XDocument xDoc = new XDocument();
//xDoc.Declaration = new XDeclaration() 默认UTF-8 第一行不需要单独建
XElement xRoot = new XElement("root", "值"); //定义元素

XElement xRoot1 = new XElement("root1");  //定义元素２
xRoot1.Value = "值1";

XAttribute xattr = new XAttribute("Id", "1"); //定义属性

xDoc.Add(xRoot); //统一使用add添加
xRoot.Add(xattr);

xDoc.Save(@"d:\linqtoxml.xml");

//真正的linq语法
//F#  函数式编程语言
new XDocument(
new XElement("root",
new XAttribute("id", "001"),
"值")
).Save(@"d:\2.xml");
//链式编程，流水线生产 f1().f2().f3()...

//查找xml
XDocument xdoc = new XDocument(new XElement("root"));//根节点
xdoc.Root.Add(new XElement("person",
new XAttribute("id", "1"),
new XAttribute("name", "zhangsan"),
new XAttribute("sex", "1")
)); //添加子节点
xdoc.Root.Add(new XElement("person",
new XAttribute("id", "2"),
new XAttribute("name", "lisi"),
new XAttribute("sex", "2")
));
xdoc.Save(@"d:\2.xml");

<?xml version="1.0" encoding="utf-8"?>
<root>
<person id="1" name="zhangsan" sex="1" />
<person id="2" name="lisi" sex="2" />
</root>

//开始查找、修改、删除

XDocument xdoc = XDocument.Load(@"d:\2.xml"); //加载xml
foreach (XElement xlt in xdoc.Root.Elements()) //Root根节点 Elements 元素集合
{
if (xlt.Name.LocalName == "person") //Name节点名 LocalName不带命名空间的节点名
{
if (xlt.Attribute("id").Value == "1") //判断属性值为1时
{
Response.Write(xlt.Attribute("name").Value); //输出name
xlt.Attribute("name").Value = "newname"; //修改name
xlt.Remove(); //删除此节点
xdoc.Save(@"d:2.xml");
}
}
}

//Linq查询语法
//Descendants()所有子节点 可加某节点下所有节点
var query = from s in xdoc.Descendants() //从集合里找
where s.Name.LocalName == "person"
select s;
foreach (XElement xlt in query)
{
Response.Write(xlt.Value);
}

//Linq方法语法(lambda表达式)
foreach (XElement xlt in xdoc.Descendants().Where(s =>
{
if (s.Name.LocalName == "name")
{
return true;
}
return false;
}))
{
Response.Write(xlt.Value);
}

委托
使用delegate定义委托，将一个方法作为参数传给另一个方法。
委托所指向的函数必须返回值与参数相同

/// <summary>
/// 委托语法
/// </summary>
class Program
{
public delegate void delSayhi(string name); //定义委托
static void Main(string[] args)
{
delSayhi del = new delSayhi(sayHiChinese); //实例化委托调用具体方法
del("san"); //执行

delSayhi del1 = sayHiChinese; //直接赋值方式
del1("si");

//匿名函数
delSayhi del2 = delegate(string name) { Console.WriteLine(name + "，思密达"); };
del2("韩国");

//lambda表达式  ()没参数也要写 => { //方法体 } 没参数可以e=> Console.WriteLine(""); 如果只有一句话不用{} 返回的return可以省略
delSayhi del3 = (string name) => { Console.WriteLine(name + "，萨瓦迪卡"); };
del2("泰国");

sayHi("david", sayHiEnglish); //调用自定义方法 参数要调用的方法
Console.ReadKey();
}

public static void sayHi(string name, delSayhi del) //定义方法 类型委托
{
del(name);
}

public static void sayHiChinese(string name)
{
Console.WriteLine("你好， 我叫" + name);
}
public static void sayHiEnglish(string name)
{
Console.WriteLine("hello, my name is {0}, nice to meet you!", name);
}
}

/// <summary>
/// 求任意数组最大值
/// </summary>
class Program
{
public delegate int delCompre(object o1, object o2); //定义比较委托
static void Main(string[] args)
{
//比较int
object[] objs = new object[] { 1, 2, 3, 4, 5, 32, 1, 243, };
var max = getMax(objs, getIntMax); //传入比较int方法
Console.WriteLine(max);

var max2 = getMax(objs, delegate(object o1, object o2)
{
return int.Parse(o1.ToString()) - int.Parse(o2.ToString());
}); //匿名函数 与比较int一样
Console.WriteLine(max2);

//比较string
object[] strs = new object[] { "abc", "efd", "asdf", "sd", "asdff" };
var maxstrs = getMax(strs, delegate(object o1, object o2)
{
return o1.ToString().Length - o2.ToString().Length;
}); //匿名函数
Console.WriteLine(maxstrs);

var maxstrs2 = getMax(strs, (object o1, object o2) =>
{
return o1.ToString().Length - o2.ToString().Length;
}); //lambda 表达式
Console.WriteLine(maxstrs2);

Console.ReadKey();
}

public static int getIntMax(object o1, object o2) //比较int方法
{
int n1 = int.Parse(o1.ToString());
int n2 = int.Parse(o2.ToString());
return n1 - n2;
}
/// <summary>
/// 取一个任意数组的最大值
/// </summary>
/// <param name="objs">数组</param>
/// <param name="del">委托</param>
/// <returns></returns>
public static object getMax(object[] objs, delCompre del)
{
object max = objs[0];
for (int i = 0; i < objs.Length; i++)
{
//if (max < objs[i]) object 无法确定是什么类型 所以不能用<
if (del(max, objs[i]) < 0) //如果委托值小于0 成立 传入如何比较即可
{
max = objs[i];
}
}
return max;
}
}

/// <summary>
/// 泛型<T>委托
/// </summary>
class Program
{
public delegate int delCompre<T>(T t1, T t2); //定义泛型委托
static void Main(string[] args)
{
//int
int[] nums = { 1, 2, 3, 4, 5 };
int max = getMax<int>(nums, (int t1, int t2) => { return t1 - t2; });
Console.WriteLine(max);

//string
string[] strs = { "asd", "sdf", "zxcvv", "123", "qwe" };
string maxStr = getMax(strs, (string s1, string s2) => { return s1.Length - s2.Length; });
Console.WriteLine(maxStr);

Console.ReadKey();
}

public static T getMax<T>(T[] objs, delCompre<T> del)
{
T max = objs[0];
for (int i = 0; i < objs.Length; i++)
{
if (del(max, objs[i]) < 0)
{
max = objs[i];
}
}
return max;
}
}

多播委托
注册多个方法，调用时将这些方法依次执行一遍。

public delegate void my1();

my1 my = Fun1();
my+= Fun2(); //+=实现多播委托

public static void Fun1(){
}
public static void Fun2(){
}