十一、C# 泛型

 1     public class Stack<T>
 2     {
 3         private T[] _Items;
 4  
 5         public void Push(T data)
 6         {
 7  
 8         }
 9  
10         public void Pop()
11         {
12  
13         }
14     }

 1  interface IPair<T>
 2     {
 3         T First { get; set; }
 4         T Second { get; set; }
 5     }
 6     public struct Pair<T> : IPair<T>
 7     {
 8         private T _First;
 9         public T First
10         {
11             get
12             {
13                 return _First;
14             }
15             set
16             {
17                 _First = value;
18             }
19         }
20         private T _Second;
21         public T Second
22         {
23             get
24             {
25                 return _Second;
26             }
27             set
28             {
29                 _Second = value;
30             }
31         }
32        
33  
34     }

 1     public interface IContainer<T>
 2     {
 3         ICollection<T> Items
 4         { set; get; }
 5     }
 6     public class Address
 7     {
 8     }
 9     public class Phone
10     {
11     }
12     public class Email
13     {
14     }
15     
16     public class Person : IContainer<Address>, IContainer<Phone>, IContainer<Email>
17     {
18         ICollection<Address> IContainer<Address>.Items
19         { set; get; }
20  
21         ICollection<Phone> IContainer<Phone>.Items
22         { set; get; }
23  
24         ICollection<Email> IContainer<Email>.Items
25         { set; get; }
26     }

 1   interface IPair<TFirst,TSecond>
 2     {
 3         TFirst First { get; set; }
 4         TSecond Second { get; set; }
 5     }
 6     public struct Pair<TPFirst, TPSecond> : IPair<TPFirst, TPSecond>
 7     {
 8         public Pair(TPFirst first,TPSecond second)
 9         {
10             _First = first;
11             _Second = second;
12         }
13         private TPFirst _First;
14         public TPFirst First
15         {
16             get
17             {
18                 return _First;
19             }
20             set
21             {
22                 _First = value;
23             }
24         }
25         private TPSecond _Second;
26         public TPSecond Second
27         {
28             get
29             {
30                 return _Second;
31             }
32             set
33             {
34                 _Second = value;
35             }
36         }         
37  
38     }

 1     class Container<T, U>
 2     {
 3         class Nested<U>
 4         {
 5             void Method(T param0, U param1)
 6             {
 7  
 8             }
 9         }
10     }
11  

  1     class Program
  2     {
  3         static void Main(string[] args)
  4         {
  5             //只有接口和委托可以使用in out修饰
  6             Pair<Contact> contacts = new Pair<Contact>(new Contact("Princess Buttercupt", DateTime.Now),
  7                 new Contact("Inigo Montoya", DateTime.Now));
  8             //IPair<PdaItem> pair = contacts;//因为没有使用out ，不允许协变
  9             IReadOnlyPair<PdaItem> readPair = contacts;
 10             //异质：泛型指定的参数数据类型与实际的数据类型不同且非继承关系（）
 11             //异质的产生：
 12             //因为如果允许从子类往上转型成了基类，理论上可以改变 pair.ReadOnlyFirst = new Address();
 13             //因为Address是PdaItem的子类 会造成数据的异质
 14             //本来只允许包含的是Contact类型(T被指定为Contact)，现在却包含了Address 这个没有直接关系的类型
 15             //所以才需要使用通过out修饰限制泛型类型声明，让它只向接口的外部公开数据
 16  
 17             PdaItem pdaItem1 = readPair.ReadOnlyFirst;//只可读取,不可设置
 18             PdaItem pdaItem2 = readPair.ReadOnlySecond;
 19             Console.WriteLine(pdaItem1.Name + " " + pdaItem1.LastUpdated);
 20             Console.WriteLine(pdaItem2.Name + " " + pdaItem2.LastUpdated);
 21  
 22  
 23  
 24  
 25  
 26  
 27  
 28         }
 29     }
 30     public class PdaItem
 31     {
 32         public PdaItem()
 33         {
 34         }
 35         public PdaItem(string pName, DateTime pLastUpdated)
 36         {
 37             Name = pName;
 38             LastUpdated = pLastUpdated;
 39         }
 40         public virtual string Name { set; get; }
 41  
 42         public DateTime LastUpdated { set; get; }
 43     }
 44  
 45     public class Contact : PdaItem
 46     {
 47         public override string Name
 48         {
 49             get
 50             {
 51                 return FirtstName;
 52             }
 53             set
 54             {
 55                 FirtstName = value + " from Contact";
 56             }
 57         }
 58         private string FirtstName;
 59         public Contact()
 60         {
 61         }
 62         public Contact(string pName, DateTime pLastUpdated)
 63             : base(pName, pLastUpdated)
 64         {
 65  
 66         }
 67  
 68     }
 69  
 70     public class Address : PdaItem
 71     {
 72         public override string Name
 73         {
 74             get
 75             {
 76                 return DetailAddress;
 77             }
 78             set
 79             {
 80                 DetailAddress = value + " from Address";
 81             }
 82         }
 83         //此处会造成与Contact数据不一，从而造成泛型的数据异质
 84         private string DetailAddress;
 85         public string address1;
 86         public string address2;
 87         public string address3;
 88         public Address()
 89         {
 90         }
 91         public Address(string pName, DateTime pLastUpdated)
 92             : base(pName, pLastUpdated)
 93         {
 94  
 95         }
 96  
 97     }
 98  
 99     interface IReadOnlyPair<out T>
100     {
101         T ReadOnlyFirst { get; }
102         T ReadOnlySecond { get; }
103     }
104     interface IPair<T>
105     {
106         T First { get; set; }
107         T Second { get; set; }
108     }
109     public struct Pair<T> : IPair<T>, IReadOnlyPair<T>
110     {
111  
112         public Pair(T first, T second)
113         {
114             TPFirst = TPFirstReadOnly = first;
115             TPSecond = TPSecondReadOnly = second;
116         }
117         private T TPFirst;
118         private T TPSecond;
119         private T TPFirstReadOnly;
120         private T TPSecondReadOnly;
121  
122         T IPair<T>.First
123         {
124             get
125             {
126                 return TPFirst;
127             }
128             set
129             {
130                 TPFirst = value;
131             }
132         }
133         T IPair<T>.Second
134         {
135             get
136             {
137                 return TPSecond;
138  
139             }
140             set
141             {
142                 TPSecond = value;
143             }
144         }
145         T IReadOnlyPair<T>.ReadOnlyFirst
146         {
147             get
148             {
149                 return TPFirstReadOnly;
150             }
151         }
152         T IReadOnlyPair<T>.ReadOnlySecond
153         {
154             get
155             {
156                 return TPSecondReadOnly;
157             }
158  
159         }
160     }

  1     class Program
  2     {
  3         static void Main(string[] args)
  4         {
  5             //只有接口和委托可以使用in out修饰
  6             Pair<Contact> contacts = new Pair<Contact>(new Contact("Princess Buttercupt", DateTime.Now),
  7                 new Contact("Inigo Montoya", DateTime.Now));
  8             //IPair<PdaItem> pair = contacts;//因为没有使用out ，不允许协变
  9             IReadOnlyPair<PdaItem> readPair = contacts;
 10             //异质：泛型指定的参数数据类型与实际的数据类型不同且非继承关系（）
 11             //异质的产生：
 12             //因为如果允许从子类往上转型成了基类，理论上可以改变 pair.ReadOnlyFirst = new Address();
 13             //因为Address是PdaItem的子类 会造成数据的异质
 14             //本来只允许包含的是Contact类型(T被指定为Contact)，现在却包含了Address 这个没有直接关系的类型
 15             //所以才需要使用通过out修饰限制泛型类型声明，让它只向接口的外部公开数据
 16  
 17             PdaItem pdaItem1 = readPair.ReadOnlyFirst;//只可读取,不可设置
 18             PdaItem pdaItem2 = readPair.ReadOnlySecond;
 19             Console.WriteLine(pdaItem1.Name + " " + pdaItem1.LastUpdated);
 20             Console.WriteLine(pdaItem2.Name + " " + pdaItem2.LastUpdated);
 21  
 22  
 23             //从基类转换成子类的泛型
 24             Pair<PdaItem> pdaitem = new Pair<PdaItem>(new Contact("Princess Buttercupt", DateTime.Now),
 25                new Address());
 26             IWriteOnlyPair<Contact> writePair = pdaitem;
 27             //此处是重点,通过这个接口 1、只能进行赋值且只能是Contact类型或者它的子类，而不能是Address类型（非相关类型） 2、不能进行访问
 28             //这样就避免了，当pdaitem有多个不同类型的项时，使用一个泛型（T为子类类型）接口访问数据时，产生错误。因为类型不同，内部的成员变量和方法也有可能不同。
 29  
 30             writePair.WriteOnlyFirst = new Contact();
 31             writePair.WriteOnlySecond = new Contact();
 32  
 33  
 34         }
 35     }
 36     public class PdaItem
 37     {
 38         public PdaItem()
 39         {
 40         }
 41         public PdaItem(string pName, DateTime pLastUpdated)
 42         {
 43             Name = pName;
 44             LastUpdated = pLastUpdated;
 45         }
 46         public virtual string Name { set; get; }
 47  
 48         public DateTime LastUpdated { set; get; }
 49     }
 50  
 51     public class Contact : PdaItem
 52     {
 53         public override string Name
 54         {
 55             get
 56             {
 57                 return FirtstName;
 58             }
 59             set
 60             {
 61                 FirtstName = value + " from Contact";
 62             }
 63         }
 64         private string FirtstName;
 65         public Contact()
 66         {
 67         }
 68         public Contact(string pName, DateTime pLastUpdated)
 69             : base(pName, pLastUpdated)
 70         {
 71  
 72         }
 73  
 74     }
 75  
 76     public class Address : PdaItem
 77     {
 78         public override string Name
 79         {
 80             get
 81             {
 82                 return DetailAddress;
 83             }
 84             set
 85             {
 86                 DetailAddress = value + " from Address";
 87             }
 88         }
 89         //此处会造成与Contact数据不一，从而造成泛型的数据异质
 90         private string DetailAddress;
 91         public string address1;
 92         public string address2;
 93         public string address3;
 94         public Address()
 95         {
 96         }
 97         public Address(string pName, DateTime pLastUpdated)
 98             : base(pName, pLastUpdated)
 99         {
100  
101         }
102  
103     }
104  
105     interface IReadOnlyPair<out T>
106     {
107         T ReadOnlyFirst { get; }
108         T ReadOnlySecond { get; }
109     }
110     interface IWriteOnlyPair<in T>
111     {
112         T WriteOnlyFirst { set; }
113         T WriteOnlySecond { set; }
114     }
115     interface IPair<T>
116     {
117         T First { get; set; }
118         T Second { get; set; }
119     }
120     public struct Pair<T> : IPair<T>, IReadOnlyPair<T>, IWriteOnlyPair<T>
121     {
122  
123         public Pair(T first, T second)
124         {
125             TPFirst = TPFirstWriteOnly = TPFirstReadOnly = first;
126             TPSecond = TPSecondWriteOnly = TPSecondReadOnly = second;
127         }
128         private T TPFirst;
129         private T TPSecond;
130         private T TPFirstReadOnly;
131         private T TPSecondReadOnly;
132  
133         private T TPFirstWriteOnly;
134         private T TPSecondWriteOnly;
135  
136         //以下都是显式实现接口，使用时，需要进行显式转换才可以使用
137         T IPair<T>.First
138         {
139             get
140             {
141                 return TPFirst;
142             }
143             set
144             {
145                 TPFirst = value;
146             }
147         }
148         T IPair<T>.Second
149         {
150             get
151             {
152                 return TPSecond;
153  
154             }
155             set
156             {
157                 TPSecond = value;
158             }
159         }
160         T IReadOnlyPair<T>.ReadOnlyFirst
161         {
162             get
163             {
164                 return TPFirstReadOnly;
165             }
166         }
167         T IReadOnlyPair<T>.ReadOnlySecond
168         {
169             get
170             {
171                 return TPSecondReadOnly;
172             }
173  
174         }
175         T IWriteOnlyPair<T>.WriteOnlyFirst
176         {
177             set
178             {
179                 TPFirstWriteOnly = value;
180             }
181         }
182         T IWriteOnlyPair<T>.WriteOnlySecond
183         {
184             set
185             {
186                 TPSecondWriteOnly = value;
187             }
188  
189         }
190     }

1     interface IConvertible<in TSource, out TTarget>
2     {
3         TTarget Convert(TSource s);
4     }