c#泛型

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

namespace XNdemo
{
    class Program
    {
        static void Main(string[] args)
        {
            ISample<ChildClass> child = new Sample<ChildClass>();
            ISample < BaseClass > baseclusing ass = child;//协变
            ISample<Object> obj = baseclass;//协变

            baseclass.Function(new ChildClass());
            
            
        }
    }
    public class BaseClass
    {
        public virtual void Print()
        {
            Console.WriteLine("in baseClass");
        }
    }
    public class ChildClass : BaseClass
    {
        public override void Print()
        {
            Console.WriteLine("in childClass");
        }
    }
    interface ISample< T>
        
    {
        T Function(T var);
    }
    class Sample<T> : ISample<T>
        where T:BaseClass
    {
        public T Function(T var)
        {
            Console.WriteLine("work...");
            var.Print();

            return default(T);
        }
 
    }
}

1泛型类中的约束是有顺序的：

　　class，struct，<base class name>这三种类型的约束必须在第一位

　　之后是<interface name>约束类型，数量不限

　　如果有new（）约束类型，必须放在最后，并且对应的实参类型必须有一个无参的公共构造函数使用格式

　　class MyPrinter<T,K>

　　　　where K:class

　　　　where t:class,Iprinter,new()

　　　　{

　　　　　　///约束的次序是有要求的

　　　　}

　　简单约束使用格式：

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

namespace YShDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Customer customer = new Customer();
            customer.CreditCardNo = "123456";
            customer.Name = "lzhq";
            Shop<Customer> shop = new Shop<Customer>();
            shop.Print(customer);
        }
    }
    public class Shop<T>
        where T:Customer//类型参数的约束T必须为customer类或者为其派生类
    {
        public void Print(T customer)
        {
            Console.WriteLine( customer.CreditCardNo);
            Console.WriteLine(customer.Name);
        }
 
    }
    public class Customer
    {
        public string Name
        {
            get;
            set;
        }
        public string CreditCardNo
        {
            get;
            set;
        }
    }
}

泛型委托：

　　

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

namespace FXdelegate

{
    delegate TResult PrintDelegate<T,TResult>(T data);
    class Program
    {
        static void Main(string[] args)
        {
            PrintDelegate<string, string> p1 = Printer.PrintString;
            PrintDelegate<int, int> p2 = Printer.PrintInt;
            PrintDelegate<string, int> p3 = Printer.PrintIntEx;
            Console.WriteLine(p1("lzhq"));
            Console.WriteLine(p2(2));
            Console.WriteLine(p3("lzhq"));

        }
    }
    public class Printer
    {
        public static string PrintString(string msg)
        {
            Console.WriteLine(msg);
            return msg;
        }
        public static int PrintInt(int msg)
        {
            return msg;
        }
        public static int PrintIntEx(string msg)
        {
            return 0;
        }
    }
}

泛型方法：

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

namespace FXmethod
{
    class Program
    {
        static void Main(string[] args)
        {
            Printer.Print<int, Data>(2010);
            Printer.Print<string, Data>("lzhq");
          

        }
    }
    public class Data
    {
        public Data()
        {
            System.Console.WriteLine("construts Data class");
        }
    }
    public class Printer
    {
        public static TResult Print<T, TResult>(T msg)
            where TResult : new()
        {
            Console.WriteLine(msg);
            TResult result = new TResult();
            return result;
        }
    }
}

4

在使用泛型接口时期中的泛型参数可以声明为协变参数或者逆变参数

协变：泛型参数定义的类型只能作为方法的返回类型不能作为方法的参数类型，且该类型直接或间接继承接口方法的返回值类型

逆变：泛型参数的类型只能作为接口方法的参数类型不能做为返回值类型，且该类型是接口方法参数类型的基类型。

简单的总结就是：如果泛型参数做为实现接口的类中的方法的返回值类型时就是协变，此时由实现类实例化的对象必须由以返回类型的基类作为泛型参数的接口来引用

如果泛型参数作为实现类的方法的参数使用时，那么实例化的类对象必要由以该参数为基类的派生类的泛型参数 的接口引用。

协变，逆变使用格式：

注：协变和逆变对应的参数类型都必须是引用类型时才有意义，如果是值类型就必须使用接口的相同的值类型参数做为左侧指向变量。

泛型接口：

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

namespace InterfaceDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            ILog<string> log1 = new Log<string>();
            ILog<int> log2 = new Log<int>();
            log1.Error("hello world");
            log2.Error(2101);
            Console.WriteLine(log1.GetCurrentMsg());
        }
    }
    public interface ILog<T>
    {
         void Error(T message);
         T GetCurrentMsg();
    }
    public class Log<T> : ILog<T>
    {
        private T _currentMsg;
        public void Error(T message)
        {
            _currentMsg = message;
            Console.WriteLine(message);
        }
        public T GetCurrentMsg()
        {
            return _currentMsg;
        }
 
    }
}

注意：接口中的成员默认都是public 的不允许重复添加public的访问权限，在运行时会报错，提示接口成员不能添加任何访问修饰权限。