// 泛型类; class引用类型约束;new()无参约束;struct值类型约束
class TC1<T> where T : class
{
T member;
#region 多态是指同一个行为具有多个不同表现形式或形态的能力;返回类型可以不一样,参数类型可以不一样,参数个数可以不一样。
public int Add(int a, int b)
{
return a + b;
}
public int Add(int a, int b, string SS)
{
Console.WriteLine(SS);
return a + b;
}
public int Add(string a, string b)
{
return Convert.ToInt32(a) + Convert.ToInt32(b);
}
public string Add(int a, String b)
{
int bi = Convert.ToInt32(b);
return (a + b).ToString();
}
// 其他多态形式:接口、重写;
#endregion 多态
public TC1() // 泛型演示
{
T dd = default;
int aa = Fun1<int>(3);
double aa1 = Fun1<double>(4);
Console.WriteLine("T泛型" + aa + ";" + aa1);
List<SS> c2s = Fun1s<SS>("输出C2");
List<int> c2aa = Fun1s<int>("输出int");
int ss = Str2IntFun<int, string>("1");
Dictionary<int, string> keyValuePair = AddDict(2, "Value=2");
keyValuePair.Add(3, "Value=3");
StringBuilder stringBuilder = new StringBuilder();
foreach (int key in keyValuePair.Keys)
{
stringBuilder.AppendLine(key + "," + keyValuePair[key]);
}
Console.WriteLine("多个泛型变量" + ss + ";" + stringBuilder.ToString());
}
/// <summary>
/// 一般写法
/// </summary>
/// <typeparam name="T">值类型</typeparam>
/// <param name="a"></param>
/// <returns></returns>
public T Fun1<T>(int a) where T : struct
{
T value = default;
value = (T)Convert.ChangeType(a, typeof(T));
return value;
}
/// <summary>
/// 常用的写法
/// </summary>
public List<T> Fun1s<T>(string str)
{
List<T> values = new List<T>();
Console.WriteLine(str);
return values;
}
/// <summary>
/// 多泛型值写法
/// </summary>
/// <typeparam name="TOne">值类型</typeparam>
/// <typeparam name="TTwo">TTwo</typeparam>
/// <param name="str"></param>
/// <returns></returns>
public TOne Str2IntFun<TOne, TTwo>(TTwo str) where TOne : struct where TTwo : class
{
TOne value = default;
value = (TOne)Convert.ChangeType(str, typeof(TOne));
return value;
}
/// <summary>
/// 多泛型值写法_返回字典类型
/// </summary>
/// <typeparam name="TOne">值类型</typeparam>
/// <typeparam name="TTwo">引用类型</typeparam>
/// <param name="key">字典的key</param>
/// <param name="value"></param>
/// <returns></returns>
public Dictionary<TOne, TTwo> AddDict<TOne, TTwo>(TOne key, TTwo value) where TOne : struct where TTwo : class
{
Dictionary<TOne, TTwo> dictionary1 = new Dictionary<TOne, TTwo>();
dictionary1.Add(key, value);
return dictionary1;
}
}
class SS
{
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
- 36.
- 37.
- 38.
- 39.
- 40.
- 41.
- 42.
- 43.
- 44.
- 45.
- 46.
- 47.
- 48.
- 49.
- 50.
- 51.
- 52.
- 53.
- 54.
- 55.
- 56.
- 57.
- 58.
- 59.
- 60.
- 61.
- 62.
- 63.
- 64.
- 65.
- 66.
- 67.
- 68.
- 69.
- 70.
- 71.
- 72.
- 73.
- 74.
- 75.
- 76.
- 77.
- 78.
- 79.
- 80.
- 81.
- 82.
- 83.
- 84.
- 85.
- 86.
- 87.
- 88.
- 89.
- 90.
- 91.
- 92.
- 93.
- 94.
- 95.
- 96.
- 97.
- 98.
- 99.
- 100.
- 101.
- 102.
- 103.
- 104.
- 105.
- 106.
- 107.
- 108.
- 109.
- 110.
- 111.
- 112.
- 113.
- 114.
- 115.
作者:꧁执笔小白꧂