Extensions

using LXYD.WebGame.Util.SqlHelpers;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;

namespace LXYD.WebGame.Util.MiscHelpers
{
public static class Extensions
{
///
/// 将string类型的队列转换为xelement类型队列
///
///
///
public static IEnumerable ToXElement(this IEnumerable list)
{
List result = new List();
foreach (var row in list)
result.Add(XElement.Parse(row));
return result;
}
///
/// 将队列转换为xelement
///
///
///
public static XElement ToXElement(this IEnumerable list)
{
XElement tableXml = new XElement(“table”);
tableXml.Add(list);
return tableXml;
}

    /// <summary>
    /// 对象转XML
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static XElement ObjectToXml<T>(this T obj) where T : class, new()
    {
        XElement tableXml = new XElement("table");
        XElement row = new XElement("row");
        //获取TResult的类型实例  反射的入口
        Type t = obj.GetType();
        // 获得此模型的公共属性      
        PropertyInfo[] paramPropertys = t.GetProperties(BindingFlags.Public | BindingFlags.Instance);
        foreach (PropertyInfo p in paramPropertys)
        {
            var value = p.GetValue(obj, null);
            if (value != null)
            {
                string nodeValue = value.ToString().ReplaceLowOrderASCIICharacters();
                row.Add(new XElement(p.Name.ToLower(), nodeValue));
            }
        }
        tableXml.Add(row);
        return tableXml;
    }

    /// <summary>
    /// 集合转XML
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="list"></param>
    /// <returns></returns>
    public static XElement ListToXml<T>(this IEnumerable<T> list) where T : class, new()
    {
        XElement tableXml = new XElement("table");
        foreach (var item in list)
        {
            XElement row = new XElement("row");
            //获取TResult的类型实例  反射的入口
            Type t = item.GetType();
            // 获得此模型的公共属性      
            PropertyInfo[] paramPropertys = t.GetProperties(BindingFlags.Public | BindingFlags.Instance);
            foreach (PropertyInfo p in paramPropertys)
            {
                var value = p.GetValue(item, null);
                if (value != null)
                    row.Add(new XElement(p.Name.ToLower(), value));
                else
                    row.Add(new XElement(p.Name.ToLower(), ""));
            }
            tableXml.Add(row);
        }
        return tableXml;
    }


    /// <summary>
    /// DataTable转List
    /// </summary>
    /// <returns></returns>
    public static List<T> ToListEntity<T>(this DataTable dt) where T : new()
    {

        List<T> ts = new List<T>();


        Type type = typeof(T);
        string tempName = "";

        foreach (DataRow dr in dt.Rows)
        {
            T t = new T();

            PropertyInfo[] propertys = t.GetType().GetProperties();
            foreach (PropertyInfo pi in propertys)
            {
                tempName = pi.Name;

                if (dt.Columns.Contains(tempName))
                {

                    if (!pi.CanWrite) continue;

                    object value = dr[tempName];
                    if (value != DBNull.Value)
                        pi.SetValue(t, value, null);
                }
            }
            ts.Add(t);
        }
        return ts;
    }

    /// <summary>
    /// uri网址转换为Model对象参数形式  
    /// </summary>
    /// <param name="str"></param>
    /// <param name="url"></param>
    /// <returns></returns>
    public static Dictionary<string, string> UriParamToModel(this string str, string url = "")
    {
        if (!string.IsNullOrEmpty(url))
        {
            str.Replace($"{url}?", "");
        }
        string[] list = str.Split('&');

        var dic = new Dictionary<string, string>();

        foreach (string item in list)
        {
            var arrayA = item.Split('=');

            if (!dic.ContainsKey(arrayA[0]))
            {
                dic.Add(arrayA[0], arrayA[1]);
            }
        } 
       
        return dic;
    }

    /// <summary>
    /// Dictionary 转规则字符串
    /// </summary>
    /// <param name="diy">The diy.</param>
    /// <param name="splitStr">The split string.</param>
    /// <returns>
    /// <Time>2018/8/14</Time>
    /// <Author>Rocky</Author>
    public static string DictionaryToStringSplit(this Dictionary<string, string> diy, char splitStr = '&')
    {

        if (diy == null || !diy.Any())
            return string.Empty;

        StringBuilder str = new StringBuilder();

        foreach (string key in diy.Keys)
        {
            str.AppendFormat("{0}={1}{2}", key, diy[key], splitStr);
        }
        return str.ToString().TrimEnd(splitStr);
    }

    /// <summary>
    /// 值在的范围？
    /// </summary>
    /// <param name="thisValue"></param>
    /// <param name="begin">大于等于begin</param>
    /// <param name="end">小于等于end</param>
    /// <returns></returns>
    public static bool IsInRange(this decimal thisValue, decimal begin, decimal end)
    {
        return thisValue >= begin && thisValue <= end;
    }

    /// <summary>
    /// 值在的范围？
    /// </summary>
    /// <param name="thisValue"></param>
    /// <param name="begin">大于等于begin</param>
    /// <param name="end">小于等于end</param>
    /// <returns></returns>
    public static bool IsInRange(this int thisValue, int begin, int end)
    {
        return thisValue >= begin && thisValue <= end;
    }
    public static bool IsIn<T>(this T thisValue, params T[] values)
    {
        return values.Contains(thisValue);
    }
}

}