当前位置： 移动技术网 > IT编程>开发语言>c# > 数据类型和特殊类型-C#

数据类型和特殊类型-C#

2019年09月21日  | 移动技术网IT编程  | 我要评论

参考地址：

1、集合set：纯粹的数据集合

2、线性结构：一对一的，数组

3、树形结构：一对多的，菜单/文件夹/类别/属性控件/表达式目录树

4、图形/网状结构：多对多，地图应用比较多，网站的应用比较少

 

线性结构：

array/arraylist/list/linkedlist/queue/stack/hastset/sortedset/hashtable/sortedlist/dictionary/sorteddictionary

ienumerable、icollection、ilist、iqueryable

接口是标机功能的，不同的接口岔开，就是为了接口隔离；虽然我们接口内容也可以复用。

ienumerable任何数据集合，都实现了的，为不同的数据结构，提供了统一数据访问方式，这个就是迭代器模式。

1、内存连续存储，节约空间，可以索引访问，读取速度快，增删慢

　　array：在内存上连续分配的，而且元素类型是一样的。

 int[] intarray = new int[3];
 intarray[0] = 123;
 string[] stringarray = new string[] { "123", "234" };//array

　　arraylist：不定长的，连续分配的；元素没有类型限制，任何元素都是当成object处理，如果是值类型，会有装箱操作；读取快，增删慢。

 arraylist arraylist = new arraylist();
 arraylist.add("bingle1");
 arraylist.add("bingle2");
 arraylist.add(32);//add增加长度
 //arraylist[4] = 26;//索引复制，不会增加长度
 //删除数据
 //arraylist.removeat(4);
 var value = arraylist[2];
 arraylist.removeat(0);
 arraylist.remove("bingle2");

　　list<t>：也是array，内存上都是连续拜访的；不定长；泛型，保证类型安全，避免装箱拆箱；读取快，增删慢。

list<int> intlist = new list<int>() { 1, 2, 3, 4 };
intlist.add(123);
intlist.add(123);
//intlist.add("123");
//intlist[0] = 123;
list<string> stringlist = new list<string>();
//stringlist[0] = "123";//异常的
foreach (var item in intlist)
{

}

2、非连续拜访的，存储数据+地址，找书的话就只能顺序查找，读取就比较慢，增删快

　　linkedlist<t>：泛型的特点；链表，元素不连续分配，每个元素都有记录前后节点；节点值可以重复。能不能下标访问？不能的，找元素就只能遍历，查找不方便，增删就比较方便。

 linkedlist<int> linkedlist = new linkedlist<int>();
 //linkedlist[3]
 linkedlist.addfirst(123);
 linkedlist.addlast(456);

 bool iscontain = linkedlist.contains(123);
 linkedlistnode<int> node123 = linkedlist.find(123);  //元素123的位置  从头查找
 linkedlist.addbefore(node123, 123);
 linkedlist.addbefore(node123, 123);
 linkedlist.addafter(node123, 9);

 linkedlist.remove(456);
 linkedlist.remove(node123);
 linkedlist.removefirst();
 linkedlist.removelast();
 linkedlist.clear();

　　queue：就是链表，先进先出，放任务延迟执行，a不断写入日志任务，b不断获取任务去执行

 queue<string> numbers = new queue<string>();
 numbers.enqueue("one");
 numbers.enqueue("two");
 numbers.enqueue("three");
 numbers.enqueue("four");
 numbers.enqueue("four");
 numbers.enqueue("five");

 foreach (string number in numbers)
 {
     console.writeline(number);
 }

 console.writeline($"dequeuing '{numbers.dequeue()}'");
 console.writeline($"peek at next item to dequeue: { numbers.peek()}");
 console.writeline($"dequeuing '{numbers.dequeue()}'");

 queue<string> queuecopy = new queue<string>(numbers.toarray());
 foreach (string number in queuecopy)
 {
     console.writeline(number);
 }

 console.writeline($"queuecopy.contains(\"four\") = {queuecopy.contains("four")}");
 queuecopy.clear();
 console.writeline($"queuecopy.count = {queuecopy.count}");

　　stack：就是链表，先进后出，解析表达式目录树的时候，先产生的数据后使用。操作记录为命令，撤销的时候是倒叙的。

 stack<string> numbers = new stack<string>();
 numbers.push("one");
 numbers.push("two");
 numbers.push("three");
 numbers.push("four");
 numbers.push("five");//放进去

 foreach (string number in numbers)
 {
     console.writeline(number);
 }

 console.writeline($"pop '{numbers.pop()}'");//获取并移除
 console.writeline($"peek at next item to dequeue: { numbers.peek()}");//获取不移除
 console.writeline($"pop '{numbers.pop()}'");

 stack<string> stackcopy = new stack<string>(numbers.toarray());
 foreach (string number in stackcopy)
 {
     console.writeline(number);
 }

 console.writeline($"stackcopy.contains(\"four\") = {stackcopy.contains("four")}");
 stackcopy.clear();
 console.writeline($"stackcopy.count = {stackcopy.count}");

　　队列是没有底的瓶子，栈是有底的瓶子

　　集合：纯粹的集合，容器，东西丢进去，唯一性，无序的。

　　hashset：hash分布，元素间没有关系，动态增加容量，去重的。统计用户ip；ip投票；交叉并补；二次好友/间接关注/粉丝集合

 hashset<string> hashset = new hashset<string>();
 hashset.add("123");
 hashset.add("689");
 hashset.add("456");
 hashset.add("12435");
 hashset.add("12435");
 hashset.add("12435");

hashset<string> hashset1 = new hashset<string>();
 hashset1.add("123");
 hashset1.add("689");
 hashset1.add("789");
 hashset1.add("12435");
 hashset1.add("12435");
 hashset1.add("12435");
 hashset1.symmetricexceptwith(hashset);//补
 hashset1.unionwith(hashset);//并
 hashset1.exceptwith(hashset);//差
 hashset1.intersectwith(hashset);//交

 

　　sortset：排序的集合；去重而且排序；统计排名，每统计一个就丢进去集合

 sortedset<string> sortedset = new sortedset<string>();
 //icomparer<t> comparer  自定义对象要排序，就用这个指定
 sortedset.add("123");
 sortedset.add("689");
 sortedset.add("456");
 sortedset.add("12435");
 sortedset.add("12435");
 sortedset.add("12435"); 

sortedset<string> sortedset1 = new sortedset<string>();
 sortedset1.add("123");
 sortedset1.add("689");
 sortedset1.add("456");
 sortedset1.add("12435");
 sortedset1.add("12435");
 sortedset1.add("12435");
 sortedset1.symmetricexceptwith(sortedset);//补
 sortedset1.unionwith(sortedset);//并
 sortedset1.exceptwith(sortedset);//差
 sortedset1.intersectwith(sortedset);//交

　　读取和增删都快的，有没有？有，hash散列，字典。是key-value，一段连续空间放value（开辟的空间比用到的多，hash使用空间换性能），基于key散列计算得到地址索引，这样读取快，但是没有数组快。增删也快，删除时也是计算位置，增加也不影响别人。代价就是，肯定会出现2个key（散列冲突），散列结果一致，可以让第二次的+1；可能会造成效率的降低，尤其是数据量大的情况下，以前测试dictionary在3w条左右的时候，性能爱是下降的厉害。

　　hashtable---key-value，体积可以动态增加，拿着key计算下一个地址，然后放入key-value；object-装箱茶香，如果不同的key得到相同的地址，第二个在前面地址上+1；查找的时候，如果地址对应数据的key不对，那就+1查找。。

　　浪费了空间，hashtable是基于数组实现；查找个数据，一次定位；增删，一次定位；增删改查都很快，但是浪费空间，数据太多，重复定位定位，效率就下去了。

 hashtable table = new hashtable();
 table.add("123", "456");
 table[234] = 456;
 table[234] = 567;
 table[32] = 4562;
 table[1] = 456;
 table["eleven"] = 456;
 foreach (dictionaryentry objde in table)
 {
     console.writeline(objde.key.tostring());
     console.writeline(objde.value.tostring());
 }
 //线程安全
 hashtable.synchronized(table);//只有一个线程写  多个线程读

字典：泛型；key - value，增删查改 都很快；有序的。但是字段不是线程安全的，concurrentdictionary

 dictionary<int, string> dic = new dictionary<int, string>();
 dic.add(1, "haha");
 dic.add(5, "hoho");
 dic.add(3, "hehe");
 dic.add(2, "hihi");
 dic.add(4, "huhu1");
 dic[4] = "huhu";
 dic.add(4, "huhu");
 foreach (var item in dic)
 {
     console.writeline($"key:{item.key}, value:{item.value}");
 }

我们来看一下list，如下图

 

 list集合为什么会继承这么多接口呢？

　　1、icollection：

　　　　count、isreadonly、add、clear、contains、copyto、clear

　　2、ilist：

　　　　t this[int index] （索引）、indexoof、.....

　　3、ienumerable：

　　　　遍历才会去查询比较，迭代器 yield

　　　　getenumerator：current、movenext、reset

　　　　任何数据集合，都实现了ienumerable，为不同的数据结构提供了统一的数据访问方式，这个就是迭代器模式。

　　4、iqueryable：

　　　　表达式目录树的解析，延迟到遍历的时候才去执行，ef的延迟查询

　　　　iqueryprovider provider{get;}

　　　　

yield是语法糖，编译时由编译器生成iterrator的代码，包括movenext current  reset

　　含有yield的函数说明它是一个生成器，而不是普通的函数。当程序运行到yield这一行时，该函数会返回值，并保存当前域的所有变量状态；等到该函数下一次被调用时，会从上一次中断的地方开始执行，一直遇到下一个yield, 程序返回值, 并在此保存当前状态; 如此反复，直到函数正常执行完成。

　　 迭代器模式是设计模式中行为模式(behavioral pattern)的一个例子，他是一种简化对象间通讯的模式，也是一种非常容易理解和使用的模式。简单来说，迭代器模式使得你能够获取到序列中的所有元素 而不用关心是其类型是array，list，linked list或者是其他什么序列结构。这一点使得能够非常高效的构建数据处理通道(data pipeline)。

　　--即数据能够进入处理通道，进行一系列的变换，或者过滤，然后得到结果。事实上，这正是linq的核心模式。

　　在.net中，迭代器模式被ienumerator和ienumerable及其对应的泛型接口所封装。如果一个类实现了ienumerable接 口，那么就能够被迭代；调用getenumerator方法将返回ienumerator接口的实现，它就是迭代器本身。迭代器类似数据库中的游标，他是 数据序列中的一个位置记录。迭代器只能向前移动，同一数据序列中可以有多个迭代器同时对数据进行操作。

下面是一个yield的一个简单demo：

public class yieldshow
{
    public ienumerable<int> createenumerable()
    {
        try
        {
            console.writeline("{0} createenumerable()方法开始", datetime.now);
            for (int i = 0; i < 5; i++)
            {
                console.writeline("{0}开始 yield {1}", datetime.now, i);
                yield return i;
                console.writeline("{0}yield 结束", datetime.now);
                if (i == 4)
                {
                    yield break;//直接终结迭代  4会出现的，，
                }
            }
            console.writeline("{0} yielding最后一个值", datetime.now);
            yield return -1;
            console.writeline("{0} createenumerable()方法结束", datetime.now);
        }
        finally
        {
            console.writeline("停止迭代！");
        }
    }
 ienumerable<int> iterable = this.createenumerable();//1 不会直接执行
 //ienumerator iterator = iterable.getenumerator();
 ienumerator<int> iterator = iterable.getenumerator();
 console.writeline("开始迭代");
 while (true)
 {
     console.writeline("调用movenext方法……");
     boolean result = iterator.movenext();//2 正式开启createenumerable
     console.writeline("movenext方法返回的{0}", result);
     if (!result)
     {
         break;
     }
     console.writeline("获取当前值……");
     console.writeline("获取到的当前值为{0}", iterator.current);
 }

 

public class yielddemo
{
    public ienumerable<int> power()
    {
        for (int i = 0; i < 10; i++)
        {
            yield return this.get(i);

            //console.writeline("这里再来一次");
            //yield return this.get(i) + 1;
        }
    }

    public ienumerable<int> common()
    {
        list<int> intlist = new list<int>();
        for (int i = 0; i < 10; i++)
        {
            intlist.add(this.get(i));
        }
        return intlist;
    }

    private int get(int num)
    {
        thread.sleep(2000);
        return num * datetime.now.second;
    }
}



 yielddemo yielddemo = new yielddemo();
 foreach (var item in yielddemo.power())
 {
     console.writeline(item);//按需获取，要一个拿一个
     if (item > 100)
         break;
 }
 console.writeline("*******************************************");
 foreach (var item in yielddemo.common())
 {
     console.writeline(item);//先全部获取，然后一起返还
     if (item > 100)
         break;
 }

dynamic关键字：

　　.net framework4.0出现的，让程序有了弱类型的特点；

　　强类型特点：

　　　　编译时完成安全检查

　　弱类型：

　　　　运行时才检查类型

 object a = new yielddemo();
 //a.power();
 type type = a.gettype();
 methodinfo method = type.getmethod("power");
 method.invoke(a, null);

 dynamic da = a;
 da.power();
 //1 代替反射  2 数据绑定方便 3 跟c++交互方便
 //性能比反射高
dynamic str = "abcd";//任何跟dynamic交互，都变成dynamic
console.writeline(str.length);
console.writeline(str.substring(1));

 

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网