databuild.cs

高校 学籍管理、成绩、收费、网上教学

using System;
using System.IO;
using System.Text;
using System.Security.Cryptography;

namespace QSEDUNET.COMMAND
{
	/// <summary>
	/// DataBuild 的摘要说明。
	/// </summary>
	public class DataBuild
	{
		private const int saltLength = 4;
		public DataBuild()
		{
			//
			// TODO: 在此处添加构造函数逻辑
			//
		}

		/// <summary>
		/// 获得字符的哈希编码
		/// </summary>
		/// <param name="inString">输入字符</param>
		/// <returns>返回哈希系列</returns>
		public byte[] GetHashList( string inString )
		{
			byte[] outString;
			SHA1 shal = SHA1.Create();
			outString = shal.ComputeHash( Encoding.Unicode.GetBytes( inString ) );
			return outString;
		}

		/// <summary>
		/// 获取加密的字符串
		/// </summary>
		/// <param name="inHashList">输入哈希列表</param>
		/// <returns>返回加密字符</returns>
		public byte[] GetSaltString( byte[] inHashList )
		{
			byte[] saltValue = new byte[ saltLength ];
			RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
			rng.GetBytes(saltValue);

			return GetResultHashList( saltValue, inHashList );
		}

		/// <summary>
		/// 加密哈希列
		/// </summary>
		/// <param name="saltValue">４位随机数组</param>
		/// <param name="inHashList">要加密的hash列</param>
		/// <returns>加密数组</returns>
		public byte[] GetResultHashList( byte[] saltValue, byte[] inHashList )
		{
			byte[] rawSalted = new byte[saltValue.Length + inHashList.Length];
			inHashList.CopyTo(rawSalted,0);
			saltValue.CopyTo(rawSalted,inHashList.Length);

			SHA1 shal = SHA1.Create();
			byte[] saltedString = shal.ComputeHash(rawSalted);

			byte[] lastString = new byte[saltedString.Length + saltValue.Length];
			saltedString.CopyTo(lastString,0);
			saltValue.CopyTo(lastString,saltedString.Length);

			return lastString;
		}

		/// <summary>
		/// 比较两个哈希列
		/// </summary>
		/// <param name="oldList">加密hash列</param>
		/// <param name="newList">未加密hash列</param>
		/// <returns>是否相同,是 true,否 false</returns>
		public bool CompareString( byte[] oldList, byte[] newList )
		{
			if(oldList == null || newList == null || newList.Length != oldList.Length - saltLength)
				return false;
			byte[] saltValue = new byte[saltLength];
			int saltOffSet = oldList.Length - saltLength;
			for(int i = 0; i< saltOffSet; i++)
				saltValue[i] = oldList[oldList.Length + i];

			byte[] newListCopy = GetResultHashList(saltValue, newList);
			return CompareByteArray(oldList,newListCopy);
		}

		/// <summary>
		/// 比较两个相同随机数加密的hash数组
		/// </summary>
		/// <param name="oldList">加密的数组</param>
		/// <param name="newListCopy">经过相同随机数加密的数组</param>
		/// <returns>是否相同 是true,否false</returns>
		public bool CompareByteArray( byte[] oldList, byte[] newListCopy )
		{
			if(oldList.Length != newListCopy.Length)
				return false;
			for(int i = 0; i< oldList.Length; i++)
			{
				if(oldList.Length != newListCopy.Length)
					return false;
			}
			return true;
		}

		/// <summary>
		/// 去除字符串两头的空格.<br/>
		/// 如果对象不是字符,则会先转化成字符串.如果对象为空,则为空字符串
		/// </summary>
		/// <param name="objValue">要转化的对象</param>
		/// <returns>结果</returns>
		public static string Trim(object objValue)
		{
			if (objValue == null || objValue == System.DBNull.Value)
				objValue = "";

			return objValue.ToString().Trim();
		}

		/// <summary>
		/// 得到合法的数据
		/// </summary>
		/// <param name="pt">要返回的数据类别</param>
		/// <param name="ps_value"></param>
		/// <returns></returns>
		public static object GetValidateData(System.TypeCode ptTypeCode, object objValue)
		{
			//System.TypeCode ptTypeCode=Type.GetTypeCode(pt);
			string ps_value = Trim(objValue);

			switch (ptTypeCode)
			{
				case TypeCode.Int16:
				case TypeCode.Int32:
				case TypeCode.Int64:
				case TypeCode.Decimal:
				case TypeCode.Double:
				case TypeCode.Single:
				case TypeCode.UInt16:
				case TypeCode.UInt32:
				case TypeCode.UInt64:
				case TypeCode.Byte:
				case TypeCode.SByte:
					if (ps_value.Trim() == "")
					{
						return Convert.ChangeType(0, ptTypeCode);
					}
					try
					{
						return Convert.ChangeType(ps_value, ptTypeCode);
					}
					catch
					{
						return Convert.ChangeType(0, ptTypeCode);
					}
				case TypeCode.Boolean:
					if (ps_value.Trim() == "")
					{
						return false;
					}
					try
					{
						return Convert.ChangeType(ps_value, ptTypeCode);
					}
					catch
					{
						return false;
					}
				case TypeCode.DateTime:
					if (ps_value.Trim() == "")
					{
						return new DateTime(1900, 1, 1);
					}
					try
					{
						return DateTime.Parse(ps_value);
					}
					catch
					{
						return new DateTime(1900, 1, 1);
					}
				default:
					return Convert.ChangeType(ps_value, ptTypeCode);
			}
		}
	}
}