泛型学习（二）
3.1 多参数泛型
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApp
{
class MoreGenericSample
{
public static void Main()
{
czrelation<int, double> sinTable = new czrelation<int, double>(180);
for (int i = 0; i < 180; i++)
{
sinTable.Left[i] = i;
sinTable.Right[i] = Math.Sin(Math.PI * i / 180);
}
//求正弦函数
Console.WriteLine("请输入度数(0~179之间)：");
int x = int.Parse(Console.ReadLine());
double y = sinTable.Right[x];
Console.WriteLine("sin({0}度={1})", x, y);
//求反正弦函数
Console.WriteLine("请输入一个实数(0~1之间)：");
double r = double.Parse(Console.ReadLine());
int pos;
for (pos = 0; pos < sinTable.Length; pos++)
{
if (Math.Abs(r - sinTable.Right[pos]) < 0.005)
break;
}
if (pos == sinTable.Length)
Console.WriteLine("没有找到指定的反正弦值。");
else
Console.WriteLine("arcsin({0})={1}度", r, sinTable.Left[pos]);
Console.ReadLine();
}
}
public class czrelation<L, R> //多参数泛型类
{
public L[] Left;
public R[] Right;
public int Length
{
get { return Left.Length; }
}
public czrelation(int iLength)
{
Left = new L[iLength];
Right = new R[iLength];
}
public int FindLeft(L left)
{
for (int i = 0; i < Length; i++)
{
if (Left[i].Equals(left))
return i;
return -1;
}
return 0;
}
public int FindRight(R right)
{
for (int i = 0; i < Length; i++)
{
if (Right[i].Equals(right))
return i;
return -1;
}
return 0;
}
}
}
3.2 类型参数与标识
关于调用时的歧义 (泛型使用时的类型参数 和 普通方法的参数 相同)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApp
{
class Test<S,T>
{
public static void Add(T t) { Console.WriteLine("T={0}",t); }
public static void Add(int i) { Console.WriteLine("i={0}", i); }
public static void Add(T t, int i) { Console.WriteLine("T={0},i={1}", t,i); }
public static void Add(int i, T t) { Console.WriteLine("i={0},T={1}", i,t); }
public static void Add(S s) { Console.WriteLine("S={0}", s); }
public static void Add(S s, T t) { Console.WriteLine("S={0},T={1}", s, t); }
public static void Add(S s, params T[] ts) { }
public static void Add(T t, params S[] ss) { }
}
class Run
{
static void Main()
{
//存在歧义，如果有一个方法的定义中不带类型参数(T)，则调用此方法
Test<int, int>.Add(1);
//存在歧义，如果两个方法的定义中都包含了类型参数，那么代码不能通过编译！
//Test<int,int>.Add(1, 2); //编译错误
//string[] str={"1","2","3"};
//Test<int, string[]>.Add(1,str);
//int[] iArr = { 1, 2, 3 };
//Test<int, int[]>.Add(1, iArr);
Console.ReadLine();
}
}
}
4 类型限制
4.1 主要限制
public class GA<T> where T : struct //限制T的目标类型为 值类型
punlic class GB<B> where T : class //限制T的目标类型为 引用类型
T t = null; //合法
public class CzRelation<L,R> where L : struct where R : class //多参数限制
4.2 次要限制
将类型参数的目标类型 限制为 从指定的基类或接口中的相关成员。
public class A {}
public class GB<T> where T : A //基类限制
public class CzAssemble<T> where T : Ioutput //接口限制
如果存在主要限制，那么次要限制就只能是接口限制， 而且关键字struct或class要在次要限制前面
public class CzAssemble<T> where T : struct, IOutput
Array，Delegate，Enum，ValueType 不能作为类型参数的限制基类
用作类型限制的类可以是泛型类， 此时它的所有类型参数都必须在被限制的类型中出现
public class BaseClass<T>{}
public class GenericClass<T> where T : BaseClass<T> {}
public class CzRelationElement<L,R> {}
public class CzRelation<T> where T : CzRelationElement<int,T>{} //合法
public class CzRelation<T> where T : CzRelationElement<S,T>{} //不合法
4.3 构造函数限制
要求其目标类型必须提供一个默认的无参构造函数
public class CzAssemble<T> where T : IOutput ,new()
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApp
{
class GenericConstraintSample
{
public static void Main()
{
CzAssemble<int> asm = new CzAssemble<int>(5);
Random rand = new Random();
for (int i = 0; i < asm.Length; i++)
asm[i] = rand.Next(100);
asm.Output();
Console.WriteLine("----------------------------------");
asm.Sort();
asm.Output();
Console.ReadLine();
}
}
public interface IOutput
{
void Output();
}
//泛型类：集合CzAssemble
public class CzAssemble<T> where T : IComparable
{
protected T[] m_list;
public int Length
{
get { return m_list.Length; }
}
public T this[int index]
{
get { return m_list[index]; }
set { m_list[index] = value; }
}
public CzAssemble(int length)
{
m_list = new T[length];
}
public void Output()
{
foreach (T t in m_list)
{
if (t != null)
{
if (t is IOutput)
(t as IOutput).Output();
else
Console.WriteLine(t);
}
}
}
public void Sort()
{
T tmp;
for (int i = m_list.Length; i > 0; i--)
{
for (int j = 0; j < i - 1; j++)
{
if (m_list[j].CompareTo(m_list[j + 1]) > 0)
{
tmp = m_list[j];
m_list[j] = m_list[j + 1];
m_list[j + 1] = tmp;
}
}
}
}
}
}
