一. IO读写
这里主要包括文件的读、写、移动、复制、删除、文件夹的创建、文件夹的删除等常规操作。
注意：这里需要特别注意，对于普通的控制台程序和Web程序，将"相对路径"转换成"绝对路径"的方法不一致。
(1). 在web程序中,可以使用HttpContext.Current.Server.MapPath进行转换，使用方法通过 ~/定位到一级目录，eg：FileOperateHelp.Write_Txt("~/TestFile/mr.txt", "mr")。
(2). 在普通的控制台程序中，HttpContext.Current为空，所以web中的转换方式在控制台中失效，需要借助 "AppDomain.CurrentDomain.BaseDirectory"来获取根目录，该目录直接定位到Debug文件夹，然后利用System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, strPath)传入路径与根目录进行结合，所以普通的控制台程序生成的所有文件均在Debug文件夹下，当然，你也可以直接写绝对路径，比如D:xxx。
下面的方法就是专门处理普通程序和web程序路径转换问题的。
/// <summary>
/// 10.将相对路径转换成绝对路径
/// </summary>
/// <param name="strPath">相对路径</param>
public static string PathConvert(string strPath)
{
//web程序使用
if (HttpContext.Current != null)
{
return HttpContext.Current.Server.MapPath(strPath);
}
else //非web程序引用
{
strPath = strPath.Replace("/", "\\");
if (strPath.StartsWith("\\"))
{
strPath = strPath.TrimStart('\\');
}
return System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, strPath);
}
}
下面分享一个FileOperateHelp类，里面包含IO的常规操作。
/// <summary>
/// 文件操作类
/// 特别注意：
/// 1.在非web程序中,HttpContext.Current.Server.MapPath失效不好用,需要使用System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, strPath);
/// 获取本目录,然后写到根目录里。AppDomain.CurrentDomain.BaseDirectory将获取到Debug文件夹，无法使用相对路径
/// 2.在web程序里,可以使用HttpContext.Current.Server.MapPath进行转换，使用方法通过 ~/定位到一级目录，eg：FileOperateHelp.Write_Txt("~/TestFile/mr.txt", "mr");
/// </summary>
public static class FileOperateHelp
{ #region 01.写文件(.txt-覆盖)
/// <summary>
/// 写文件(覆盖源文件内容)
/// 文件不存在的话自动创建
/// </summary>
/// <param name="FileName">文件路径(web里相对路径,控制台在根目录下写)</param>
/// <param name="Content">文件内容</param>
public static string Write_Txt(string FileName, string Content)
{
try
{
Encoding code = Encoding.GetEncoding("gb2312");
string htmlfilename = FileOperateHelp.PathConvert(FileName);
//string htmlfilename = HttpContext.Current.Server.MapPath(FileName + ".txt"); //保存文件的路径
string str = Content;
StreamWriter sw = null;
{
try
{
sw = new StreamWriter(htmlfilename, false, code);
sw.Write(str);
sw.Flush();
}
catch { }
}
sw.Close();
sw.Dispose();
return "ok";
}
catch (Exception ex)
{ return ex.Message;
} }
#endregion #region 02.读文件(.txt)
/// <summary>
/// 读文件
/// </summary>
/// <param name="filename">文件路径(web里相对路径,控制台在根目录下写)</param>
/// <returns></returns>
public static string Read_Txt(string filename)
{ try
{
Encoding code = Encoding.GetEncoding("gb2312");
string temp = FileOperateHelp.PathConvert(filename);
// string temp = HttpContext.Current.Server.MapPath(filename + ".txt");
string str = "";
if (File.Exists(temp))
{
StreamReader sr = null;
try
{
sr = new StreamReader(temp, code);
str = sr.ReadToEnd(); // 读取文件
}
catch { }
sr.Close();
sr.Dispose();
}
else
{
str = "";
}
return str;
}
catch (Exception ex)
{ return ex.Message;
}
}
#endregion #region 03.写文件（.txt-添加）
/// <summary>
/// 写文件
/// </summary>
/// <param name="FileName">文件路径(web里相对路径,控制台在根目录下写)</param>
/// <param name="Strings">文件内容</param>
public static string WriteFile(string FileName, string Strings)
{
try
{
string Path = FileOperateHelp.PathConvert(FileName); if (!System.IO.File.Exists(Path))
{
System.IO.FileStream f = System.IO.File.Create(Path);
f.Close();
f.Dispose();
}
System.IO.StreamWriter f2 = new System.IO.StreamWriter(Path, true, System.Text.Encoding.UTF8);
f2.WriteLine(Strings);
f2.Close();
f2.Dispose();
return "ok";
}
catch (Exception ex)
{ return ex.Message;
}
}
#endregion #region 04.读文件（.txt）
/// <summary>
/// 读文件
/// </summary>
/// <param name="FileName">文件路径(web里相对路径,控制台在根目录下写)</param>
/// <returns></returns>
public static string ReadFile(string FileName)
{
try
{
string Path = FileOperateHelp.PathConvert(FileName);
string s = "";
if (!System.IO.File.Exists(Path))
s = "不存在相应的目录";
else
{
StreamReader f2 = new StreamReader(Path, System.Text.Encoding.GetEncoding("gb2312"));
s = f2.ReadToEnd();
f2.Close();
f2.Dispose();
}
return s;
}
catch (Exception ex)
{
return ex.Message;
}
}
#endregion #region 05.删除文件
/// <summary>
/// 删除文件
/// </summary>
/// <param name="Path">文件路径(web里相对路径,控制台在根目录下写)</param>
public static string FileDel(string Path)
{
try
{
string temp = FileOperateHelp.PathConvert(Path);
File.Delete(temp);
return "ok";
}
catch (Exception ex)
{
return ex.Message;
}
}
#endregion #region 06.移动文件
/// <summary>
/// 移动文件
/// </summary>
/// <param name="OrignFile">原始路径(web里相对路径,控制台在根目录下写)</param>
/// <param name="NewFile">新路径,需要写上路径下的文件名，不能单写路径(web里相对路径,控制台在根目录下写)</param>
public static string FileMove(string OrignFile, string NewFile)
{
try
{
OrignFile = FileOperateHelp.PathConvert(OrignFile);
NewFile = FileOperateHelp.PathConvert(NewFile);
File.Move(OrignFile, NewFile);
return "ok";
}
catch (Exception ex)
{
return ex.Message;
}
}
#endregion #region 07.复制文件
/// <summary>
/// 复制文件
/// </summary>
/// <param name="OrignFile">原始文件(web里相对路径,控制台在根目录下写)</param>
/// <param name="NewFile">新文件路径(web里相对路径,控制台在根目录下写)</param>
public static string FileCopy(string OrignFile, string NewFile)
{
try
{
OrignFile = FileOperateHelp.PathConvert(OrignFile);
NewFile = FileOperateHelp.PathConvert(NewFile);
File.Copy(OrignFile, NewFile, true);
return "ok";
}
catch (Exception ex)
{
return ex.Message;
}
}
#endregion #region 08.创建文件夹
/// <summary>
/// 创建文件夹
/// </summary>
/// <param name="Path">相对路径(web里相对路径,控制台在根目录下写)</param>
public static string FolderCreate(string Path)
{
try
{
Path = FileOperateHelp.PathConvert(Path);
// 判断目标目录是否存在如果不存在则新建之
if (!Directory.Exists(Path))
{
Directory.CreateDirectory(Path);
}
return "ok";
}
catch (Exception ex)
{
return ex.Message;
}
}
#endregion #region 09.递归删除文件夹目录及文件
/// <summary>
/// 递归删除文件夹目录及文件
/// </summary>
/// <param name="dir">相对路径(web里相对路径,控制台在根目录下写) 截止到哪删除到哪，eg：/a/ 连a也删除</param>
/// <returns></returns>
public static string DeleteFolder(string dir)
{ try
{
string adir = FileOperateHelp.PathConvert(dir);
if (Directory.Exists(adir)) //如果存在这个文件夹删除之
{
foreach (string d in Directory.GetFileSystemEntries(adir))
{
if (File.Exists(d))
File.Delete(d); //直接删除其中的文件
else
DeleteFolder(d); //递归删除子文件夹
}
Directory.Delete(adir, true); //删除已空文件夹
}
return "ok";
}
catch (Exception ex)
{
return ex.Message;
}
} #endregion #region 10.将相对路径转换成绝对路径
/// <summary>
/// 10.将相对路径转换成绝对路径
/// </summary>
/// <param name="strPath">相对路径</param>
public static string PathConvert(string strPath)
{
//web程序使用
if (HttpContext.Current != null)
{
return HttpContext.Current.Server.MapPath(strPath);
}
else //非web程序引用
{
strPath = strPath.Replace("/", "\\");
if (strPath.StartsWith("\\"))
{
strPath = strPath.TrimStart('\\');
}
return System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, strPath);
}
}
#endregion }
1. 在控制台中进行调用。
//1.写文件测试(覆盖写入)
FileOperateHelp.Write_Txt("TestFile/mr.txt", "mr123");
FileOperateHelp.Write_Txt("TestFile/mr2.txt", "mr123");
//2.读文件测试
string msg1 = FileOperateHelp.Read_Txt("TestFile/mr.txt"); //3.写文件测试(追加写入)
FileOperateHelp.WriteFile("TestFile/mr.txt", "");
//4.读文件测试
string msg2 = FileOperateHelp.ReadFile("TestFile/mr.txt"); //5.删除文件测试
FileOperateHelp.FileDel("TestFile/mr2.txt"); //6.移动文件测试
FileOperateHelp.FileMove("TestFile/mr.txt", "TestFile/TEST/mr移动.txt"); //7.复制文件测试
FileOperateHelp.FileCopy("TestFile/mr3.txt", "TestFile/TEST/mr3Copy.txt"); //8.创建文件夹
FileOperateHelp.FolderCreate("TestFile/TEST2"); //9.递归删除文件夹（删除a文件夹）
FileOperateHelp.DeleteFolder("TestFile/TestDel/a/");
2. 在Web程序中进行调用
public void Index()
{
//1.写文件测试(覆盖写入)
FileOperateHelp.Write_Txt("~/TestFile/mr.txt", "mr123");
FileOperateHelp.Write_Txt("~/TestFile/mr2.txt", "mr123");
//2.读文件测试
string msg1 = FileOperateHelp.Read_Txt("~/TestFile/mr.txt"); //3.写文件测试(追加写入)
FileOperateHelp.WriteFile("~/TestFile/mr.txt", "");
//4.读文件测试
string msg2 = FileOperateHelp.ReadFile("~/TestFile/mr.txt"); //5.删除文件测试
FileOperateHelp.FileDel("~/TestFile/mr2.txt"); //6.移动文件测试
FileOperateHelp.FileMove("~/TestFile/mr.txt", "~/TestFile/TEST/mr移动.txt"); //7.复制文件测试
FileOperateHelp.FileCopy("~/TestFile/mr3.txt", "~/TestFile/TEST/mr3Copy.txt"); //8.创建文件夹
FileOperateHelp.FolderCreate("~/TestFile/TEST2"); //9.递归删除文件夹（删除a文件夹）
FileOperateHelp.DeleteFolder("~/TestFile/TestDel/a/"); }
二. 序列化和反序列化
1. 在.Net中，序列化和反序列化主要有两种 ：
方案一：利用JavaScriptSerializer对象实现，需要添加System.Web.Extensions程序集的引用。
方案二：利用程序集Newtonsoft.Json.dll来实现。
注意：如果要把某个类序列化，需要在该类上面加一个 [Serializable]属性。
下面分享一个JsonHelp类，该类主要提供两种序列化和反序列化的方法，代码如下：
public class JsonHelp
{
#region 01-将JSON转换成JSON字符串
/// <summary>
/// 将JSON转换成JSON字符串
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <returns></returns>
public static string ObjectToString<T>(T obj)
{
JavaScriptSerializer jss = new JavaScriptSerializer();
return jss.Serialize(obj);
}
#endregion #region 02-将字符串转换成JSON对象
/// <summary>
/// 将字符串转换成JSON对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="content"></param>
/// <returns></returns>
public static T StringToObject<T>(string content)
{
JavaScriptSerializer jss = new JavaScriptSerializer();
return jss.Deserialize<T>(content);
}
#endregion #region 03-将JSON转换成JSON字符串
/// <summary>
///将JSON转换成JSON字符串
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <returns></returns>
public static string ToJsonString<T>(T obj)
{
return JsonConvert.SerializeObject(obj);
}
#endregion #region 04-将字符串转换成JSON对象
/// <summary>
/// 将字符串转换成JSON对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="content"></param>
/// <returns></returns>
public static T ToObject<T>(string content)
{
return JsonConvert.DeserializeObject<T>(content);
}
#endregion
}
2. 代码调用：
//1. 将JSON对象转换成JSON字符串
Console.WriteLine("-------------------------------------1. 将JSON转换成JSON字符串------------------------------------------");
var myObj = new
{
id = "",
name = "ypf",
myList = studentList,
myList2 = studentList.Where(u => u.Age > ).Select(u => new
{
t1 = u.Age,
t2 = u.ClassId
}).ToList() };
//1.1 方式一
string myString1 = JsonHelp.ObjectToString(myObj);
//1.2 方式二
string myString2 = JsonHelp.ToJsonString(myObj);
string myString3 = JsonHelp.ToJsonString(studentList);
Console.WriteLine(myString1);
Console.WriteLine(myString2);
//2. 将JSON字符串转换成JSON对象（必须显式的声明对象）
List<Student> myList = JsonHelp.StringToObject<List<Student>>(myString3);
Console.WriteLine(myList);
三. 加密和解密
这里介绍三种加密方式，分别是：
(1). MD5不可逆加密：加密后可以是16位，也可以是32位，任何语言的MD5加密后的结果都相同。
(2). DES可逆对称加密：
优点：对称加密算法的优点是速度快。
缺点：密钥管理不方便，要求共享密钥。
特点：不同写法对应的加密值不同。
(3). RSA可逆非对称加密:
特点：可逆非对称加密，需要两个Key,公钥和私钥，每次产生的公钥和私钥不一致，加密的结果就不一致
好处：非对称加密算法的优点是密钥管理很方便，缺点是速度慢。
特性(重点！！！)：需要通过代码来生成一对公钥（加密key）和私钥（解密key）,公钥私钥只与是否公开有关。
A. 如果公开公钥（加密key）：只有我接受加密信息才有用，因为只有我有私钥（解密key），能解密。
B. 如果公开私钥（解密key）：用于签名，表示加密数据一定是我发的，因为只有公钥（加密key）。
1. 下面分享两种MD5实现的算法
/// <summary>
/// MD5加密,和动网上的16/32位MD5加密结果相同,
/// 使用的UTF8编码
/// </summary>
/// <param name="strSource">待加密字串</param>
/// <param name="length">16或32值之一,其它则采用.net默认MD5加密算法</param>
/// <returns>加密后的字串</returns>
public static string Encrypt(string source, int length = )//默认参数
{
HashAlgorithm provider = CryptoConfig.CreateFromName("MD5") as HashAlgorithm;
if (string.IsNullOrEmpty(source)) return string.Empty; byte[] bytes = Encoding.UTF8.GetBytes(source);// Encoding.ASCII.GetBytes(source);
byte[] hashValue = provider.ComputeHash(bytes);
StringBuilder sb = new StringBuilder();
switch (length)
{
case ://16位密文是32位密文的9到24位字符
for (int i = ; i < ; i++)
sb.Append(hashValue[i].ToString("x2"));
break;
case :
for (int i = ; i < ; i++)
{
sb.Append(hashValue[i].ToString("x2"));
}
break;
default:
for (int i = ; i < hashValue.Length; i++)
{
sb.Append(hashValue[i].ToString("x2"));
}
break;
}
return sb.ToString();
}
/// <summary>
/// MD5加密
/// </summary>
/// <param name="str">要加密的字符串</param>
/// <returns>加密后的字符串</returns>
public static string Md5(string str)
{
var md5 = MD5.Create();
// 计算字符串的散列值
var bytes = md5.ComputeHash(Encoding.UTF8.GetBytes(str));
var sbd = new StringBuilder();
foreach (var item in bytes)
{
sbd.Append(item.ToString("x2"));
}
return sbd.ToString();
}
2. 下面分享两种DES实现的算法
public class DesEncrypt
{
//8位长度
private static string KEY = "ypf12345";
private static byte[] rgbKey = ASCIIEncoding.ASCII.GetBytes(KEY.Substring(, ));
private static byte[] rgbIV = ASCIIEncoding.ASCII.GetBytes(KEY.Insert(, "w").Substring(, )); #region 01-DES加密
/// <summary>
/// DES 加密
/// </summary>
/// <param name="strValue">需要加密的字符串</param>
/// <returns></returns>
public static string Encrypt(string strValue)
{
DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
using (MemoryStream memStream = new MemoryStream())
{
CryptoStream crypStream = new CryptoStream(memStream, dsp.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
StreamWriter sWriter = new StreamWriter(crypStream);
sWriter.Write(strValue);
sWriter.Flush();
crypStream.FlushFinalBlock();
memStream.Flush();
return Convert.ToBase64String(memStream.GetBuffer(), , (int)memStream.Length);
}
}
#endregion #region 02-DES解密
/// <summary>
/// DES解密
/// </summary>
/// <param name="EncValue">加密后的结果</param>
/// <returns></returns>
public static string Decrypt(string EncValue)
{
DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
byte[] buffer = Convert.FromBase64String(EncValue); using (MemoryStream memStream = new MemoryStream())
{
CryptoStream crypStream = new CryptoStream(memStream, dsp.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
crypStream.Write(buffer, , buffer.Length);
crypStream.FlushFinalBlock();
return ASCIIEncoding.UTF8.GetString(memStream.ToArray());
}
}
#endregion
}
#region 3.DES加密一个字符串(可逆，非固定)
/// <summary>
/// 加密一个字符串(可逆，非固定)
/// </summary>
/// <param name="str">要加密的字符串</param>
/// <param name="key">加密密钥</param>
/// <returns>加密后的字符串</returns>
public static string EncryptStr(string str, string key = "iceStone")
{
var des = DES.Create();
// var timestamp = DateTime.Now.ToString("HHmmssfff");
var inputBytes = Encoding.UTF8.GetBytes(MixUp(str));
var keyBytes = Encoding.UTF8.GetBytes(key);
SHA1 ha = new SHA1Managed();
var hb = ha.ComputeHash(keyBytes);
var sKey = new byte[];
var sIv = new byte[];
for (var i = ; i < ; i++)
sKey[i] = hb[i];
for (var i = ; i < ; i++)
sIv[i - ] = hb[i];
des.Key = sKey;
des.IV = sIv;
using (var ms = new MemoryStream())
{
using (var cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(inputBytes, , inputBytes.Length);
cs.FlushFinalBlock();
var ret = new StringBuilder();
foreach (var b in ms.ToArray())
{
ret.AppendFormat("{0:X2}", b);
} return ret.ToString();
}
}
}
#endregion #region 4.DES解密一个字符串
/// <summary>
/// 解密一个字符串
/// <param name="str">要解密的字符串</param>
/// <param name="key">加密密钥</param>
/// <returns>解密后的字符串</returns>
public static string DecryptStr(string str, string key = "iceStone")
{
var des = DES.Create();
var inputBytes = new byte[str.Length / ];
for (var x = ; x < str.Length / ; x++)
{
inputBytes[x] = (byte)System.Convert.ToInt32(str.Substring(x * , ), );
}
var keyByteArray = Encoding.UTF8.GetBytes(key);
var ha = new SHA1Managed();
var hb = ha.ComputeHash(keyByteArray);
var sKey = new byte[];
var sIv = new byte[];
for (var i = ; i < ; i++)
sKey[i] = hb[i];
for (var i = ; i < ; i++)
sIv[i - ] = hb[i];
des.Key = sKey;
des.IV = sIv;
using (var ms = new MemoryStream())
{
using (var cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(inputBytes, , inputBytes.Length);
cs.FlushFinalBlock();
return ClearUp(Encoding.UTF8.GetString(ms.ToArray()));
}
}
}
#endregion
3. 下面分享RSA的代码
public class RsaEncrypt
{ #region 01-生成公钥和私钥
/// <summary>
/// 生成公钥和私钥
/// </summary>
/// <returns></returns>
public static KeyValuePair<string, string> GetKeyPair()
{
RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
string publicKey = RSA.ToXmlString(false);
string privateKey = RSA.ToXmlString(true);
return new KeyValuePair<string, string>(publicKey, privateKey);
}
#endregion #region 02-加密(传入内容和公钥)
/// <summary>
/// 加密：内容+公钥,事先需要生成公钥和私钥
/// </summary>
/// <param name="content">加密内容</param>
/// <param name="publicKey">公钥</param>
/// <returns></returns>
public static string Encrypt(string content, string publicKey)
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.FromXmlString(publicKey);
UnicodeEncoding ByteConverter = new UnicodeEncoding();
byte[] DataToEncrypt = ByteConverter.GetBytes(content);
byte[] resultBytes = rsa.Encrypt(DataToEncrypt, false);
return Convert.ToBase64String(resultBytes);
}
#endregion #region 03-加密(并返回公钥和私钥)
/// <summary>
/// 加密(并返回公钥和私钥),在该方法中生成了公钥和私钥，并返回
/// </summary>
/// <param name="content">加密内容</param>
/// <param name="publicKey">返还公钥</param>
/// <param name="privateKey">返回密钥</param>
/// <returns>加密后结果</returns>
public static string Encrypt(string content, out string publicKey, out string privateKey)
{
RSACryptoServiceProvider rsaProvider = new RSACryptoServiceProvider();
publicKey = rsaProvider.ToXmlString(false);
privateKey = rsaProvider.ToXmlString(true);
UnicodeEncoding ByteConverter = new UnicodeEncoding();
byte[] DataToEncrypt = ByteConverter.GetBytes(content);
byte[] resultBytes = rsaProvider.Encrypt(DataToEncrypt, false);
return Convert.ToBase64String(resultBytes);
}
#endregion #region 04-解密(内容+私钥)
/// <summary>
/// 解密-内容+私钥
/// </summary>
/// <param name="content"></param>
/// <param name="privateKey"></param>
/// <returns></returns>
public static string Decrypt(string content, string privateKey)
{
byte[] dataToDecrypt = Convert.FromBase64String(content);
RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
RSA.FromXmlString(privateKey);
byte[] resultBytes = RSA.Decrypt(dataToDecrypt, false);
UnicodeEncoding ByteConverter = new UnicodeEncoding();
return ByteConverter.GetString(resultBytes);
}
#endregion
}
4. 分享加密算法的调用代码
{
Console.WriteLine("-------------------------------------三.3种加密方式------------------------------------------");
{
Console.WriteLine("----------------------1.MD5加密(加密后结果可以是32位,也可以是16位,主流都采用32位)-----------------------------");
//1.MD5加密(加密后结果可以是32位,也可以是16位,主流都采用32位)
//1.1 写法一
string msg1 = "mr1";
string result1 = MD5Encrypt.Encrypt(msg1);
string result2 = MD5Encrypt.Encrypt(msg1, );
Console.WriteLine(result1);
Console.WriteLine(result2);
//1.2 写法二 .Net 高度封装的MD5方法
string result3 = SecurityHelp.Md5(msg1);
Console.WriteLine(result3);
}
{
Console.WriteLine("----------------------2.对称可逆加密算法DES-----------------------------");
//2.对称加密算法DES
string msg1 = "mr1";
//2.1 写法一：密钥写在DesEncrypt类中了，密钥为ypf12345
string result1 = DesEncrypt.Encrypt(msg1);
string result2 = DesEncrypt.Decrypt(result1);
Console.WriteLine(result1);
Console.WriteLine(result2);
//2.2 写法二
string result3 = SecurityHelp.EncryptStr(msg1, "ypf12345");
string result4 = SecurityHelp.DecryptStr(result3, "ypf12345");
Console.WriteLine(result3);
Console.WriteLine(result4);
}
{
Console.WriteLine("----------------------3.非对称可逆加密算法RSA-----------------------------");
//方式一：先生成公钥和私钥,然后加密和解密
//KeyValuePair是一个键值对, myKey.Key 代表的公钥；myKey.Value 代表的私钥
KeyValuePair<string, string> myKey = RsaEncrypt.GetKeyPair();
string msg1 = "mr1";
//加密
string result1 = RsaEncrypt.Encrypt(msg1, myKey.Key);
//解密
string result2 = RsaEncrypt.Decrypt(result1, myKey.Value);
Console.WriteLine(result1);
Console.WriteLine(result2);
//方式二：直接加密，并通过out参数的形式返回公钥和私钥
string publicKey = "";
string privateKey = "";
//加密
string result3 = RsaEncrypt.Encrypt(msg1, out publicKey, out privateKey);
//解密
string result4 = RsaEncrypt.Decrypt(result3, privateKey);
Console.WriteLine(result3);
Console.WriteLine(result4);
}
}
运行结果：
!
作 者 : Yaopengfei(姚鹏飞)
博客地址 : http://www.cnblogs.com/yaopengfei/
声 明1 : 本人才疏学浅，用郭德纲的话说“我是一个小学生”，如有错误，欢迎讨论，请勿谩骂^_^。
声 明2 : 原创博客请在转载时保留原文链接或在文章开头加上本人博客地址，否则保留追究法律责任的权利。
