C#——泛型入门

最新推荐文章于 2024-04-28 20:19:05 发布
最新推荐文章于 2024-04-28 20:19:05 发布
阅读量691 收藏 8
点赞数 7
分类专栏： C# 文章标签： c# 开发语言 .net 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41810413/article/details/128218828
版权

        在C#中，泛型无处不在，因为它可以避免成员膨胀或者类型膨胀，又因为其具有良好的正交性继而产生了泛型类型（类/接口/委托/...）和泛型成员（属性/方法/字段/...），泛型也可以做到类型方法的参数推断，我们会通过例子一一了解

类型膨胀 和 成员膨胀

先来看看什么是类型膨胀
请按照注释顺序查看代码：
 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _16.泛型_partial类_枚举_结构
{
internal class Program
    {
        
        static void Main(string[] args)
        {
            //1.2 卖苹果
            Apple apple = new Apple();
            apple.Color = "red";

            AppleBox box = new AppleBox()
            {
                Cargo = apple
            };//这是两种属性赋值方式
            Console.WriteLine(box.Cargo.Color);


            Book book = new Book() { Name = "New Book"};
            BookBox bookBox = new BookBox(){ Cargo = book };
            Console.WriteLine(bookBox.Cargo.Name);

            //1.5 目前为止看着没什么问题是吧，实际上已经出问题了，叫做类型膨胀，目前我就两种商品，还需要创建两种盒子，那以后商品越来越多，盒子也得越来越多，就造成了类型膨胀


            Console.ReadKey();

        }
    }

    //1. 假设我是一个苹果商，准备在圣诞卖苹果
    class Apple
    {
        public string Color { get; set; }
    }

    //1.3 因为我圣诞赚了一笔我决定顺手再卖点书
    class Book
    {
        public string Name { get; set; }
    }


    //1.1 为了更贵点我要准备一个好看的盒子把苹果装起来
    class AppleBox
    {
        //我这个盒子的用途非常明确，就是为了装苹果，所以可以给他准备一个苹果类型的属性Cargo表示我的货物
        public Apple Cargo { get; set; }
    }

    //1.4 我也得把书包装一下卖的更贵
    class BookBox
    {
        public Book Cargo { get; set; }
    }
}

再来看看什么是成员膨胀
 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _16.泛型_partial类_枚举_结构
{
internal class Program
    {

        static void Main(string[] args)
        {
            Apple apple = new Apple() { Color = "red" };
            Book book = new Book() { Name = "New Book" };

            Box box1 = new Box()
            { Apple = apple };//在这里 book属性是闲置得
            Box box2 = new Box()
            { Book = book };//在这里 apple属性是闲置得
            //这就产生了第二个问题，成员膨胀，如果有一千个商品就会有一千个属性，那么同时就会有999个属性闲置


            Console.ReadKey();

        }
    }

    class Apple
    {
        public string Color { get; set; }
    }

    class Book
    {
        public string Name { get; set; }
    }

    //1. 那我们试一下用一个Box来装所有的东西
    class Box
    {
        public Apple Apple { get; set; }
        public Book Book { get; set; }
        //......
    }
}

泛型类 

来看看怎么用泛型解决上面的问题
注意按照注释顺序查看：
 


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _16.泛型_partial类_枚举_结构
{
internal class Program
    {

        static void Main(string[] args)
        {
            Apple apple = new Apple() { Color = "red" };
            Book book = new Book() { Name = "New Book" };

            //1.2 注意！所有泛型实体都不能直接拿来编程，使用前要对其进行特化，如下操作
            Box<Apple> box1 = new Box<Apple>() { Cargo = apple };       //1.3 这里先把一个泛型Box特化成一个装苹果的Box，相当于我们用Apple类型替换了我们的TCargo类型，所以原来Box中的Cargo属性的类型也就变成了apple类型

            //1.4 我们再特化一个类型
            Box<Book> box2 = new Box<Book>() { Cargo = book };

            //1.5 此处注意！我们的泛型类在经过特化之后，里面凡是使用到类型参数的地方，都是强类型的
            //Console.WriteLine(box1.Cargo.);  1.6 在Cargo后面打.的时候就能清楚看到Color的属性

            Console.WriteLine(box1.Cargo.Color);
            Console.WriteLine(box2.Cargo.Name);


            Console.ReadKey();

        }
    }

    class Apple
    {
        public string Color { get; set; }
    }

    class Book
    {
        public string Name { get; set; }
    }

    //1. 首先把Box类改成泛型类，方法就是在类名后面加一对尖括号，写在这对尖括号里面的内容叫做类型参数,类型参数一定是类名！！！！！
    //这个类型参数其实就是一个标识符，这个标识符代表一个泛化的类型，比如我喜欢听音乐，这个音乐就是一个泛指
    class Box<TCargo>//这里代表类型是一个商品类型
    {
        //属性的声明也会发生改变
        public TCargo Cargo { get; set; }

        //1.1 现在我们回到Main函数中使用它
    }
}

泛型接口

再来看看泛型接口如何使用
同样是按照注释顺序查看：
 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _16.泛型_partial类_枚举_结构
{

internal class Program
    {

        static void Main(string[] args)
        {
            //1,4 现在来使用一下,比如在我的系统中我希望学生的ID是一个整数
            //Student<int> stu = new Student<int>();
            //stu.ID = 101;//1.5 现在把鼠标放在ID上会发现它变成了int属性，神不神奇？？!!
            //stu.Name = "DiaoMao";

            //1.6 因为我学校人越来越多，整数类型已经不够用了，我现在想换成无符号长整型作为学生id
            Student<ulong> stu = new Student<ulong>();//所以我们再特化一次
            stu.ID = 10000000000000001;
            stu.Name = "ShaDiao";

            //1.7 以上是踏出泛型学习的第一步

            Console.ReadKey();

        }
    }

    //1. 声明一个接口IUnique，我怎么保证对象的唯一呢，就需要这个对象有ID这个属性，那这个属性是什么类型我不确定，所以我要把这个接口改成泛型接口
    //interface IUnique
    interface IUnique<TId>//1.1 类型参数给一个T就可以，但是如果你怕别人不知道这个T是ID属性类型的话，可以写成TId，表示这个类型是为了声明ID这个属性的
    {
        //public TId ID { get; set; } 注意接口里不能有public ，因为他默认全是public
        TId ID { get; set; }
    }

    //1.2 创建一个学生类，学生是有ID的，但是注意，如果一个类继承了泛型接口，那么这个类也必须变成泛型的
    class Student<TId> : IUnique<TId>//Alt + Enter自动实现接口
    {
        public TId ID { get; set; }//1.3 删除多余的代码，并注意，Student<TId>的TId这个类型参数只会影响到这一行的TId属性，不会影响其他的

        public string Name { get; set; }//这里不受TId影响

    }
}

        这个例子在声明Student类的时候，我们实现了泛型接口IUnique，然后Student这个类就自然而然地变成了泛型类，但是还有一种实现泛型接口的方法，就是当我们实现泛型接口的时候，我们实现的是一个特化之后的泛型接口，这个时候我们的类就不是泛型类了

来看看这种情况：
 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _16.泛型_partial类_枚举_结构
{

 internal class Program
    {

        static void Main(string[] args)
        {
            Student student = new Student();
            student.ID = 1000000000000000001;
            student.Name = "ShaDiao";

            //1.3 这就是泛型接口的第二种情况，我们在使用一个类实现这个泛型接口的时候，我们在实现这个接口的时候，就把这个接口特化了，此时类实现的就是一个特化以后的泛型接口

            Console.ReadKey();

        }
    }

    //1. 上个例子在声明Student类的时候，我们实现了泛型接口IUnique，然后Student这个类就自然而然地变成了泛型类
    //但是还有一种实现泛型接口的方法，就是当我们实现泛型接口的时候，我们实现的是一个特化之后的泛型接口，这个时候我们的类就不是泛型类了
    interface IUnique<TId>
    {
        TId ID { get; set; }
    }
    //1.1 如果我确定以后学生的id都是无符号长整型，那我就不用TId了，直接在实现接口的时候给他特化
    class Student : IUnique<ulong>//1.2 在继承接口的时候就特化，此时类就不需要用泛型
    {
        public ulong ID { get; set; } //这行需要删掉重新实现，就会从Tid类型变成ulong类型
        public string Name { get; set; }
    }
}

        在我们.Net Framework框架中，几乎常用的数据结构都是泛型的，我们平时处理的数据大部分都存储在各种各样的集合中，比如数组、链表、列表、字典等等这些集合或者说这些数据结构都是泛型的，而且他们的基接口和基类也都是泛型的，泛型的集合或者泛型的数据结构以及他们的泛型基接口基类都集中在这个命名空间里：using System.Collections.Generic;

常见的泛型结构——List(动态数组)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _16.泛型_partial类_枚举_结构
{
    internal class Program
    {

        static void Main(string[] args)
        {
            IList<int> list = new List<int>();//1. List背后其实维护者一个数组，我们可以不停的往里面放东西，当我们放的东西太多了，超过其存储能力后，他会生成一个更长的空间,然后把旧的数组复制过来继续存储
            //1.1 数组的长度不能改变，但是我们的List和ArrayList可以
            for (int i = 0; i < 100; i++)
            {
                list.Add(i);
            }
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
            //1.2 这个就是带有一个类型参数的IList泛型接口，和带有一个类型参数的list泛型类
            //1.3 我们把鼠标点击在List上按F12可以查看定义，在定义的最前面显式List继承了一系列基接口，包括IEnumerab，这代表他可以被迭代；还有ICollection基接口，代表List也是一个集合，可以向集合添加和移除元素

            Console.ReadKey();
        }
    }
}

 

双类型参数的泛型——IDictionary（字典）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _16.泛型_partial类_枚举_结构
{
    internal class Program
    {

        static void Main(string[] args)
        {
            IDictionary<int, string> dict = new Dictionary<int, string>();//1. IDictionary被特化成了以int类型为Key，string类型为Value的类型
            //1.1 由多态可知：dict是一个接口类型的变量，引用了一个Dictionary类型的实例
            //1.2 注意这里IDictionary是接口，Dictionary是一个类，后者继承了前者;而且现在两者都被特化了，所以1.1的引用是没有问题的
            dict[1] = "tim";
            dict[2] = "tom";
            Console.WriteLine($"Student #1 is {dict[1]}");
            Console.WriteLine($"Student #2 is {dict[2]}");
            //1.3 以上就是给大家展示一下带有不止一个类型参数的泛型接口和泛型类
            Console.ReadKey();
        }
    }
}

 泛型算法以及类型推断

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _16.泛型_partial类_枚举_结构
{
internal class Program
    {

        static void Main(string[] args)
        {
            int[] a1 = { 1, 2, 3, 4, 5 };
            int[] a2 = { 1, 2, 3, 4, 5, 6 };
            double[] a3 = { 1.1, 2.2, 3.3, 4.4, 5.5 };
            double[] a4 = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 };
            //int[] result = Zip(a1, a2);//输出为1，1，2，2，3，3，4，4，5，5，6

            //1.那么我想对a3,a4进行一样的操作可以吗，答案是不行
            //double[] result = Zip(a3, a4);//这里会警告你参数无法从double转换成int

            //1.3 那么现在更完蛋了，因为出现了更麻烦的方法膨胀，接下来我们尝试把数组改成泛型的

            //1.6 此时两种类型的数组都可以使用一个方法了，这就是泛型方法的特点，我们只需要写一个方法，就可以在不同的类型之间反复特化以及调用，就不会出现成员膨胀和逻辑重复的问题

            double[] result = Zip(a3, a4);//1.7 此时应该注意Zip并没有特化，也就是没有写成Zip<T>(a3, a4)的形式，这是为什么？
            //1.8 因为当你传进去a1,a2或者a3,a4的时候，编译器可以判断出这是整型数组还是double数组，然后编译器就能推断出来这个<T>是什么类型的，就不用显示的去写
            //double[] result = Zip<double>(a3, a4); 1.9 这行代码是等效于double[] result = Zip(a3, a4);的

            //2. 以上就是泛型方法在调用的时候的类型自动推断

            Console.WriteLine(string.Join(",", result));//串联集合的成员，并且在每个成员之间使用指定的分隔符


            Console.ReadKey();
        }


        //1.1 一个解决方法就是把下面所有的int数组改成double的
        static int[] Zip(int[] a, int[] b)
        {
            int[] zipped = new int[a.Length + b.Length];
            int ai = 0, bi = 0, zi = 0;
            do
            {
                if (ai < a.Length)
                {
                    zipped[zi++] = a[ai++];
                }
                if (bi < b.Length)
                {
                    zipped[zi++] = b[bi++];
                }
            } while (ai < a.Length || bi < b.Length);

            return zipped;

        }

        //1.2 改成这样上面的就可以正常输出了
        static double[] Zip(double[] a, double[] b)
        {
            double[] zipped = new double[a.Length + b.Length];
            int ai = 0, bi = 0, zi = 0;
            do
            {
                if (ai < a.Length)
                {
                    zipped[zi++] = a[ai++];
                }
                if (bi < b.Length)
                {
                    zipped[zi++] = b[bi++];
                }
            } while (ai < a.Length || bi < b.Length);

            return zipped;

        }

        //1.4 Ctrl + H替换所有的int[]数组为T[]，此时报警找不到T的来源
        static T[] Zip<T>(T[] a, T[] b)//1.5 只需要在方法后面加上：<T>即可，现在这个方法就变成了一个泛型方法
        {
            T[] zipped = new T[a.Length + b.Length];
            int ai = 0, bi = 0, zi = 0;
            do
            {
                if (ai < a.Length)
                {
                    zipped[zi++] = a[ai++];
                }
                if (bi < b.Length)
                {
                    zipped[zi++] = b[bi++];
                }
            } while (ai < a.Length || bi < b.Length);

            return zipped;

        }
    }
}

泛型委托——Action

        .Net Framework为我们准备了很多泛型委托，他们经常会和Lambda表达式一起使用来构成Linq查询，泛型委托最常用的就是Function和Action这两种

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _16.泛型_partial类_枚举_结构
{
internal class Program
    {

        static void Main(string[] args)
        {
            //1. 接下来我们用泛型委托Action调用下面两个参数类型完全不同的方法

            Action<string> a1 = Say;
            a1.Invoke("tim");
            Action<int> a2 = Mul;
            a2.Invoke(1);

            //1.1 注意Action委托是间接调用，而且只能调用没有返回值的方法

            Console.ReadKey();
        }

        static void Say(string str)
        {
            Console.WriteLine($"Hello {str}!");
        }

        static void Mul(int x)
        {
            Console.WriteLine(x * 100);
        }

    }
}

 泛型委托——Function

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _16.泛型_partial类_枚举_结构
{

    internal class Program
    {

        static void Main(string[] args)
        {
            Func<int, int, int> f1 = Add;//前两个int 是参数类型以及参数个数，最后一个int是返回值类型
            Console.WriteLine(f1.Invoke(3, 6));

            Func<double, double, double> f2 = Add;
            Console.WriteLine(f2(2.4, 4.1));

            //以上就是Function的泛型委托

            Console.ReadKey();
        }

        static int Add(int a, int b)
        {
            return a + b;
        }

        static double Add(double a, double b)
        {
            return a + b;
        }

    }
}

 泛型委托与Lambda表达式

        Lambda表达式：对于一些逻辑非常简单的方法，我懒得声明他，而是在调用的地方随调用而声明，而且是匿名的声明比如：Function<double,double,double> func1 = (double a,double b) => {return a+b;};,因为Function里面说明了参数类型是double可以简化为：Function<double,double,double> func1 = (a,b) => {return a+b;} 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _16.泛型_partial类_枚举_结构
{

internal class Program
    {
        /*
            Lambda表达式：对于一些逻辑非常简单的方法，我懒得声明他，而是在调用的地方随调用而声明，而且是匿名的声明
        比如：Function<double,double,double> func1 = (double a,double b) => {return a+b;};,因为Function里面说明了参数类型是double
        可以简化为：Function<double,double,double> func1 = (a,b) => {return a+b;}
        */

        static void Main(string[] args)
        {
            Func<double, double, double> func1 = (a, b) => { return a + b; };
            var result = func1(100.1, 100.2);
            Console.WriteLine(result);
            Console.ReadKey();
        }
    }
}

 

沿江路小佩奇
关注
  • 7
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#泛型
Jun5203
06-02 174
泛型 官方：延迟编写类或方法中的编程元素的数据类型，直到实际在程序中使用它。 个人理解：泛型就是一个可以与任何数据类型一起工作的类或方法。换句话说，就是用同一个方法来处理多个方法中功能相似但传入不同的数据类型 为什么使用泛型？ 先说不用泛型，下面来举一个例子 public class CommonMethod { public static void ShowInt(int i) ...
C#中的泛型
AuraroTeen的博客
04-18 4772
编写程序时，经常遇到两个模块的功能非常相似，区别只是一个是处理int数据，另一个是处理string数据，或者其他自定义的数据类型，我们只能分别写多个方法处理每个数据类型，因为方法的参数类型不同。ArrayList不是类型安全的，使用时很可能出现类型不匹配的错误，就算都插入了同一类型的数据，使用时我们也需要将它们转化为对应的原类型来处理。泛型类的定义与泛型方法类似，是在泛型类的名称后面加上<T>，当然,也可以定义多个类型，即“<T1,T2,・・・>“ArrayList 存储在装箱和拆箱操作，导致其性能低下。
C#泛型的理解
qq_57767445的博客
11-08 2138
泛型的概念 定义：泛型允许我们延迟编写类或方法中的编程元素的数据类型的规范，直到实际在程 序中使用它的时候。（也就是说泛型是可以与任何数据类型一起工作的类或方法）模块内高 内聚，模块间低耦合。 泛型的使用：当我们的类/方法不需要关注调用者传递的实体是什么(公共基类工具 类)，这个时候就可以使用泛型。 注意： 集合中的项允许是 object 型的值，因此可以存放任意类型的值，无法确保存入集合中 的值都是同一类型，而导致在处理时发生异常。 可空类型 对于引用类型的变量来说，如果未对其赋值，在默认情况下
C# 中泛型编程之泛型类、泛型方法、泛型约束详解
最新发布
u011555996的博客
04-28 1222
类型Type现在可以表示带有特定类型的实参(或绑定类型)或未指定类型的泛型(或称未绑定类型)。委托级别的约束只在声明委托变量和实例化委托时使用，类似于在类型和方法的作用范围中实施的其他任何约束。同时子类中的泛型方法不能重复基类泛型方法的约束，这一点和泛型类中的虚方法重写是有区别的，代码如下。////错误 重写和显式接口实现方法的约束是从基方法继承的，因此不能直接指定这些约束。类型参数必须具有无参数的公共构造函数。3.在子类重复基类的约束(在使用子类泛型参数时,必须在子类级别重复在基类级别规定的任何约束)
C#高级--泛型详解
李宥的博客
07-26 8997
C#高级–泛型详解 一、泛型是什么？ 泛型是C#2.0推出的新语法，不是语法糖，而是2.0由框架升级提供的功能。 我们在编程程序时，经常会遇到功能非常相似的模块，只是它们处理的数据不一样。但我们没有办法，只能分别写多个方法来处理不同的数据类型。这个时候，那么问题来了，有没有一种办法，用同一个方法来处理传入不同种类型参数的办法呢？泛型的出现就是专门来解决这个问题的。 使用泛型是一种增强程序功能的技术，具体表现在以下几个方面： 它有助于您最大限度地重用代码、保护类型的安全以及提高性能。 您可以创建泛型集合类。
C# 泛型概念及用法详解
u011555996的博客
05-05 8949
泛型(generic)是C# 2.0推出的新语法，它是专门为处理多段代码在不同的数据类型上执行相同的指令的情况而设计的。比如说编程时，碰到功能非常相似的模块，只是它们所处理的数据类型不同，然而我们却需要写不同的方法来实现它，很明显，这加大了我们的工作量，也很乏味。有没有什么办法能够解决这个问题呢？它就是泛型了，可以让多个类型共享一组代码。通过压栈例子可以更清楚的了解泛型{int[] arr;//将int类型的值压栈//将float类型的值压栈。
C# 泛型详解(泛型类，方法，接口，委托，约束，反射 )
热门推荐
熊思雨的博客
09-01 1万+
泛型(Generic)，是将不确定的类型预先定义下来的一种C#高级语法，我们在使用一个类，接口或者方法前，不知道用户将来传什么类型，或者我们写的类，接口或方法相同的代码可以服务不同的类型，就可以定义为泛型。这会大大简化我们的代码结构，同时让后期维护变得容易。...............
C#入门——面向对象等，代码+注释
12-10
第10天 03_List泛型集合 04_Dictionary 05泛型集合练习 06文件流 FileStream 07StreamReader和StreamWriter 02 file类 01 path类。File.ReadAllBytes 第11天 02 抽象类 Animal Cat Dog Program 02-抽象类 Animal ...
C#6.0学习笔记——从第一行C#代码到第一个项目设计(第二个包)
06-06
在本书最后一章，专门设计了综合实例——“综合实例1： 照片面积计算机器”和“综合实例2： 文件加密与解密工具”，通过这两个综合实例，既可以将前20章的知识融会贯通，又可以抛砖引玉，真正教会读者开发Ｃ＃应用...
C#6.0学习笔记——从第一行C#代码到第一个项目设计(第一个包)
06-06
在本书最后一章，专门设计了综合实例——“综合实例1： 照片面积计算机器”和“综合实例2： 文件加密与解密工具”，通过这两个综合实例，既可以将前20章的知识融会贯通，又可以抛砖引玉，真正教会读者开发Ｃ＃应用...
轻松学C#(图解版)
04-27
第1章 C#入门 2 1.1 C#概述 2 1.1.1 C#的发展 2 1.1.2 C#开发的基础 2 1.2 搭建开发环境 3 1.2.1 Visual Studio 2012软硬件配置要求 3 1.2.2 下载Visual Studio 2012 3 1.2.3 安装Visual Studio 2012 4 1.2.4 初始化...
CLR.via.C#.(中文第3版)(自制详细书签)
12-27
24.1 序列化/反序列化快速入门 24.2 使类型可序列化 24.3 控制序列化和反序列化 24.4 格式化器如何序列化类型实例 24.5 控制序列化/反序列化的数据 24.5.1 如何在基类没有实现ISerializable的前提下定义一个...
C# 泛型详解
这个人好有趣....hh
02-23 3789
1、泛型概述 2、定义泛型 3、泛型的特性 4、泛型委托 5、泛型的优点
C# 泛型
LiKe11807的博客
10-22 9029
为什么要有泛型： 我们在编写程序时，经常遇到两个模块的功能非常相似，只是一个是处理int数据，另一个是处string数据，或者其他自定义的数据类型，但我们没有办法，只能分别写多个方法处理每个数据类型，因为方法的参数类型不同。 你可能会想到用object，来解决这个问题。但是，缺陷的： 1.会出现装箱、折箱操作，这将在托管堆上分配和回收大量的变量，若数据量大，则性能损失非常严重。 2.在处理引用类型时，虽然没有装箱和折箱操作，但将用到数据类型的强制转换操作，增加处理器的负担。 介绍泛型： C.
C#基础篇——泛型
03-30 2394
前言 在开发编程中，我们经常会遇到功能非常相似的功能模块，只是他们的处理的数据不一样，所以我们会分别采用多个方法来处理不同的数据类型。但是这个时候，我们就会想一个问题，有没有办法实现利用同一个方法来传递不同种类型的参数呢？ 这个时候，泛型也就因运而生，专门来解决这个问题的。 泛型是在C#2.0就推出的一个新语法，由框架升级提供的功能。 说明 泛型通过参数化类型实现在同一份代码上操作多种数据类型。例如使用泛型的类型参数T,定义一个类Stack， 可以用Stack、Stack或者Stack实例化它，从而使类S.
【C#进阶】C# 泛型
好学若饥，谦卑若愚。
03-27 1807
🎫 hello大家好啊，我是哈桑c，本文为大家介绍 C# 中的泛型。正确地使用泛型可以提高代码的可读性、重用性以及灵活性，可以在一定程度上提高程序的性能。错误或者过度地使用泛型容易导致类型异常、使代码变得复杂（可读性变低）以及很难确定参数真正的类型等问题。除了文中提到泛型的用法之外，还可以创建自定义的泛型数组、泛型事件以及泛型和反射的结合等。
C# 委托泛型
05-27
C# 委托泛型（Generic Delegate）是一种泛型类型，它可以封装一个或多个泛型方法。与非泛型委托不同，泛型委托可以接受任何类型的方法作为参数，而不需要进行类型转换或强制转换。 泛型委托的语法格式如下： ```...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值