asp.net技术（公共方法）

大量数据写入数据库方法：SqlServer优化之批量插入（SqlBulkCopy、表值参数）

#region 获取 本周、本月、本季度、本年 的开始时间或结束时间
        /// <summary>
        /// 获取开始时间
        /// </summary>
        /// <param name="TimeType">Week、Month、Season、Year</param>
        /// <param name="now"></param>
        /// <returns>2017-01-01 00:00:00</returns>
        public static DateTime? GetTimeStartByType(string TimeType, DateTime now)
        {
            switch (TimeType)
            {
                case "Week":
                    return now.AddDays(-(now.DayOfWeek ==  ?  : (int)now.DayOfWeek) + ).Date;
                case "Month":
                    return now.AddDays(-now.Day + ).Date;
                case "Season":
                    var time = now.AddMonths( - ((now.Month - ) % ));
                    return time.AddDays(-time.Day + ).Date;
                case "Year":
                    return now.AddDays(-now.DayOfYear + ).Date;
                default:
                    return null;
            }
        }

        /// <summary>
        /// 获取结束时间
        /// </summary>
        /// <param name="TimeType">Week、Month、Season、Year</param>
        /// <param name="now"></param>
        /// <returns>2017-12-31 23:59:59</returns>
        public static DateTime? GetTimeEndByType(string TimeType, DateTime now)
        {
            DateTime dt = new DateTime();
            switch (TimeType)
            {
                case "Week":
                    dt = now.AddDays( - (now.DayOfWeek ==  ?  : (int)now.DayOfWeek)).Date; break;
                case "Month":
                    dt = now.AddMonths().AddDays(-now.AddMonths().Day + ).AddDays(-).Date; break;
                case "Season":
                    var time = now.AddMonths(( - ((now.Month - ) % ) - ));
                    dt = time.AddMonths().AddDays(-time.AddMonths().Day + ).AddDays(-).Date; break;
                case "Year":
                    var time2 = now.AddYears();
                    dt = time2.AddDays(-time2.DayOfYear).Date; break;
                default:
                    return null;
            }
            return dt.AddDays().AddSeconds(-);
        }
        #endregion

//ashx页面下调用多种方法

        public void ProcessRequest(HttpContext context)
        {
            var dataType = context.Request["DataType"];
            var keyid = context.Request["Keyid"];

            var cMethod = string.Format("Get{0}", dataType);
            var tp = typeof(DataFetch);
            var mi = tp.GetMethod(cMethod);
            if (mi != null)
            {
                mi.Invoke(Activator.CreateInstance(tp), new object[] { context, keyid });
            }
        }

        /// <summary>
        /// 获取用户信息
        /// </summary>
        /// <param name="keyid"></param>
        public void GetUser(HttpContext context, string keyid)
        {

        var context = HttpContext.Current;
                //var param = context.Request["Param"];

        context.WriteJson(json);

        }  

/*泛型转换*/
 /// <summary>
        /// 获取视图状态的属性值
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="stateName">视图状态名称</param>
        /// <param name="defauleValue">默认值</param>
        public T GetState<T>(string stateName, T defauleValue)
        {
            T m_Value = defauleValue;
            if (ViewState[stateName] != null)
            {
                m_Value = (T)ViewState[stateName];
            }
            return m_Value;
        }

        /// <summary>
        /// 获取视图状态的属性值
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="stateName">视图状态名称</param>
        public T GetState<T>(string stateName)
        {
            return GetState<T>(stateName, default(T));
        }

        private List<T_AberRedSetInfo> listAberRedSet
        {
            get { return this.GetState<List<T_AberRedSetInfo>>("T_AberRedSet"); }
            set { this.SetState("T_AberRedSet", value); }
        }

强制对所有代进行即时垃圾回收 GC.Collect();

深度拷贝与浅复制

///复制List--当然前题是List中的对象要实现ICloneable接口
public static IList<T> Clone<T>(this IList<T> listToClone) where T: ICloneable
         {
                 return listToClone.Select(item => (T)item.Clone()).ToList();
         } 

 #region Object拓展，深复制，对象转换
        /// <summary>
        /// 深复制，就是完全复制Clone，代替ICloneable接口
        /// </summary>
        /// <param name="oSource"></param>
        /// <returns></returns>
        public static T DeepCopy<T>(this T oSource)
        {
            T oClone;
            DataContractSerializer dcs = new DataContractSerializer(typeof(T));
            using (MemoryStream ms = new MemoryStream())
            {
                dcs.WriteObject(ms, oSource);
                ms.Position = ;
                oClone = (T)dcs.ReadObject(ms);
            }
            return oClone;
        }

        /// <summary>
        /// 将Object对象转换为目标对象，一般用于匿名对象转换。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        public static T ChangeObjectType<T>(this object obj, T t)
        {
            return (T)obj;
        }
        #endregion

[Serializable]
    public class InvoiceDetailResponse : IDeepCopy, IShallowCopy
    {

        public Guid merchant_id { get; set; }
        /// <summary>
        /// 名称
        /// </summary>
        public string uname { get; set; }

        /// <summary>
        /// 浅拷贝
        /// </summary>
        /// <returns></returns>
        public object ShallowCopy()
        {
            return this.MemberwiseClone();
        }
       /// <summary>
        /// 深拷贝 【不建议使用二进制流方法，此方法即使在类前面加了可序列化标志，调用该方法时也会报未序列化错误】，推荐使用反射方式
        /// </summary>
        /// <returns></returns>
        public object DeepCopy()
        {
            using (MemoryStream stream = new MemoryStream())
            {
                BinaryFormatter bFormatter = new BinaryFormatter();
                bFormatter.Serialize(stream, this);
                stream.Seek(, SeekOrigin.Begin);
                return (InvoiceDetailResponse)bFormatter.Deserialize(stream);
            }
        }
    }
    /// <summary>
    /// 深拷贝接口
    /// </summary>
    interface IDeepCopy
    {
        object DeepCopy();
    }

    /// <summary>
    /// 浅拷贝接口
    /// </summary>
    interface IShallowCopy
    {
        object ShallowCopy();
    }

///利用反射实现
public static T DeepCopyByReflection<T>(T obj)
{
　　if (obj is string || obj.GetType().IsValueType)
　　return obj;

　　object retval = Activator.CreateInstance(obj.GetType());
　　FieldInfo[] fields = obj.GetType().GetFields(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.Instance);
　　foreach(var field in fields)
　　{
　　　　try
　　　　{
　　　　　　field.SetValue(retval, DeepCopyByReflection(field.GetValue(obj)));
　　　　}
　　　　catch { }
　　}

　　return (T)retval;
}

public static T Clone<T>(T RealObject) 

{
     using (Stream objectStream = new MemoryStream())
     {
            //利用 System.Runtime.Serialization序列化与反序列化完成引用对象的复制
             IFormatter formatter = new BinaryFormatter();
             formatter.Serialize(objectStream, RealObject);
             objectStream.Seek(, SeekOrigin.Begin);
             return (T)formatter.Deserialize(objectStream);
     }
} 

#region Object拓展，深复制，对象转换        /// <summary>        /// 深复制，就是完全复制Clone，代替ICloneable接口        /// </summary>        /// <param name="oSource"></param>        /// <returns></returns>        public static T DeepCopy<T>(this T oSource)        {            T oClone;            DataContractSerializer dcs = new DataContractSerializer(typeof(T));            using (MemoryStream ms = new MemoryStream())            {                dcs.WriteObject(ms, oSource);                ms.Position = 0;                oClone = (T)dcs.ReadObject(ms);            }            return oClone;        }
        /// <summary>        /// 将Object对象转换为目标对象，一般用于匿名对象转换。        /// </summary>        /// <typeparam name="T"></typeparam>        /// <param name="obj"></param>        /// <param name="t"></param>        /// <returns></returns>        public static T ChangeObjectType<T>(this object obj, T t)        {            return (T)obj;        }        #endregion