.NET/C# 高级开发（一） 泛型

最新推荐文章于 2023-12-15 13:02:39 发布
最新推荐文章于 2023-12-15 13:02:39 发布
阅读量326 收藏 1
点赞数 1
分类专栏： .NET/C# 高级开发 文章标签： 泛型 泛型方法 泛型委托 泛型接口 泛型缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45102787/article/details/92815697
版权

.NET/C# 高级开发（一） 泛型

泛型入门：泛型方法，泛型类，泛型接口，泛型委托

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

namespace 泛型
{
    
    class Program
    {
        static void Main(string[] args)
        {

        }
        //泛型方法:参数作为泛型的方法
        //服务于不同类型的共同需求的方法
        public void 泛型方法_a<T>(T t)
        {

        }
        //泛型方法:参数作为泛型的方法
        //多泛型参数的方法，不可以用关键字
        //不建议使用类名，变量名，方法名
        public void 泛型方法_b<T,B,C>(T t)
        {

        }
        //泛型方法:返回值作为泛型的方法
        //object可以强转成泛型
        public T 泛型方法_c<T>(object t)
        {
            return (T)t;
        }
        //泛型方法:返回值作为泛型的方法
        //T t = default(T);//空的泛型变量，不可以用null
        public T 泛型方法_d<T>()
        {
            T t = default(T);
            return t;
        }
    }
    //泛型类:将服务于不同类型的共同需求集合起来
    public class 泛型类<T>
    {

    }
    //泛型接口:服务于不同类型的共同需求的接口
    public interface 泛型接口<T>
    {

    }
    //泛型委托:服务于不同类型的共同需求的委托
    public delegate void 泛型委托<T>();
}

泛型使用：延迟声明

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

namespace 泛型
{
    
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("************************声明不同类型变量方便演示**************************");
            int iValue = 123;
            string sValue = "456";
            DateTime dValue = DateTime.Now;
            object oValue = "789";

            Console.WriteLine("************************ShowObject**************************");
            //利用Object的基类特性传入参数，
            //会产生两个问题：
            //1.装箱拆箱，性能损耗
            //  传入一个INT值（栈）
            //  （装箱） object是在堆里面的引用类型，如果把INT传递进来，会把值从栈里面Copy到堆里面
            //  （拆箱） 使用的时候需要用到对象值，又会从堆把值Copy到栈
            //2.类型安全
            //  传入的对象没有限制
            //  如果传入的类型超出它的使用类型就会出问题
            ShowObject(iValue);
            ShowObject(sValue);
            ShowObject(dValue);
            ShowObject(oValue);
            Console.WriteLine("************************ShowT**************************");
            //泛型方法使用时要指明参数类型，
            //编译器根据传入的参数类型自动推算泛型类型，这被我们成为语法糖，语法糖是编译器提供的便捷功能的代称
            //如果指明的类型参数和传入的参数类型不符，编译不会通过
            //编译阶段用占位符代替，是在运行阶段才确定的类型
            //这类做法使用了延迟声明的设计思想，推迟一切可以推迟的
            ShowT<int>(iValue);
            ShowT(sValue);
            ShowT(dValue);
            ShowT(oValue);
            Console.ReadKey();
        }
        static void ShowObject(object oParameter)//普通方法
        {
            Console.WriteLine($"传入的参数类型{oParameter.GetType().FullName},类型的值={tParameter}");
        }
        /// <summary>
        /// 泛型方法：方法名称后面加上尖括号，里面是一个可以代指任何类型的代号
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        static void ShowT<T>(T tParameter)
        {
            Console.WriteLine($"传入的参数类型={tParameter.GetType().FullName},类型的值={tParameter}");
        }
    }
}

泛型扩展：泛型约束

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

namespace 泛型
{

    class Program
    {
        static void Main(string[] args)
        {
            people peo = new people()
            {
                Id = 123,
                Name = "人",
            };
            Chinese chi = new Chinese()
            {
                Id = 234,
                Name = "中国人",
            };
            Hubei hub = new Hubei()
            {
                Id = 345,
                Name = "湖北人",
            };
            Japanese Jap = new Japanese()
            {
                Id = 456,
                Name = "日本人",
            };
            Show(peo);
            Show(chi);
            Show(hub);
            Show(Jap);
            Console.ReadKey();
        }
        public static void Show<T>(T t)
            //where T : new     //无参数构造函数，没有带参数构造函数
            //where T : struct    //值类型约束，当返回类型为泛型时可以用关键字default(T);会根据T的类型获得一个默认的值
            //where T : class    //引用类型约束

            //where T : ISports    //接口约束
            //where T : people     //基类约束
            where T : people, ISports0, ISports1, new()  //可以被一个基类/父类，多个接口同时约束,
            //约束可以叠加但是有些不可以一起使用，因为没有意义
        {
            Console.WriteLine($"This is {typeof(Program)},t={t.GetType().Name},type={t}");
            Console.WriteLine($"{t.Id}  {t.Name}");
            //return default(T);
        }
        public static void Show<T,S>(T t)
            where T : people, ISports0, ISports1, new()
            where S : new ()   //多个泛型可以直接约束
            //where T : people, ISports0, ISports1, new()
            //where S : T
            //如果两个泛型约束相同可以这样写
        {
            Console.WriteLine($"This is {typeof(Program)},t={t.GetType().Name},type={t}");
            Console.WriteLine($"{t.Id}  {t.Name}");
            //return default(T);
        }
    }
    public class ShowClass_0<T> where T : ISports0
    {
        //泛型类约束
    }
    public class ShowClass_1<T,S> where T : ISports0 where S:ISports1
    {
        //多泛型参数的泛型类约束
    }
    public class people_0<T, S> : ShowClass_0<T>, ISports2<S>
        where T:ISports0
        where S:class
    {
        //使用了带有约束的父类或接口时，如果没有指明泛型类型，需要指明同父类或接口相同的约束
    }
    public class people_1<T, S> : ShowClass_0<Japanese>, ISports2<string>
    {
        //使用了带有约束的父类或接口时，如果指明了泛型类型，需要指明同父类或接口相同约束的类型
    }


    public interface ISports0
    {
        
    }
    public interface ISports1
    {

    }
    public interface ISports2<S>
        where S : class
    {

    }
    public class people: ISports0,ISports1
    {
        public int Id;
        public string Name;
    }
    public class Chinese : people { }
    public class Hubei : people { }
    public class Japanese : people { }
}

泛型扩展：泛型缓存

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

namespace 泛型
{
    
    class Program
    {
        static void Main(string[] args)
        {
            //每个不同的T都会生成一份不同的副本
            //适合不同类型都需要缓存一份自身数据的场景，效率高
            for (int i=0;i<5;i++)
            {
                Console.WriteLine(GenericCache<int>.GetCache());
                Thread.Sleep(10);
                Console.WriteLine(GenericCache<long>.GetCache());
                Thread.Sleep(10);
                Console.WriteLine(GenericCache<DateTime>.GetCache());
                Thread.Sleep(10);
                Console.WriteLine(GenericCache<string>.GetCache());
                Thread.Sleep(10);
                Console.WriteLine(GenericCache<Program>.GetCache());
                Thread.Sleep(10);
            }
        }
    }
    //字典缓存，静态属性常驻内存，把传入类型作为键
    //示例
    public class DictionaryCache
    {
        private static Dictionary<Type, string> _TypeTimeDictionary = null;
        static DictionaryCache()
        {
            Console.WriteLine("静态构造函数，全局只执行一次");
            _TypeTimeDictionary = new Dictionary<Type, string>();//创建静态字典
        }
        public static string GetCache<T>()
        {
            Type type = typeof(T);
            if (!_TypeTimeDictionary.ContainsKey(type))//是否不包含当前键
            {
                _TypeTimeDictionary[type] = string.Format("{0}_{1}",typeof(T).FullName,DateTime.Now.ToString("yyyyMMddHHmmss.fff"));
            }
            return _TypeTimeDictionary[type];
        }
    }
    //静态缓存，把传入类型作为键
    //示例
    public class GenericCache<T>
    {
        private static string _TypeTime = "";
        static GenericCache()
        {
            Console.WriteLine("静态构造函数，全局只执行一次");
            _TypeTime = string.Format("{0}_{1}", typeof(T).FullName, DateTime.Now.ToString("yyyyMMddHHmmss.fff"));
        }
        public static string GetCache()
        {
            return _TypeTime;
        }
    }
    
}

泛型扩展：协变逆变

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


namespace 泛型
{

    class Program
    {
        static void Main(string[] args)
        {
            //-------------------------------------------------------------------------------------------
            //Bird bir_ = new Sparrow();//麻雀一定是一只鸟
            //Sparrow spa = new Bird();//鸟不一定是一只麻雀，也有可能是其他鸟
            //-------------------------------------------------------------------------------------------
            //List<Bird> bir = new List<Bird>();
            //List<Bird> bir1 = new List<Sparrow>();
            //List集合不可以用子类实例化父类，因为编译器会编译成完全不同的两个类，也不存在父子关系
            //-------------------------------------------------------------------------------------------
            ///协变
            {
                //-------------------------------------------------------------------------------------------
                //协变：
                //      可以让我们用子类实例化父类
                //      协变的泛型参数只能作为返回结果，不能作为参数
                //个人理解：
                //      子类不包含父类，故子类实例父类不够完整
                //      如果作为参数以父类的方式操作子类会造成不可预料的后果
                //      因为操作的类型也可能是父类自身类型
                //      所以只能作为返回结果
                OutList<Bird> bir_0 = new OutList_<Bird>();
                bir_0.Get();
                OutList<Bird> bir_1 = new OutList_<Sparrow>();
                bir_1.Get();
                //      在协变中父类不可以实例化子类
                //OutList<Sparrow> bir_2 = new OutList_<Bird>();
                //-------------------------------------------------------------------------------------------
            }
            ///逆变
            {
                //-------------------------------------------------------------------------------------------
                //逆变：
                //      可以让我们用父类实例化子类
                //      逆变的泛型参数只能作为参数，不能作为返回结果
                //个人理解：
                //      父类包含子类，故父类拥有子类的完全属性
                //      如果作为返回类型的话编译器识别不出当前泛型的具体类型
                //      所以只能作为参数传递
                InList<Sparrow> spa_0 = new InList_<Sparrow>();
                spa_0.Show(new Sparrow());
                InList<Sparrow> spa_1 = new InList_<Bird>();
                spa_1.Show(new Sparrow());
                //      在逆变中子类不可以实例化父类
                //InList<Bird> spa_2 = new InList_<Sparrow>();
                //-------------------------------------------------------------------------------------------
            }
            ///协变+逆变
            {
                //-------------------------------------------------------------------------------------------
                InOutList<Sparrow, Bird> ino_0 = new InOutList_<Sparrow, Bird>();
                //协变，第二个泛型参数定义了out，所以可以子类实例化父类
                InOutList<Sparrow, Bird> ino_1 = new InOutList_<Sparrow, Sparrow>();
                //逆变，第一个泛型参数定义了in，所以可以父类实例化子类
                InOutList<Sparrow, Bird> ino_2 = new InOutList_<Bird, Bird>();
                //协变+逆变
                InOutList<Sparrow, Bird> ino_3 = new InOutList_<Bird, Sparrow>();
                //-------------------------------------------------------------------------------------------
            }
        }
    }
    public interface InOutList<in Tin,out Tout>
    {

        void Show(Tin tin);
        Tout Get();
        Tout Do(Tin tin);
    }
    public class InOutList_<Tin, Tout> : InOutList<Tin, Tout>
    {
        public Tout Do(Tin tin)
        {
            return default(Tout);
        }

        public Tout Get()
        {
            return default(Tout);
        }

        public void Show(Tin tin)
        {
        }
    }
    public  interface OutList<out T>
    {
        //泛型参数带有out的称为协变，out只有在泛型和委托中才有协变的概念
        T Get();
    }
    public class OutList_<T> : OutList<T>
    {
        //泛型接口的实现，注意泛型参数不能写错和漏写
        public T Get()
        {
            //根据传递的参数返回默认值
            return default(T);
        }
    }
    public  interface InList<in T>
    {
        //泛型参数带有in的称为逆变，in只有在泛型和委托中才有逆变的概念
        void Show(T t);
    }
    public class InList_<T> : InList<T>
    {
        //泛型接口的实现，注意泛型参数不能写错和漏写
        public void Show(T t)
        {
            //不做任何操作，只是为了演示
        }
    }
    public class Bird
    {
        public int id { get; set; }
    }
    public class Sparrow : Bird
    {
        public string Name { get; set; }
    }
}
__Unique
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
.NET/C# 英文面试题［附答案］汇总 1
03-02
.NET/C# 是一种广泛使用的软件开发平台，由微软公司推出，用于构建各种应用程序，包括桌面应用、Web应用、移动应用和服务。C# 是.NET 平台上的一种面向对象的编程语言，具有现代编程语言的特性，如强类型、垃圾回收...
.net/C#软件工程师面试题目汇总
11-10
- 高级特性：泛型、匿名方法、Lambda表达式、LINQ、委托、事件、属性、构造器、析构函数。 - C# 6及以上版本的新特性：async/await、null条件操作符、异步流、属性初始化器等。 3. **.NET框架** - 应用程序域...
C#高级教程
学习之路，创业之光
05-06 1929
语法上没有任何错误，只不过在运行过程由于某些原因出现了问题。转义符\n：换行（苹果系统或者控制台）\t：制表\b：删除前面的字符（注意：放在字符串的两端没有效果\r\n：换行（win系统）\：表示一个\可以这样用@"F:\fjld\fd\a\q.txt"取消在字符串中的转义作用在声明变量的最前面加const属性的作用就是保护字段、对字段的赋值和取值进行限定。属性的本质就是两个方法，一个叫get()一个叫set()。1.抽象成员必须标记为abstract,并且不能有任何实现。
C#高级--特性详解
热门推荐
李宥的博客
08-02 1万+
C#高级–特性详解 一、什么是特性 1、特性定义 **特性（Attribute）**是用于在运行时传递程序中各种元素（比如类、方法、结构、枚举、组件等）的行为信息的声明性标签。您可以通过使用特性向程序添加声明性信息。一个声明性标签是通过放置在它所应用的元素前面的方括号（[ ]）来描述的。 特性（Attribute）用于添加元数据，如编译器指令和注释、描述、方法、类等其他信息。.Net 框架提供了两种类型的特性：预定义特性和自定义特性。 2、特性的语法 特性（Attribute）的名称和值是在方括号内规定的，
C# 学习（三）高级能力
RikkaTheWorld
06-24 659
Obsolete声明自定义特性构建自定义特性在目标程序元素上应用自定义特性通过反射访问特性这里使用到反射的知识，本节先不讲解，将会在下节讲述一个新的自定义特性需要继承true我构建了一个名为DebugInfobug 的代号编码辨认该 bug 的开发人员名字最后一次CR 该代码的日期一个存储了开发人员标记的字符串消息我们的DebugInfo类有三个用于存储前三个信息的私有属性，和一个存储消息的公共属性。所以前三个是必须的定位（positional。
.Net 泛型总结
Coding Home
09-02 4051
一、泛型概念 泛型是C# 2.0和CLR的一个特性，在1.0时代，声明一个可以给多个类型参数共同使用的方法很繁杂，需要编写多个方法而参数不同，当然可以使用object，但通过object会发生装箱拆箱，降低性能。而泛型为.Net引入了类型参数的概念，使得声明类和方法时不必指定具体的类型参数，其具体类型可以延迟到客户代码当中实现。 二、如何声明和使用泛型 声明...
C#高级--常用数据结构
李宥的博客
09-02 8600
C#高级–常用数据结构 零、文章目录 一、常见的数据结构 1、集合[Set] 2、线性结构 3、树形结构 4、图形结构 二、Array/ArrayList/List 内存上连续存储，节约空间，可以索引访问，读取快，增删慢 1、Array 元素类型是一样的，定长 int[] list = new int[3]; list[0] = 123; string[] stringArray = new string[] { "123", "234" }; for (int i = 0; i < list.Le
VS.NET C# WinForm实践开发教程 .rar
09-17
在本教程中，我们将深入探讨如何使用Visual Studio .NET（VS.NET）集成开发环境（IDE）和C#编程语言进行Windows Forms（WinForm）应用程序的开发。Windows Forms是.NET Framework的一部分，提供了一种构建桌面应用的...
微软官网下载pdf版本2023《.net C#》开发指南中文版
09-20
总的来说，《.NET C#》开发指南中文版是一个全面的学习资料，涵盖了C#语言的基础到高级特性，以及与.NET平台的集成使用。无论是初学者还是有经验的开发者，都能从中受益，提升自己的C#编程技能。
c#实现对泛型数组排序
12-26
在C#编程中，泛型是一种强大的特性，它允许我们...在ASP.NET和.NET框架中，这些特性与其他高级功能（如LINQ）相结合，极大地提高了开发效率和代码质量。理解并熟练运用这些概念，对于任何C#开发者来说都是至关重要的。
C#（二） C#高级进阶
Hello World!
08-14 8079
C# 中的委托（Delegate）类似于 C 或 C++ 中的函数指针，是一种引用类型，表示对具有特定参数列表和返回值类型的。简单来说，委托是一种方法的代理/中介，委托指向某个方法来实现具体的功能。委托是方法的抽象，它存储的就是一系列具有相同参数和返回值类型的方法的地址。委托的使用包括定义声明委托、实例化委托以及调用委托三个阶段，在实例化委托时，必须将委托的实例与具有相同返回值类型以及参数列表的方法相关联，这样就可以通过委托来调用方法。另外，使用委托还可以将方法作为参数传递给其他方法.........
2023最新高级难度C#面试题,包含答案。刷题必备！记录一下。
最新发布
m0_62946064的博客
12-15 2955
装箱和拆箱是C#中的一个重要概念，它涉及到值类型和引用类型之间的转换。装箱是指将值类型的数据转换为其对应的引用类型的过程。在这个过程中，会在托管堆上分配一块内存用来存储值类型的实例，并返回一个指向这块内存的新对象引用。// 这里发生了装箱操作拆箱则是将引用类型的数据还原为其原始值类型的过程。在这个过程中，会检查对象引用是否真的指向一个有效且正确的值类型实例，然后将其内容复制到新的值类型变量中去。// 这里发生了拆箱操作装箱和拆箱会对程序的性能产生一定的影响。
C#之高级进阶
10-25
从急速入门到面向对象，课程是否为你打开了新世界的大门呢，C# 高级课程来了，各种高阶知识点，干货噻到爆。开启你的大神之路吧，同学~ C#语言系列课程分为一下几个部分：1.C#急速入门        https://edu.csdn.net/course/detail/205892.C#之面向对象https://edu.csdn.net/course/detail/266413.C#高级进阶（本课程）4.程序员内功修炼 - 数据结构(C#)https://edu.csdn.net/course/detail/10505
c#学习
u011655372的专栏
08-10 747
简介 C#读作C Sharp。最初它有个更酷的名字，叫做COOL。微软从1998年12月开始了COOL项目，直到2000年2月，COOL被正式更名为C#。在1998年，Delphi语言的设计者Hejlsberg带领着Microsoft公司的开发团队，开始了第一个版本C#语言的设计。在2000年9月，国际信息和通信系统标准化组织为C#语言定义了一个Microsoft公司建议的标准。最终C#语言在2
.Net泛型详解
孤行者程序之路的博客
06-08 1379
/这是一个泛型类//这是一个泛型方法//这是一个泛型委托//这是一个泛型接口通过观察以上简略的定义我们可以发现如下规律：1：类型参数不只是可以为T，也可以为其他字符或者字符串，因为只是一个占位符而已，叫什么名字不重要。2：一个泛型的类型参数可以不止一个，可以有，两个、三个甚至更多。而一个泛型的类型参数的个数我们称之为“元数”。以上案例中的GenericMethod显然是一个二元泛型方法。
C#高级教程（一）
吴小花的博客
02-11 6213
C# 结构体（Struct） 定义结构体 为了定义一个结构体，您必须使用 struct 语句。struct 语句为程序定义了一个带有多个成员的新的数据类型。 例如，您可以按照如下的方式声明 Book 结构： struct Books { public string title; public string author; public string subject; ...
.NET 中的泛型 101
weixin_30642869的博客
06-11 61
1.1.1 摘要 图1 C# 泛型介绍 在接触泛型之前，我们编程一般都是使用具体类型（char, int, string等）或自定义类型来定义我们变量，如果我们有一个功能很强的接口，而且我们想把它提取或重构成一个通用的接口，使得该接口不仅仅适用于已定义数据类型，而是适用于更多数据类型，从而方便以后的扩展。 泛型提供上述功能的实现，泛型其实就是提供一个数据类...
C#之高级篇
m0_55337678的博客
03-02 569
高级部分C#，持续更新中
C#开发Android实战指南：使用MonoforAndroid和.NET/C#
1. **C#语言基础**：C#是一种面向对象的编程语言，具有类型安全和垃圾回收机制，支持泛型、委托、匿名方法、LINQ等高级特性。在开发Android应用时，C#的这些特性可以提高代码的可读性和可维护性。 2. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值