Common方法

一些Common的方法。

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Script.Serialization;
using System.IO;
using System.Runtime.Serialization.Json;
using System.Data;
using System.Xml;
using System.Text;
using System.Xml.Serialization;
using System.Reflection;

namespace Commom
{
    public static class CommonMethod
    {
        public static List<T> JSONStringToList<T>(this string JsonStr)
        {
            JavaScriptSerializer Serializer = new JavaScriptSerializer();
            List<T> objs = Serializer.Deserialize<List<T>>(JsonStr);
            return objs;
        }

        public static string ConvertToJson(System.Data.DataTable dt)
        {
            System.Text.StringBuilder retVal = new System.Text.StringBuilder();
            retVal.Append("[");
            int RowCount = 0, ColumnCount = 0;
            foreach (DataRow row in dt.Rows)
            {
                RowCount++;
                retVal.Append("{");
                foreach (DataColumn column in dt.Columns)
                {
                    ColumnCount++;
                    retVal.AppendFormat("'{0}':'{1}'{2}", column.ColumnName, (row[column].ToString()), ColumnCount == dt.Columns.Count ? "" : ",");
                }
                ColumnCount = 0;
                retVal.Append("}");
                retVal.AppendFormat("{0}", RowCount == dt.Rows.Count ? "" : ",");
            }
            retVal.Append("]");
            return retVal.ToString();
        }

        public static string ToJSONS(object obj)
        {
            JavaScriptSerializer serillizer = new JavaScriptSerializer();
            return serillizer.Serialize(obj);
        }

        public static string ToJSONS(object obj, int recursiondepth)
        {
            JavaScriptSerializer serialize = new JavaScriptSerializer();
            serialize.RecursionLimit = recursiondepth;
            return serialize.Serialize(obj);
        }

        public static string DtToXml(DataTable dt)
        {
            if (dt != null)
            {
                if (string.IsNullOrEmpty(dt.TableName))
                    dt.TableName = Guid.NewGuid().ToString();

                MemoryStream ms = null;
                XmlTextWriter XmlWt = null;
                try
                {
                    ms = new MemoryStream();                   
                    XmlWt = new XmlTextWriter(ms, Encoding.Unicode);//根据ms实例化XmlWt                    
                    dt.WriteXml(XmlWt);
                    int count = (int)ms.Length;
                    byte[] temp = new byte[count];
                    ms.Seek(0, SeekOrigin.Begin);
                    ms.Read(temp, 0, count);                    
                    UnicodeEncoding ucode = new UnicodeEncoding();
                    string returnValue = ucode.GetString(temp);
                    return returnValue;
                }
                catch (System.Exception ex)
                {
                    throw ex;
                }
                finally
                {                  
                    if (XmlWt != null)//释放资源
                    {
                        XmlWt.Close();
                        ms.Close();
                        ms.Dispose();
                    }
                }
            }
            else
            {
                return "";
            }
        }


        public static int ToLength(this string input)
        {
            if (input.IsEmpty())
                return 0;
            int n = 0;
            foreach (char c in input)
            {
                if ((int)c > 256)
                    n += 2;
                else
                    n++;
            }
            return n;
        }

        public static bool IsEmpty(this string input)
        {
            return string.IsNullOrEmpty(input);
        }


        /// <summary>
        /// 反序列化
        /// </summary>
        /// <param name="type">对象类型</param>
        /// <param name="filename">文件路径</param>
        public static object Load(Type type, string filename)
        {
            FileStream fs = null;
            try
            {
                // open the stream...
                fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                XmlSerializer serializer = new XmlSerializer(type);
                return serializer.Deserialize(fs);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (fs != null)
                    fs.Close();
            }
        }

        /// <summary>
        /// 序列化
        /// </summary>
        /// <param name="obj">对象</param>
        /// <param name="filename">文件路径</param>
        public static void Save(object obj, string filename)
        {
            FileStream fs = null;
            // serialize it...
            try
            {
                fs = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
                XmlSerializer serializer = new XmlSerializer(obj.GetType());
                serializer.Serialize(fs, obj);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (fs != null)
                    fs.Close();
            }
        }

    }

    /// <summary>
    /// 单例实现辅助类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public static class Singleton<T> where T : class
    {
        static volatile T _instance;

        static object _lock = new object();

        static Singleton() { }

        /// <summary>        
        /// 创建/获取一个可以new的类对象的单件实例        
        /// </summary>   
        public static T Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_lock)
                    {
                        if (_instance == null)
                        {
                            ConstructorInfo constructor = null;
                            try
                            {
                                //构造函数不包含public修饰符的
                                constructor = typeof(T).GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[0], null);
                            }
                            catch (Exception ex)
                            {
                                throw new InvalidOperationException(ex.Message, ex);
                            }
                            if (constructor == null || constructor.IsAssembly)
                            {
                                throw new InvalidOperationException(string.Format("在'{0}'里面没有找到private或者protected的构造函数。", typeof(T).Name));
                            }
                            _instance = (T)constructor.Invoke(null);
                        }
                    }
                }
                return _instance;
            }
        }
    }


}