C#基础-泛型的声明

        c# 的声明对象或类需要提前声明类型 ，但有声明时并不确定其类型，此时需要引用泛型先声明对象，先将其看做某一类，其对象类型可以视为广泛的类型代表任意数据类型，在后续调用或实现时将类型传入。

泛型一般以一个大写字母表示。可以贯穿整个C#，可以代表任何数据类型。是项目抽象化的一种实现。

目录

声明（定义）：

 在方法中声明泛型：

在类中声明泛型：

在结构体中声明泛型：

在委托声明泛型：

在抽象类中声明泛型：

在静态类中声明泛型：

在接口中声明泛型：

---

声明（定义）：

 在方法中声明泛型：

在方法名后边加上泛型标识，在此方法中可将该泛型当做其他数据类型使用，可以用于返回，传参

或局部变量。在调用该方法时将类型传入即可。

using System;

namespace CCCC
{
    class Program
    {
        static void Main(string[] args)
        {
            Test1 test1 = new Test1();
            test1.A<int>(10);//在调用有泛型定义的方法时，将该泛型所代表的数据类型类型传入，若泛型作为参数 则需传入指定类型的参数   输出：10
            test1.B<bool, string>(false,"7878798");//多重泛型用逗号隔开传入 输出：false 7878798
        }
    }

    public class Test1
    {
        public int _age = 10;
        public void A<T>(T t)//将泛型视为数据类型直接用即可
        {
            Console.WriteLine(t);
        }
        public void B<T, P>(T t, P p)//多泛型使用逗号隔开即可
        {
            Console.WriteLine(t);
            Console.WriteLine(p);
        }
    }
}

在类中声明泛型：

在类名后可加上泛型标识，在该类型中可以使用该泛型做任意类成员。

using System;

namespace CCCC
{
    class Program
    {
        static void Main(string[] args)
        {
           
             Test2<float> test2 = new Test2<float>(1.1f);//创建包含泛型对象时，将泛型代表类型传入实例，并传入指定类型值
             test2.C();//调用test2 方法 输出：1.1
        }
    }

    public class Test2<K>
    {
        K _kVal;//泛型字段
        public K GetKVal { get { return _kVal; } }//泛型属性

        public Test2(K k)//含泛型参数的构造
        {
            _kVal = k;
        }

        public void C()
        {
            Console.WriteLine(_kVal);
        }
    }
}

在结构体中声明泛型：

namespace ConsoleApp4
{
    internal class Program
    {
        static void Main(string[] args)
        {
            MyStruct<int> myStruct = new ConsoleApp4.MyStruct<int>(10);
            Console.WriteLine(myStruct._valT);
        }
    }

    public struct MyStruct<T> where T : struct 
    {
        public T _valT;

        public MyStruct(T t)
        {
            _valT = t;
        }
    }

    public class MyClass<T> where T : struct
    {
    }
}

在委托声明泛型：

using System;

namespace CCCC
{
    class Program
    {
        public delegate L Test3<L>();//一个返回指定泛型值的委托

        static Test3<int> _t3;//泛型委托实例化
        static Test3<bool> _t4;//泛型委托实例化

        static void Main(string[] args)
        {
            Test5 t5=new Test5();

            _t3 =t5.D;//泛型委托注册 返回值和泛型委托同一类型才可注册登记
            //_t3 += E;//报错 返回类型为bool 但当前委托实例时指定泛型为int 无法登记
            _t4 += t5.E;
            var tVal = _t3.Invoke();//泛型委托调用 并得到
            Console.WriteLine(tVal);
        }
    }

    public class Test5
    {
        public int D()
        {
            return 0;
        }

        public bool E()
        {
            return false;
        }
    }
}

在抽象类中声明泛型：

普通类和抽象类都可以选择将泛型进行继承或终止

public abstract class Class1<T>
{

}

public abstract class Class3<T> : Class1<T>//抽象类继承抽象类可以选择不明确泛型类型，将泛型派生下去
{
}

public abstract class Class6 : Class1<int>//抽象类继承抽象类可以也选择明确泛型，将泛型终止
{
}

public class Class2<T> : Class1<T>//普通类可以选择不明确泛型类型，将泛型派生
{
}

public class Class4 : Class3<int>//普通类将泛型终止
{

}

在静态类中声明泛型：

//public static class Class4<P> :Class1<int>//报错 静态类无法进行继承
//{

//}

public static class Class8<G> //静态类只能从实例化进行泛型实现
{
 
}

在接口中声明泛型：

public interface ICharge<T>//指定泛型 
{
    void CheckVal(T t);
}

public interface IBigCharge<T> : ICharge<T>//接口继承接口 将泛型T应用于本接口中
{
    void CheckVal2(T t);
}

public class Class1 : ICharge<int>//接口实例化 指定泛型为int
{
    public void CheckVal(int t)
    {
        Console.WriteLine(t == 10);
    }
}

public class Class2 : IBigCharge<float>//指定泛型为 float 那么IBigCharge及他继承的接口 泛型将统一成float
{
    public void CheckVal(float t)
    {
        Console.WriteLine(t <= 10);
    }

    public void CheckVal2(float t)
    {
        Console.WriteLine(t >= 10);
    }
}