泛型函数

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型。——来自百度

自我理解：泛型函数就是，你定义函数时候，是万能类型。在调用的时候，只要你把具体的类型传进去就好。好处呢，就是代码的复用，减少代码量。

在面向对象的语言中都是有泛型的这个概念和实现的。比如说：JAVA、C#、C++、TypeScript等等。但是我们在看书或者学习的时候呢，一般只是看到了这样的概念，或者说例子很简单，就是一个Int 和 string 参数的泛型使用。

其实泛型是用的很广泛的，特别是在写底层框架的时候。当大家去看源码的时候，会看到很多泛型。最近的工作中也用到了泛型，算是写底层吧，因为给别人调用。

工作需求是这样的 ，使用TCP/IP协议，从客户端发送 “结构体”到服务端。一般都是会将数据转化成byte[],再进行数据的传送。查资料和用泛型改造后：

C#代码

// 结构体转byte数组
public byte[] StructToBytes<T>(T structParams)
{
    var size = Marshal.SizeOf(structParams);
    var buffer = Marshal.AllocHGlobal(size);
    try
    {
        Marshal.StructureToPtr(structParams, buffer, false);
        var bytes = new byte[size];
        Marshal.Copy(buffer, bytes, 0, size);
        return bytes;
    }
    finally
    {
        Marshal.FreeHGlobal(buffer);
    }
}
    
// 结构体转byte数组
public static T BytesToStruct<T>(byte[] arr) where T : new()
{
    // where后面的泛型约束：参数需要有一个无参的构造函数
    T structType = new T();
    var size = Marshal.SizeOf(structType);
    var ptr = Marshal.AllocHGlobal(size);

    Marshal.Copy(arr, 0, ptr, size);
    structType = (T)Marshal.PtrToStructure(ptr, structType.GetType());
    Marshal.FreeHGlobal(ptr);
    
    return structType;
}

    public struct TestStruct0
    {
        public int count;
        public string key;
    }  
    public struct TestStruct1
    {
        public int count1;
        public string key1;
    }
    // testStruct0 为实例
    StructToBytes<TestStruct0>(testStruct0)
    // testStruct1 为实例
    StructToBytes<TestStruct1>(testStruct1)

在方法写成泛型以后，无论结构体是什么，函数只需要写一遍。调用方只需要写结构体的类型，和传入相应的实例就可以，而不需要写多个函数。对于参数不一样的而实现是一样的函数，大家可以考虑写成泛型方法或者用接口。

因为泛型在多种面向对象语言中均有实现，为了广大水友能更好的理解，或者说消除语言方面的区别。接下来写一个C#、JAVA、typescript的简单泛型函数版本。

C#的泛型函数：

public void Test<T>(T params)
{
  // TODO    
}
// 调用实例1： Student为类型，student为传入参数
Test<Student>(student);
// 调用实例2： String为类型
Test<String>("我是参数")
// 调用实例3：Int为类型
Test<Int>(100)

Java中没有Struct，我们将用简单的例子：

// 返回值为T类型的实例
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}

// 调用
test1 obj1 = genericMethod(Class.forName("com.test.test1"));
test2 obj2 = genericMethod(Class.forName("com.test.test2"));

TypeScript 泛型函数代码

function identity<T>(arg: T): T {
    return arg;
}
// 调用
let output0 Identity(3);
let output1 = identity("myString");

自我理解用法：泛型函数一般用在基础类型的函数较多，像Int、String、struct，这种不能用接口限定的，用泛型去写方法。如果是Object类型的话，可以用接口是去限定参数。记得有一句话叫对接口编程，而不是对实现编程。