public void SetViewBinding(object view) { if (PoppableService == null) { PoppableService = view as IPoppable; } }
public static void Main() { Stack <Dog> dogs = new Stack <Dog>(); //Stack<Animal> animals = dogs; //error CS0029 //AnimalCleaner.Wash(dogs); // error CS1503 dogs.Push(new Dog()); IPoppable <Animal> animals = dogs; AnimalCleaner.Wash(animals); }
/// <summary> /// 协变测试 /// 1.协变类型参数,该参数只能用于输出的位置(例如方法的返回值) /// 2.仅泛型接口和泛型委托支持协变类型参数(泛型类不支持协变类型参数) /// 在接口和委托的类型参数上指定out修饰符可将其声明为协变参数 /// 3.(由于历史原因)数组支持协变 /// </summary> private void Test01() { MyStackA <Cat> catStack = new MyStackA <Cat>(); //MyStackA<Animal> animalStack = catStack;//编译报错 MyStackB <Cat> catStackB = new MyStackB <Cat>(); IPoppable <Animal> animalStackB = catStackB;//利用协变 Animal a1 = animalStackB.Pop(); //WashA(catStackB); //WashB(catStackB); WashC(catStackB); }
private static void GenericTypesTests() { Console.WriteLine("--- {0} ---", System.Reflection.MethodBase.GetCurrentMethod().Name); Stack <int> stack = new Stack <int>(); stack.Push(5); stack.Push(10); int x = stack.Pop(); int y = stack.Pop(); int xx = 5, yy = 10; Generics.Swap(b: ref yy, a: ref xx); Type g1 = typeof(G <>); Type g2 = typeof(G <,>); Console.WriteLine(g2.GetGenericArguments().Count()); Type g3 = typeof(G <int, int>); Console.WriteLine(g3.GetGenericArguments().Count()); Console.WriteLine(++Bob <int> .Count); Console.WriteLine(++Bob <int> .Count); Console.WriteLine(++Bob <string> .Count); Console.WriteLine(++Bob <object> .Count); // Covariance { // Assuming that Bear subclasses Animal: var bears = new Stack <Bear>(); bears.Push(new Bear()); // Because bears implements IPoppable<Bear>, we can convert it to IPoppable<Animal>: IPoppable <Animal> animals = bears; // Legal Animal a = animals.Pop(); } // Contravariance { IPushable <Animal> animals = new Stack <Animal>(); IPushable <Bear> bears = animals; // Legal bears.Push(new Bear()); } Console.WriteLine("====================================================================="); }
static void Main(string[] args) { // Stack covariance Animal animal = new Bear(); // Bear is convertible to Animal (asumption above) var bearStack = new Stack <Bear>(); bearStack.Push(animal as Bear); bearStack.Push(new Bear()); IPoppable <Animal> animalPop = bearStack; animal = animalPop.Pop(); //Stack<Animal> animalst = bears; // not a covariant parameter, classes do not permit covariant paramters since data flow in both directions ZooCleaner.Wash(bearStack); // OK, covariant method // contravariance var animalStack = new Stack <Animal>(); IPushable <Bear> bearPush = animalStack; // legal IPushable <Camel> camelPush = animalStack; // legal, contravariant animalStack.Push(new Bear()); animalStack.Push(new Camel()); camelPush.Push(new Camel()); bearPush.Push(new Bear()); // Interface covariance string s = "Hello"; object o = s; IFoo <string> fooString = new FooString(); //IFoo<object> fooObject; fooObject = fooString; // HEY! interfaces should be covariant!!!! Whats up? // Array covariance Bear[] bearArr = new Bear[] { new Bear(), new Bear() }; Animal[] animalArr = bearArr; // OK, covariant animalArr[1] = new Bear(); //animalArr[1] = new Camel(); ArrayTypeMismatchException: Attempted to access an element as a type incompatible with the array. //animalArr[1] = new Animal(); ditto }
public static void Wash(IPoppable <Animal> animals) { }
private void OnBubbleTap(IPoppable bubble) { bubble.Pop(); OnBubblePoped?.Invoke(bubble.GetScore()); }
//public static void Wash(Stack<Animal> animals) public static void Wash(IPoppable <Animal> animals) { System.Console.WriteLine("The animals are clean!"); }
private void WashC(IPoppable <Animal> animal) { }