精华内容
下载资源
问答
  • c#泛型类
    2019-05-28 08:02:42

    泛型类实例化的理论
    C#泛型类在编译时,先生成中间的代码IL,通常类型T只是一个占位符。在实例化类时,根据用户指定的数据类型代替T并由即时编译器(JIT)生成本地代码,这个本地代码中已经使用了实际的数据类型,等同于用实际类型写的类,所以不同的封闭类的本地代码是不一样的。按照这个原理,我们可以这样认为:
    泛型类的不同的封闭类是分割不同的数据类型。
    例:Stack和Stack是两个完全没有任何关系的类,你可以把他看成类A和类B,这个解释对泛型类的静态成员的理解有很大帮助。
    泛型中的静态成员变量
    在C#1.x中,我们知道类的静态成员变量在不同的类实例间是共享的,并且他是通过类名访问的。C#2.0中由于引进了泛型,导致静态成员变量的机制出现了一些变化:静态成员变量在相同封闭类间共享,不同的封闭类间不共享。
    这也非常容易理解,因为不同的封闭类虽然有相同的类名称,但由于分别传入了不同的数据类型,他们是完全不同的类,比如:
    Stack a = new Stack();
    Stack b = new Stack();
    Stack c = new Stack();
    类实例a和b是同一类型,他们之间共享静态成员变量,但类实例c却是和a、b完全不同的类型,所以不能和a、b共享静态成员变量。
    泛型中的静态构造函数
    静态构造函数的规则:只能有一个,且不能有参数,他只能被.NET运行时自动调用,而不能人工调用。
    泛型中的静态构造函数的原理和非泛型类是一样的,只需把泛型中的不同的封闭类理解为不同的类即可。以下两种情况可激发静态的构造函数:

    1.   特定的封闭类第一次被实例化。
      
    2.   特定封闭类中任一静态成员变量被调用。
      

    泛型的优点
    针对早期版本的通用语言运行时和C#语言的局限,泛型提供了一个解决方案。以前类型的泛化(generalization)是靠类型与全局基类System.Object的相互转换来实现。.NET框架基础类库的ArrayList容器类,就是这种局限的一个例子。ArrayList是一个很方便的容器类,使用中无需更改就可以存储任何引用类型或值类型。
    //The .NET Framework 1.1 way of creating a list
    ArrayList list1 = new ArrayList();
    list1.Add(3);
    list1.Add(105);
    //…
    ArrayList list2 = new ArrayList();
    list2.Add(“It is raining in Redmond.”);
    list2.Add(“It is snowing in the mountains.”);
    但是这种便利是有代价的,这需要把任何一个加入ArrayList的引用类型或值类型都隐式地向上转换成System.Object。如果这些元素是值类型,那么当加入到列表中时,它们必须被装箱;当重新取回它们时,要拆箱。类型转换和装箱、拆箱的操作都降低了性能;在必须迭代(iterate)大容器的情况下,装箱和拆箱的影响可能十分显著。
    泛型的使用范围
    泛型类和泛型方法兼复用性、类型安全和高效率于一身,是与之对应的非泛型的类和方法所不及。泛型广泛用于容器(collections)和对容器操作的方法中。.NET框架2.0的类库提供一个新的命名空间System.Collections.Generic,其中包含了一些新的基于泛型的容器类。要查找新的泛型容器类(collection classes)的示例代码,请参见基础类库中的泛型。当然,你也可以创建自己的泛型类和方法,以提供你自己的泛化的方案和设计模式,这是类型安全且高效的。下面的示例代码以一个简单的泛型链表类作为示范。(多数情况下,推荐使用由.NET框架类库提供的List类,而不是创建自己的表。)类型参数T在多处使用,具体类型通常在这些地方来指明表中元素的类型。类型参数T有以下几种用法:
    l 在AddHead方法中,作为方法参数的类型。
    l 在公共方法GetNext中,以及嵌套类Node的 Data属性中作为返回值的类型。
    l 在嵌套类中,作为私有成员data的类型。

    注意一点,T对嵌套的类Node也是有效的。当用一个具体类来实现MyList时——如MyList——每个出现过的T都要用int代替。

    using System;
    using System.Collections.Generic;

    public class MyList //type parameter T in angle brackets
    {
    private Node head;
    // The nested type is also generic on T.
    private class Node
    {
    private Node next;
    //T as private member data type:
    private T data;
    //T used in non-generic constructor:
    public Node(T t)
    {
    next = null;
    data = t;
    }
    public Node Next
    {
    get { return next; }
    set { next = value; }
    }
    //T as return type of property:
    public T Data
    {
    get { return data; }
    set { data = value; }
    }
    }
    public MyList()
    {
    head = null;
    }
    //T as method parameter type:
    public void AddHead(T t)
    {
    Node n = new Node(t);
    n.Next = head;
    head = n;
    }

        public IEnumerator<T> GetEnumerator()
        {
            Node current = head;
    
            while (current != null)
            {
                yield return current.Data;
                current = current.Next;
            }
        }
    }
    

    实际上,泛型还可以用在类方法、接口、结构(struct)、委托等上面使用,使用方法大致相同,就不再讲述。

    更多相关内容
  • 泛型类、泛型方法、泛型接口、泛型委托 泛型类、泛型方法、泛型接口、泛型委托
  • c# 泛型类

    2021-12-07 13:18:41
    1、创建泛型类 使用<T> 来表示泛型类类型。 不能把null赋值为泛型类型。 泛型赋值:使用default关键字。default会把引用类型使用null赋值,把值类型使用0赋值 Public class Document<T> { public...

    1、创建泛型类

    使用<T> 来表示泛型类类型。

    不能把null赋值为泛型类型。

    泛型赋值:使用default关键字。default会把引用类型使用null赋值,把值类型使用0赋值

    Public class Document<T>
    {
    
        public T getDoc()
        {
            T doc = default;
            
            //其他代码
            return doc;
        }
    }

    2、泛型范围,即泛型的使用范围约束 where T 范围

    // T 必须是Docment及其子类的类型
    public class DOC<T> where T:Docment
    {
        public void getAllDocs()
        {
            foreach(T doc in listObject)
            {
                Console.WriteLine(doc.title);
            }
        }
        
    } 

    3、基本范围:

     

    4、泛型类继承:

            继承父类必须是泛型类,并且继承的泛型类类型要保持一致,或者是父类的子类。

    class LinkedList<T>:IEnumber<T>
    {
    }
    
    class Devide<T>:Base<string>
    {
    
    }
    
    
    interface IComparation<T>
    {
    
    }

    展开全文
  • c#泛型类、泛型方法、泛型接口、泛型委托
  • C# 泛型类(函数)的实例化小例子,需要的朋友可以参考一下
  • 3):给泛型类 加类型(引用类型,值类型)的约束:where T:class,new ( )遇到的问题:在写MongodbHelper类的时候,为了能处理多种类别,所以如下定义了该类: 代码如下: public class MongodbHelper { 。...
  • C#泛型类

    千次阅读 2020-02-01 15:59:45
    一、泛型类的简介 所谓的泛型就是不知道具体的类型的一种通用表达。泛型和概念和C++中的模板,LabVIEW中的变体略有相似。用泛型定义的类具有多态的作用。 泛型的出现目的在于解决能应用在不同数据类型上的共有代码...

    一、泛型类的简介

    所谓的泛型就是不知道具体的类型的一种通用表达。泛型和概念和C++中的模板,LabVIEW中的变体略有相似。用泛型定义的类具有多态的作用。
    泛型的出现目的在于解决能应用在不同数据类型上的共有代码。

    示例如下:

    class Program
    {
        public class Static<T>           //定义的泛型类
        {
            int pos;
            T[] data =new T[100];        //定义泛型数组
            public void Push(T obj)      //入栈操作
            {
                data[pos++] = obj;
            }
    
            public T Pop(T obj)          //出栈操作
            {
                return data[--pos];
            }
        }
        static void Main(string[] args)
        {
            var stack = new Stack<int>();
            //也可写成:Stack<int> stack=new Stack<int>();
            stack.Push(5);
            stack.Push(10);
            int x = stack.Pop();   //x=5
            int y = stack.Pop();   //y=10
            Console.WriteLine("{0},{1}",x,y);  //输出10,5
            Console.ReadKey();
        }
    

    如上,泛型类的定义中,Static中的T就是就是一个占位符。他表示整个类中的所有涉及到的T是一种暂时不知道类型的占位符。在使用中指定T的类型即可。就像var stack=new Stack<int>();一样,他会指定int为T的具体类型。

    如上所示的:
    Stack<T> 称之为开放类型
    Stack<int> 称之为封闭类型
    在运行时,所有的泛型类型的实例都被封闭了,也就是说所有T的占位符全部被填充了。

    所以总结上面的代码,最终在运行时,Stack类最终会变成

    public class 类名   //这里的类型为系统定义的默认名称。
    {
    	int pos;
    	int[] data=new int[100];
    	public void Push(int obj)
    	{
    		data[pos++]=obj;
    	}
    	public int Pop()
    	{
    		return data[--pos];
    	}
    }
    

    二、泛型为什么会出现

    上述我们可知,泛型的出现目的就是为了解决能针对不同类型的共用代码。如果仅仅是为了共用代码的话,其实还可以通过object类来进行操作。如下:

    class Program
    {
        public class ObjectStack  //定义的泛型类
        {
            int pos=0;
            object[] data =new object[100];        //泛型数组
            public void Push(object obj)      //入栈操作
            {
                data[pos++] = obj;
            }
    
            public object Pop()          //出栈操作
            {
                return data[--pos];
            }
        }
        static void Main(string[] args)
        {
            ObjectStack stack = new ObjectStack();
            //也可写成:Stack<int> stack = new Stack<int>();
            stack.Push(5);
            stack.Push(10);
            int x = Convert.ToInt32(stack.Pop());   //x=5
            int y = Convert.ToInt32(stack.Pop());   //y=10
            Console.WriteLine("{0},{1}",x,y);
    
            Console.ReadKey();
        }
    

    上述代码的结果与一种一样。

    那么既然用Object也能实现同样的目的,为什么还要引出泛型类型呢。

    我们知道,Object是个基类。操作中的10和5是个数值,想要将10和5转换成类的Object的话,一定会有装箱操作,反之需要拆箱操作。正因为装箱和拆箱的效率问题,才导致我们最好使用泛型而不是用Object类。
    另外,在转换中无法进行检查,导致隐含风险。
    例如:
    stack.Push(“s”);编译不会出错,因为"s"也能装箱为Object
    int i=(int)satck.Pop(); //运行出错,因为“s”拆箱后转换成int语法错误。

    综上所述:
    泛型是延迟声明的:即定义的时候没有指定具体的参数类型,把参数类型的声明推迟到了调用的时候才指定参数类型。 延迟思想在程序架构设计的时候很受欢迎。例如:分布式缓存队列、EF的延迟加载等等。

    此外,泛型的效率一般比较高。具体详情请参考:
    C#泛型的效率对比(ArrayList和List<T>)

    展开全文
  • 详解c# 泛型类的功能

    2020-12-16 21:37:08
    泛型类中,由于不知道泛型参数T是什么类型,可能是引用类型,也可能是值类型,因此不能将null等赋予泛型类型。如何对泛型对象赋初值、如何保证泛型的正确性等,以使用泛型文档管理器为例:  文档管理器用于从队列...
  • 浅谈c# 泛型类的应用

    2021-01-01 06:02:25
    泛型类泛型类封装不是特定于具体数据类型的操作。 泛型类最常用于集合,如链接列表、哈希表、堆栈、队列、树等。 像从集合中添加和移除项这样的操作都以大体上相同的方式执行,与所存储数据的类型无关。对大多集合类...
  • 主要介绍了C#泛型的类型参数约束的相关资料,文中讲解非常细致,帮助大家更好的理解和学习c#,感兴趣的朋友可以了解下
  • 泛型类: using System; namespace ThreadDemo { class Program { static void Main(string[] args) { MyStack<int> myStack = new MyStack<int>(3); myStack.Push(1); myStack.Push(2);

    泛型类:

    using System;
    
    namespace ThreadDemo
    {
        class Program
        {
    
            static void Main(string[] args)
            {
                MyStack<int> myStack = new MyStack<int>(3);
                myStack.Push(1);
                myStack.Push(2);
                myStack.Push(3);
                myStack.Push(4);
    
                MyStack<string> myStack1 = new MyStack<string>(5);
                myStack1.Push("张三");
            }
        }
    
        public class MyStack<T>
        {
            private T[] _stack;//栈数组
            private int _stackPoint;//当前位置
            private int _size;//栈的容量
    
            /// <summary>
            /// 初始化
            /// </summary>
            public MyStack(int size)
            {
                _size = size;
                _stack = new T[size];
                _stackPoint = 0;
            }
    
            /// <summary>
            /// 入栈方法
            /// </summary>
            /// <param name="item"></param>
            public void Push(T item)
            {
                if (_stackPoint >= _size)
                {
                    Console.WriteLine("栈已满,无法继续入栈");
                }
                else
                {
                    _stack[_stackPoint] = item;
                    _stackPoint++;
                }
    
                foreach (var s in _stack)
                {
                    Console.WriteLine(s);
                }
                Console.WriteLine("---------------------------");
            }
    
        }
    
    }
    

    执行结果:

    上面实例模拟数据入栈的操作。使用泛型可以让不同类型的数据公用一个类处理。实现代码的复用。

     

     泛型方法:

    using System;
    
    namespace ThreadDemo
    {
        class Program
        {
            /// <summary>
            /// 两个参数交换值
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="left"></param>
            /// <param name="right"></param>
            static void Swip<T>(ref T left, ref T right)
            {
                T temp;
                temp = left;
                left = right;
                right = temp;
            }
    
            static void Main(string[] args)
            {
                int a = 1;
                int b = 2;
                Swip<int>(ref a, ref b);
    
                string s1 = "张三";
                string s2 = "李四";
                Swip<string>(ref s1, ref s2);
    
                Console.WriteLine("a={0},b={1}", a, b);
                Console.WriteLine("s1={0},s2={1}", s1, s2);
    
            }
        }
    
    
    
    }
    

    执行结果:

    可以看到a,b  s1,s2 的值都进行了交换。

    这里的泛型方法就起到了可以为不同类型的数据进行数值交换,而不需要对各种类型单独定义方法。

    这里用到了ref关键字,可以参考https://blog.csdn.net/m0_37679113/article/details/83045813

     

     

    展开全文
  • C#泛型类约束

    2019-07-17 11:14:47
    Public class Demo where T:class,new(){…}:class表明T必须是一个,而不是一个structure结构,new()表明T必须含有一个无参数....NET 含有一下五种泛型约束: where T:class 丨T必须是一个 where T:struct ...
  • C#泛型类和泛型方法

    2019-10-21 20:16:46
    泛型可以理解为广泛的类型,或者不确定的...泛型类 泛型类是指这个类的某些字段的类型是不确定的,只有在构造的时候才能确定下的类。 泛型类示例 class Program { static void Main(string[] args) { MyClass&l...
  • c#泛型类的基本使用

    2019-10-11 16:17:12
    * 常见的泛型:泛型类和泛型方法 * 后续深入:泛型委托(自定义泛型委托、常见的泛型委托Func、Action) * * 泛型类的规范:public class 类名<T>{类的成员...} * T:仅仅是一个占位符,只要符合C#的命名...
  • 泛型类: 定义一个泛型类就是指的是,定义一个类,这个类中某些字段的类型是不确定的,这些类型可以在类构造的时候确定下来 举例: 创建一个类处理int类型和double类型的相加 class QQ&lt;T,A&gt;//T代表一...
  • C#泛型_泛型类

    2022-02-22 23:09:33
    } } 2、当我们利用泛型类构造的时候,需要指定泛型的类型 class Program { static void Main(string[] args) { //var o1 = new ClassA(12,34);//当我们利用泛型类构造的时候,需要制定泛型的类型 //string s = o1....
  • C#泛型类的定义及使用

    千次阅读 2019-10-17 12:01:38
    C#语言中泛型类的定义与泛型方法类似,是在泛型类的名称后面加上<T>,当然,也可以定义多个类型,即“<T1,T2,・・・>”。 具体的定义形式如下。 class 类名<T1,T2,…> { //类的成员 } 这样,...
  • C# 泛型类、泛型函数

    2020-03-01 18:55:14
    泛型方法是使用类型参数声明的方法,如下所示: C# static void Swap(ref T lhs, ref T rhs) {   T temp;   temp = lhs;   lhs = rhs;   rhs = temp; } 下面的代码示例演示一种使用 int 作为...
  • 本文实例为大家分享了C#泛型类创建与使用的具体代码,供大家参考,具体内容如下 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication13 { ...
  • C# 泛型类(多类型)

    千次阅读 2019-02-14 10:47:21
    using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Examples { class Holder&...//声明泛型T,万能数据类型 { T[...
  • C#泛型类与泛型方法总结

    千次阅读 2020-06-11 11:21:11
    前言:本博文从C#泛型入手,依次介绍泛型类和泛型方法,如果读者想对泛型有更多的了解,可访问本人另一篇博文:C#中List泛型用法,必知必会! 文章目录一、泛型是什么?二、泛型类的定义三、泛型方法定义 一、泛型是...
  • C#泛型类定义和泛型方法定义

    千次阅读 2018-11-24 01:45:00
    泛型类定义 定义一个泛型类就是指的是,定义一个类,这个类中某些字段的类型是不确定的,这些类型可以在类构造的时候确定下来,举例: class ClassA&amp;lt;T&amp;gt;{ private T a; private T b; public ...
  • //非泛型类集合的命名空间。 //非泛型类的集合 不固定数据类型 using System.Collections.Generic;//泛型类集合的命名空间。 &lt;1&gt;非泛型类的集合和泛型类的集合的区别 前者是不固定数据类型 ,后者...
  • C#泛型类访问子类成员

    千次阅读 2017-12-02 13:28:20
    有两个,一个父类一个子类。解决的问题是要在实例化之后可以访问子类成员。 父类: public class Student { public string school; } 子类: public class College:Student { public int age; public Co
  • 闲来无事,自己研究了泛型类的简单的使用,where表示泛型约束,表示泛型类型中的参数只能是car类型,IEnumerable是一个接口,一个集合要支持FOREAch遍历,必须实现IEnumerable接口 代码如下:public class Car { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,011
精华内容 23,604
关键字:

c#泛型类

友情链接: 纸牌游戏代码.rar