C# in Depth

Covariance and contravariance143some random data, and then use that method as the action for a StreamFactory delegateinstance.Listing 5.3Demonstration of covariance of return types for delegatesdelegate Stream StreamFactory();static MemoryStream GenerateRandomData(){byte[] buffer = new byte[16];new Random().NextBytes(buffer);return new MemoryStream(buffer);}...StreamFactory factory = GenerateRandomData;B Declares delegate type returning StreamCDeclares methodreturning MemoryStreamDConverts methodgroup with covarianceStream stream = factory();int data;while ( (data=stream.ReadByte()) != -1){Console.WriteLine(data);}E InvokesdelegateThe actual generation and display of the data in listing 5.3 is only present to give the codesomething to do. (In particular, the way of generating random data is pretty awful!)The important points are the annotated lines. We declare that the delegate type has areturn type of Stream B, but the GenerateRandomData method C has a return type ofMemoryStream. The line creating the delegate instance D performs the conversion wesaw earlier and uses covariance of return types to allow GenerateRandomData to be usedfor the action for StreamFactory. By the time we invoke the delegate instance E, thecompiler no longer knows that a MemoryStream will be returned—if we changed the typeof the stream variable to MemoryStream, we’d get a compilation error.Covariance and contravariance can also be used to construct one delegate instancefrom another. For instance, consider these two lines of code (which assume an appropriateHandleEvent method):EventHandler general = new EventHandler(HandleEvent);KeyPressEventHandler key = new KeyPressEventHandler(general);The first line is valid in C# 1, but the second isn’t—in order to construct one delegatefrom another in C# 1, the signatures of the two delegate types involved have to match.For instance, you could create a MethodInvoker from a ThreadStart—but youcouldn’t do what we’re doing in the previous code. We’re using contravariance to createa new delegate instance from an existing one with a compatible delegate type signature,where compatibility is defined in a less restrictive manner in C# 2 than in C# 1.This new flexibility in C# 2 causes one of the very few cases where existing validC#1 code may produce different results when compiled under C# 2: if a derived classoverloads a method declared in its base class, a delegate creation expression that previouslyonly matched the base class method could now match the derived classmethod due to covariance or contravariance. In this case the derived class methodwill take priority in C# 2. Listing 5.4 gives an example of this.Licensed to Rhona Hadida