|
|
/////////////////////////////////////////////////////////////////
|
|
|
//
|
|
|
// (C) Copyright 2009, Kenneth, Inc.
|
|
|
// All rights reserved. Confidential. Except as pursuant
|
|
|
// to a written agreement with Kenneth, this software may
|
|
|
// not be used or distributed. This software may be covered
|
|
|
// by one or more patents.
|
|
|
//
|
|
|
// 本软件为Kenneth开发，版权所有，违者必究，320325198102218110
|
|
|
//
|
|
|
/////////////////////////////////////////////////////////////////
|
|
|
|
|
|
using System;
|
|
|
using System.Collections.Generic;
|
|
|
using System.Linq;
|
|
|
using System.Text;
|
|
|
using System.Text.RegularExpressions;
|
|
|
using System.ComponentModel;
|
|
|
using System.Data.SqlClient;
|
|
|
using System.Data;
|
|
|
|
|
|
namespace GummingCommon
|
|
|
{
|
|
|
public class TypeHelper
|
|
|
{
|
|
|
/// <summary>
|
|
|
///
|
|
|
/// </summary>
|
|
|
/// <param name="str"></param>
|
|
|
/// <returns></returns>
|
|
|
public static string ConvertFromBase64String(string str)
|
|
|
{
|
|
|
return Encoding.Default.GetString(Convert.FromBase64String(str));
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
///
|
|
|
/// </summary>
|
|
|
/// <param name="str"></param>
|
|
|
/// <returns></returns>
|
|
|
public static string ConvertToBase64String(string str)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
return Convert.ToBase64String(Encoding.Default.GetBytes(str));
|
|
|
}
|
|
|
catch
|
|
|
{
|
|
|
return "";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public static string ConvertFromBase64UTF8(string str)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
return Encoding.UTF8.GetString(Convert.FromBase64String(str));
|
|
|
}
|
|
|
catch
|
|
|
{
|
|
|
|
|
|
return "";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public static string ConvertToBase64UTF8(string str)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
return Convert.ToBase64String(Encoding.UTF8.GetBytes(str));
|
|
|
}
|
|
|
catch
|
|
|
{
|
|
|
|
|
|
return "";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public static String UTF8ByteArrayToString(Byte[] characters)
|
|
|
{
|
|
|
|
|
|
UTF8Encoding encoding = new UTF8Encoding();
|
|
|
String constructedString = encoding.GetString(characters);
|
|
|
return (constructedString);
|
|
|
}
|
|
|
|
|
|
public static Byte[] StringToUTF8ByteArray(String pXmlString)
|
|
|
{
|
|
|
|
|
|
UTF8Encoding encoding = new UTF8Encoding();
|
|
|
Byte[] byteArray = encoding.GetBytes(pXmlString);
|
|
|
return byteArray;
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
///
|
|
|
/// </summary>
|
|
|
/// <param name="dt"></param>
|
|
|
/// <returns></returns>
|
|
|
public static string ToString(DateTime dt)
|
|
|
{
|
|
|
return dt.ToString("yyyy-MM-dd HH:mm:ss");
|
|
|
}
|
|
|
|
|
|
public static string ToString(DateTime? dt)
|
|
|
{
|
|
|
return Convert.ToDateTime(dt).ToString("yyyy-MM-dd HH:mm:ss");
|
|
|
}
|
|
|
|
|
|
public static string ToOCIString(DateTime? dt)
|
|
|
{
|
|
|
return Convert.ToDateTime(dt).ToString("yyyyMMdd");
|
|
|
}
|
|
|
|
|
|
public static DateTime ToDateTime(string dtstr)
|
|
|
{
|
|
|
DateTime dt;
|
|
|
DateTime.TryParse(dtstr, out dt);
|
|
|
return dt;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
///
|
|
|
/// </summary>
|
|
|
/// <param name="splitString"></param>
|
|
|
/// <param name="numbers"></param>
|
|
|
/// <returns></returns>
|
|
|
public static string[] Split(string splitString, int numbers)
|
|
|
{
|
|
|
string[] values = splitString.Split(',');
|
|
|
List<string> listValues = new List<string>();
|
|
|
listValues.AddRange(values);
|
|
|
while (listValues.Count < numbers)
|
|
|
{
|
|
|
listValues.Add("0");
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < listValues.Count; i++)
|
|
|
{
|
|
|
if (string.IsNullOrEmpty(listValues[i]))
|
|
|
{
|
|
|
listValues[i] = "0";
|
|
|
}
|
|
|
}
|
|
|
return listValues.ToArray();
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
///
|
|
|
/// </summary>
|
|
|
/// <param name="s"></param>
|
|
|
/// <returns></returns>
|
|
|
public static byte[] HexStringToByteArray(string s)
|
|
|
{
|
|
|
s = s.Replace(" ", "");
|
|
|
|
|
|
byte[] buffer = new byte[s.Length / 2];
|
|
|
|
|
|
for (int i = 0; i < s.Length; i += 2)
|
|
|
|
|
|
buffer[i / 2] = (byte)Convert.ToByte(s.Substring(i, 2), 16);
|
|
|
|
|
|
return buffer;
|
|
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
///
|
|
|
/// </summary>
|
|
|
/// <param name="data"></param>
|
|
|
/// <returns></returns>
|
|
|
public static string ByteArrayToHexString(byte[] data)
|
|
|
{
|
|
|
StringBuilder sb = new StringBuilder(data.Length * 3);
|
|
|
|
|
|
foreach (byte b in data)
|
|
|
|
|
|
sb.Append(Convert.ToString(b, 16).PadLeft(2, '0').PadRight(3, ' '));
|
|
|
|
|
|
return sb.ToString().ToUpper();
|
|
|
}
|
|
|
|
|
|
public static string IntToHex(int value)
|
|
|
{
|
|
|
return value.ToString("X");
|
|
|
}
|
|
|
|
|
|
public static byte[] IntToByteArray(int value)
|
|
|
{
|
|
|
//低位在前，高位在后
|
|
|
byte[] src = new byte[4];
|
|
|
src[3] = (byte)((value >> 24) & 0xFF);
|
|
|
src[2] = (byte)((value >> 16) & 0xFF);
|
|
|
src[1] = (byte)((value >> 8) & 0xFF);
|
|
|
src[0] = (byte)(value & 0xFF);
|
|
|
return src;
|
|
|
|
|
|
/*高位在前，低位在后
|
|
|
byte[] src = new byte[4];
|
|
|
src[0] = (byte) ((value>>24) & 0xFF);
|
|
|
src[1] = (byte) ((value>>16)& 0xFF);
|
|
|
src[2] = (byte) ((value>>8)&0xFF);
|
|
|
src[3] = (byte) (value & 0xFF);
|
|
|
return src;*/
|
|
|
}
|
|
|
|
|
|
public static byte[] ShortToByteArray(int value)
|
|
|
{
|
|
|
//低位在前，高位在后
|
|
|
byte[] src = new byte[2];
|
|
|
src[1] = (byte)((value >> 8) & 0xFF);
|
|
|
src[0] = (byte)(value & 0xFF);
|
|
|
return src;
|
|
|
}
|
|
|
|
|
|
public static int ByteArrayToInt(byte[] bytes)
|
|
|
{
|
|
|
int value;//低位在前，高位在后
|
|
|
value = (int)((bytes[0] & 0xFF)
|
|
|
| ((bytes[1] & 0xFF) << 8)
|
|
|
| ((bytes[2] & 0xFF) << 16)
|
|
|
| ((bytes[3] & 0xFF) << 24));
|
|
|
return value;
|
|
|
|
|
|
/*低位在后，高位在前
|
|
|
int value;
|
|
|
value = (int)(((src[offset] & 0xFF) << 24)
|
|
|
| ((src[offset + 1] & 0xFF) << 16)
|
|
|
| ((src[offset + 2] & 0xFF) << 8)
|
|
|
| (src[offset + 3] & 0xFF));
|
|
|
return value;*/
|
|
|
}
|
|
|
|
|
|
public static int ByteArrayToShort(byte[] bytes)
|
|
|
{
|
|
|
int value;//低位在前，高位在后
|
|
|
value = (int)((bytes[0] & 0xFF)
|
|
|
| ((bytes[1] & 0xFF) << 8));
|
|
|
return value;
|
|
|
|
|
|
/*低位在后，高位在前
|
|
|
int value;
|
|
|
value = (int)(((src[offset] & 0xFF) << 24)
|
|
|
| ((src[offset + 1] & 0xFF) << 16)
|
|
|
| ((src[offset + 2] & 0xFF) << 8)
|
|
|
| (src[offset + 3] & 0xFF));
|
|
|
return value;*/
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// valide the number type
|
|
|
/// </summary>
|
|
|
/// <param name="number"></param>
|
|
|
/// <returns></returns>
|
|
|
/*/////
|
|
|
valide the number type//*/
|
|
|
public static bool ValideDecimal(string number)/////*/
|
|
|
{
|
|
|
bool isnumber = false;
|
|
|
string macth = @"^[+-]?\d{0,19}\.\d*$";
|
|
|
|
|
|
isnumber = Regex.IsMatch(number, macth);
|
|
|
|
|
|
macth = @"^[+-]?\d{1,19}$";
|
|
|
|
|
|
isnumber = Regex.IsMatch(number, macth) || isnumber;
|
|
|
|
|
|
return isnumber;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
///
|
|
|
/// </summary>
|
|
|
/// <param name="pi"></param>
|
|
|
/// <returns></returns>
|
|
|
public static bool ValidTypeIsNumber(System.Reflection.PropertyInfo pi)
|
|
|
{
|
|
|
if (pi.PropertyType == typeof(double) || pi.PropertyType == typeof(int) || pi.PropertyType == typeof(decimal))
|
|
|
{
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Convert Media Color (WPF) to Drawing Color (WinForm)
|
|
|
/// </summary>
|
|
|
/// <param name="mediaColor"></param>
|
|
|
/// <returns></returns>
|
|
|
public static System.Drawing.Color ToDrawingColor(System.Windows.Media.Color mediaColor)
|
|
|
{
|
|
|
return System.Drawing.Color.FromArgb(mediaColor.A, mediaColor.R, mediaColor.G, mediaColor.B);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Convert Drawing Color (WPF) to Media Color (WinForm)
|
|
|
/// </summary>
|
|
|
/// <param name="drawingColor"></param>
|
|
|
/// <returns></returns>
|
|
|
public static System.Windows.Media.Color ToMediaColor(System.Drawing.Color drawingColor)
|
|
|
{
|
|
|
return System.Windows.Media.Color.FromArgb(drawingColor.A, drawingColor.R, drawingColor.G, drawingColor.B);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
///
|
|
|
/// </summary>
|
|
|
/// <param name="value"></param>
|
|
|
/// <param name="destinationType"></param>
|
|
|
/// <returns></returns>
|
|
|
public static object ConvertAnyType(object value, Type destinationType)
|
|
|
{
|
|
|
object returnValue;
|
|
|
if ((value == null) || destinationType.IsInstanceOfType(value))
|
|
|
{
|
|
|
return value;
|
|
|
}
|
|
|
string str = value as string;
|
|
|
if ((str != null) && (str.Length == 0))
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
TypeConverter converter = TypeDescriptor.GetConverter(destinationType);
|
|
|
bool flag = converter.CanConvertFrom(value.GetType());
|
|
|
if (!flag)
|
|
|
{
|
|
|
converter = TypeDescriptor.GetConverter(value.GetType());
|
|
|
}
|
|
|
if (!flag && !converter.CanConvertTo(destinationType))
|
|
|
{
|
|
|
throw new InvalidOperationException("can to finshed the convert:" + value.ToString() + "==>" + destinationType);
|
|
|
}
|
|
|
try
|
|
|
{
|
|
|
if (destinationType == typeof(bool) && TypeHelper.ValideDecimal((string)value))
|
|
|
{
|
|
|
string newvalue = value as string;
|
|
|
newvalue = newvalue.ToLower();
|
|
|
returnValue = newvalue == "true" || newvalue == "1" ? true : false;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
returnValue = flag ? converter.ConvertFrom(null, null, value) : converter.ConvertTo(null, null, value, destinationType);
|
|
|
}
|
|
|
}
|
|
|
catch (Exception e)
|
|
|
{
|
|
|
throw new InvalidOperationException("convert error:" + value.ToString() + "==>" + destinationType, e);
|
|
|
}
|
|
|
return returnValue;
|
|
|
}
|
|
|
|
|
|
|
|
|
public static DbType GetDbType(Type type)
|
|
|
{
|
|
|
String name = type.Name;
|
|
|
DbType val = DbType.String; // default value
|
|
|
try
|
|
|
{
|
|
|
val = (DbType)Enum.Parse(typeof(DbType), name, true);
|
|
|
}
|
|
|
catch (Exception)
|
|
|
{
|
|
|
// add error handling to suit your taste
|
|
|
}
|
|
|
return val;
|
|
|
}
|
|
|
|
|
|
public static SqlDbType GetSqlDbType(Type type)
|
|
|
{
|
|
|
SqlParameter p1 = new SqlParameter();
|
|
|
System.ComponentModel.TypeConverter tc;
|
|
|
tc = System.ComponentModel.TypeDescriptor.GetConverter(p1.DbType);
|
|
|
|
|
|
if (tc.CanConvertFrom(type))
|
|
|
p1.DbType = (DbType)tc.ConvertFrom(type.Name);
|
|
|
else
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
p1.DbType = (DbType)tc.ConvertFrom(type.Name);
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
}
|
|
|
}
|
|
|
return p1.SqlDbType;
|
|
|
}
|
|
|
|
|
|
public static SqlDbType GetSqlDbType(TypeCode type)
|
|
|
{
|
|
|
SqlDbType p = SqlDbType.VarChar;
|
|
|
switch (type)
|
|
|
{
|
|
|
case TypeCode.String:
|
|
|
p = SqlDbType.VarChar;
|
|
|
break;
|
|
|
case TypeCode.Int32:
|
|
|
p = SqlDbType.Int;
|
|
|
break;
|
|
|
case TypeCode.Int64:
|
|
|
p = SqlDbType.BigInt;
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
return p;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
