C#中list<>定义的变量,我用foreach()循环查找 与 list<> .find 查找两个哪个效率高?后者是不是用了算法

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C#中list<>定义的变量,我用foreach()循环查找 与 list<> .find 查找两个哪个效率高?后者是不是用了算法相关的知识,希望对你有一定的参考价值。

一种是我自己
list<int> lams = new list<int>;
/*省略中间插入信息*/
foreach(int i in lams)

if(i == 152)
return i;

另一种是用list封装的方法find
lams.find ( delegate(int s) return s== 152; )

两种运算效率哪个比较高一点?
或者find采用了什么算法?
谢谢

List<T>.Find() 本质还是循环遍历,不过它用了一层委托来包装。

我们可以看 MSDN 官方对于 List<T>.Find() 的定义:
【当前 List<T> 的元素被逐个传递给 Predicate<T> 委托,并在 List<T> 中向前移动,从第一个元素开始,到最后一个元素结束。当找到匹配项时处理即停止。】
参考:http://msdn.microsoft.com/zh-cn/library/x0b5b5bc.aspx

这样一来,如果集合很小,foreach 效率略微高一些;而如果集合很大,比如有十万行甚至更多行数据,Find() 委托会更快,且随着数据量增多后明显的更高效。

而 List<T>.FindAll() 的效率在集合很小时,明显的不如 foreach 效率;随着集合变大后,效率会慢慢变高,但不会比 foreach 更高效。
参考技术A find 快一点 find是直接寻址了 foreach 还要先找对象 然后寻址 出结果 你可以用一个 几百万的 list实验一下就知道了追问

谢谢哈,你说的也很对

C#中怎样将List&lt;自己定义&gt;转为Json格式 及相关函数-DataContractJsonSerializer

对C#和.net使用List<自己定义>和Json格式相互转化的方法进行总结


关于JSON的入门介绍见http://www.json.org/ ,或者百度,这里不赘述,只是通过以下的样例会有个更快捷和更直观的认识。

如Json格式[{"id":"1","name":"sara"},{"id":"2","name":"sara2"}]

自己定义数据类型。用于List<>:

 [DataContract]
    class Person {
        [DataMember]
        public int id;
        [DataMember]
        public string name;
    }

程序中使用:

首先增加引用:

using System.Runtime.Serialization.Json;
using System.Runtime.Serialization;
using System.Text;

代码内容:

class Program
    {
        static void Main(string[] args)
        {
            //Product.GetAllSmartPhones();
            List<Person> nums = new List<Person>();
            nums.Add(new Person() { 
                id=1,
                name="sara"
            });
            nums.Add(new Person() { 
                id=1,
                name="sylar"
            });

            DataContractJsonSerializer json = new DataContractJsonSerializer(nums.GetType());

            string szJson = "";

            //序列化

            using (MemoryStream stream = new MemoryStream())
            {

                json.WriteObject(stream, nums);

                szJson = Encoding.UTF8.GetString(stream.ToArray());

            }
            Console.WriteLine(szJson);
            Console.ReadLine();
        }
    }
project化时,能够对自己定义数据结构又一次定义一个类:

如:

public class TestListResult<T> : List<T>
    {
        public TestListResult()
        {
            this.Successed = false;
            this.Message = "";
        }
        public bool Successed { get; set; }
        public string Message { get; set; }
    }

使用时同上在一个文件中一样

理解了以上原理,能够使用下面函数在项目中使用:

List<T>转Json

public static string Obj2Json<T>(T data)
{
    try
    {
        System.Runtime.Serialization.Json.DataContractJsonSerializer serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(data.GetType());
        using (MemoryStream ms = new MemoryStream())
        {
            serializer.WriteObject(ms, data);
            return Encoding.UTF8.GetString(ms.ToArray());
        }
    }
    catch
    {
        return null;
    }
}

Json转List<T>

public static Object Json2Obj(String json,Type t)
{
    try
    {
        System.Runtime.Serialization.Json.DataContractJsonSerializer serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(t);
        using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(json)))
        {
            
            return  serializer.ReadObject(ms);
        }
    }
    catch
    {
        return null;
    }
}

DataTable 转Json

public static string DataTable2Json(DataTable dt)
{
    if (dt.Rows.Count == 0)
    {
        return "";
    }
 
    StringBuilder jsonBuilder = new StringBuilder();
    // jsonBuilder.Append("{"); 
    //jsonBuilder.Append(dt.TableName.ToString());  
    jsonBuilder.Append("[");//转换成多个model的形式
    for (int i = 0; i < dt.Rows.Count; i++)
    {
        jsonBuilder.Append("{");
        for (int j = 0; j < dt.Columns.Count; j++)
        {
            jsonBuilder.Append("\"");
            jsonBuilder.Append(dt.Columns[j].ColumnName);
            jsonBuilder.Append("\":\"");
            jsonBuilder.Append(dt.Rows[i][j].ToString());
            jsonBuilder.Append("\",");
        }
        jsonBuilder.Remove(jsonBuilder.Length - 1, 1);
        jsonBuilder.Append("},");
    }
    jsonBuilder.Remove(jsonBuilder.Length - 1, 1);
    jsonBuilder.Append("]");
    //  jsonBuilder.Append("}");
    return jsonBuilder.ToString();
}

单个对象转JSON

public static T Json2Obj<T>(string json) 
{
    T obj = Activator.CreateInstance<T>();
    using (System.IO.MemoryStream ms = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(json)))
    {
        System.Runtime.Serialization.Json.DataContractJsonSerializer serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(obj.GetType());
        return (T)serializer.ReadObject(ms);
    }
}

将函数封装成类,更便于项目中引用:

 public class JsonHelper
    {
        /// <summary>
        /// 生成Json格式
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string GetJson<T>(T obj)
        {
            DataContractJsonSerializer json = new DataContractJsonSerializer(obj.GetType());
            using (MemoryStream stream = new MemoryStream())
            {
                json.WriteObject(stream, obj);
                string szJson = Encoding.UTF8.GetString(stream.ToArray()); 
                return szJson;
            }
        }
        /// <summary>
        /// 获取Json的Model
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="szJson"></param>
        /// <returns></returns>
        public static T ParseFromJson<T>(string szJson)
        {
            T obj = Activator.CreateInstance<T>();
            using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(szJson)))
            {
                DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
                return (T)serializer.ReadObject(ms);
            }
        }
    }
 /// <summary>
        /// 反回JSON数据到前台
        /// </summary>
        /// <param name="dt">数据表</param>
        /// <returns>JSON字符串</returns>
        public string DataTableToJson(DataTable dt)
        {
            StringBuilder JsonString = new StringBuilder();
            if (dt != null && dt.Rows.Count > 0)
            {
                JsonString.Append("{ ");
                JsonString.Append("\"TableInfo\":[ ");
                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    JsonString.Append("{ ");
                    for (int j = 0; j < dt.Columns.Count; j++)
                    {
                        if (j < dt.Columns.Count - 1)
                        {
                            JsonString.Append("\"" + dt.Columns[j].ColumnName.ToString() + "\":" + "\"" + dt.Rows[i][j].ToString() + "\",");
                        }
                        else if (j == dt.Columns.Count - 1)
                        {
                            JsonString.Append("\"" + dt.Columns[j].ColumnName.ToString() + "\":" + "\"" + dt.Rows[i][j].ToString() + "\"");
                        }
                    }
                    if (i == dt.Rows.Count - 1)
                    {
                        JsonString.Append("} ");
                    }
                    else
                    {
                        JsonString.Append("}, ");
                    }
                }
                JsonString.Append("]}");
                return JsonString.ToString();
            }
            else
            {
                return null;
            }
        }

表的转化Json类:
public static class JsonTableHelper
    {
        /// <summary> 
        /// 返回对象序列化 
        /// </summary> 
        /// <param name="obj">源对象</param> 
        /// <returns>json数据</returns> 
        public static string ToJson(this object obj)
        {
            JavaScriptSerializer serialize = new JavaScriptSerializer();
            return serialize.Serialize(obj);
        }

        /// <summary> 
        /// 控制深度 
        /// </summary> 
        /// <param name="obj">源对象</param> 
        /// <param name="recursionDepth">深度</param> 
        /// <returns>json数据</returns> 
        public static string ToJson(this object obj, int recursionDepth)
        {
            JavaScriptSerializer serialize = new JavaScriptSerializer();
            serialize.RecursionLimit = recursionDepth;
            return serialize.Serialize(obj);
        }

        /// <summary> 
        /// DataTable转为json 
        /// </summary> 
        /// <param name="dt">DataTable</param> 
        /// <returns>json数据</returns> 
        public static string ToJson(DataTable dt)
        {
            Dictionary<string, object> dic = new Dictionary<string, object>();

            int index = 0;
            foreach (DataRow dr in dt.Rows)
            {
                Dictionary<string, object> result = new Dictionary<string, object>();

                foreach (DataColumn dc in dt.Columns)
                {
                    result.Add(dc.ColumnName, dr[dc].ToString());
                }
                dic.Add(index.ToString(), result);
                index++;
            }
            return ToJson(dic);
        }
    }

在Asp.net中前后台Json数据的传递

一、前台产生Json数据传递给后台处理

前台生成Json数据要使用javascript和json.js。

json.js 下载地址:http://www.json.org/json.js


前台代码:

            var people = [{ "UserName": "t1", "PassWord": "111111", "Sex": "男" },{ "UserName": "t2", "PassWord": "222222", "Sex": "女" }];
            var url = "Default.aspx?

people=" + escape(people.toJSONString()); request.open("POST", url, true); request.onreadystatechange = updatePage; request.send(null);


后台处理代码:

同上面的转化原理一样,我们先建立一个json数据类,便于List<>中使用。

[DataContract]//序列化
public class TestObj
{
    [DataMember]
    public string UserName { get; set; }
     [DataMember]
    public string PassWord { get; set; }
     [DataMember]
    public string Sex { get; set; }


public TestObj(string u,string p,string s)
	{
        UserName = u;
        PassWord = p;
        Sex = s;
	}
}

对前台提交的Json数据相互转化函数

//json 序列化

    public static string ToJsJson(object item)
    {
        DataContractJsonSerializer serializer = new DataContractJsonSerializer(item.GetType());
        using(MemoryStream ms=new MemoryStream())
        {
            serializer.WriteObject(ms, item);
            StringBuilder sb = new StringBuilder();
            sb.Append(Encoding.UTF8.GetString(ms.ToArray()));
            return sb.ToString();
        }
    }

    //反序列化

    public static T FromJsonTo<T>(string jsonString)
    {
        DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
        using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString)))
        {
            T jsonObject = (T)ser.ReadObject(ms);
            return jsonObject;
        }
    }

在后台代码中调用以上函数进行对数据people的处理:

 //获取json字符串
        string jsonStr = Request["people"];
        List<TestObj> obj = Json.FromJsonTo<List<TestObj>>(jsonStr);
        foreach (TestObj item in obj)
            {
         Response.Write(string.Format("UserName:{0}。Password:{1},Sex:{2}/r/n", item.UserName, item.PassWord, item.Sex));
            }
        Response.End();

终于的结果:

        List<TestObj> Users = new List<TestObj>();
        Users.Add(new TestObj("t1", "1", "男"));
        Users.Add(new TestObj("t2", "2", "女"));
        string json = Json.ToJsJson(Users);
        Response.Write(json);
        Response.End();

二、前台获取后台提交的Json数据

后台产生Json数据的方法如上原理中提到的:

 string Json;
       DataContractJsonSerializer json = new DataContractJsonSerializer(list.GetType());
                using (MemoryStream stream = new MemoryStream())
                {
                    json.WriteObject(stream, list);
                     Json = Encoding.UTF8.GetString(stream.ToArray());
                    
                }
        return Json;   
  /// <summary>
    /// Json的数据结构
    /// </summary>
    [DataContract]
    class ResultJson
    {
        [DataMember]
        public bool Result;
        [DataMember]
        public int Count;
        [DataMember]
        public string Message;
    }

前台获取后台返回的Json字符串:

  function updatePage() {
            if (request.readyState == 4) {
                if (request.status == 200) {
                    var response = request.responseText;
                    //转化成对象
                    //方法1
                        response = response.parseJSON();
                    //方法2
                    // response = eval("(" + response + ")");
                    //对象訪问方式
                    document.getElementById("d1").innerHTML = response[1].Sex;
                    //直接输出
                   // document.getElementById("d1").innerHTML = response;
                }
            }
        }

复杂的Json字符串操作方法:

假如我们要转化的JSON字符串格式为:

{
    "encoding":"UTF-8",
    "plug-ins":["python","c++","ruby"],
    "indent":{
        "length":3,
        "use_space":true
    }
}
然后编写对应的序列化的类,注意以下Indent类加的属性:
[DataContract]
class Config
{
    [DataMember(Order = 0)]
    public string encoding { get; set; }
    [DataMember(Order = 1)]
    public string[] plugins { get; set; }
    [DataMember(Order = 2)]
    public Indent indent { get; set; }
}

[DataContract]
class Indent
{
    [DataMember(Order = 0)]
    public int length { get; set; }
    [DataMember(Order = 1)]
    public bool use_space { get; set; }
}

输出JSON字符串


var config = new Config(){
                         encoding = "UTF-8",
                         plugins = new string[]{"python", "C++", "C#"},
                         indent = new Indent(){ length = 4, use_space = false}
                         };
var serializer = new DataContractJsonSerializer(typeof(Config));
var stream = new MemoryStream();
serializer.Write










































以上是关于C#中list<>定义的变量,我用foreach()循环查找 与 list<> .find 查找两个哪个效率高?后者是不是用了算法的主要内容,如果未能解决你的问题,请参考以下文章

c#中泛型集合怎样写强制类弄转换

C#中如何用for循环遍历List<类>?

在字典的列表中添加变量(Dictionary<Key,List<var>)unity C#

c++在模板类中使用list问题

如何在 C# 循环中捕获局部变量?

C#中怎样将List&lt;自己定义&gt;转为Json格式 及相关函数-DataContractJsonSerializer