Diving into Code in VB.NET

Printer Denso QR Bar Code in VB.NET Diving into Code

Going back to Figure 6-6, notice the classes Implementation1 and Implementation2 need to be defined, and they need to use Subject to implement the dynamic extensions. Following are the definitions of the implementation classes: public class Implementation1 : IBase1, ISubject { Subject _subject; public Implementation1( Subject subject) { _subject = subject; } public type GetExtension< type>() where type: class { return _subject.GetExtension< type>(); }

public int Value() { return 1; } } public class Implementation2 : IBase2, ISubject { Subject _subject; public Implementation2( Subject subject) { _subject = subject; } public type GetExtension< type>() where type: class{ return _subject.GetExtension< type>(); } public int Value() { return 2; } } Implementation1 implements both IBase1 and ISubject. The implementation of IBase1 is obvious, since that is the interface that will be cast to. The implementation of ISubject is required, because if a client has a reference to the IBase1 interface, it will typecast to ISubject and use the method GetExtension to retrieve the interface instance that is needed. The same sort of implementation logic applies to Implementation2. In the example, both Implementation1 and Implementation2 have constructors with a parameter of type Subject. This is done on purpose so that when either Implementation1 or Implementation2 is instantiated, they are associated with a Subject instance that will chain together Implementation1 and Implementation2. The last step is to use the Factory pattern to instantiate both types and link them together: class Factory { public static IBase1 CreateInstance() { Subject main = new Subject(); Implementation1 impl1 = new Implementation1( main); Implementation2 impl2 = new Implementation2( main); main.AddExtension( impl1 as IBase1); main.AddExtension( impl2 as IBase2); return impl1; } } Factory has a single method, CreateInstance, which returns an interface instance of type IBase1. In the implementation of CreateInstance, the first step is to instantiate Subject because it s the class that binds together all of the implementations. Then the different implementations (impl1 and impl2) are instantiated and the Subject instance passed to them. At this point, both impl1 and impl2 have been instantiated and are valid instances, but they aren t linked together. This means if a client has a reference to IBase1, which is impl1, and attempts to get the extension instance impl2, which is IBase2, a null value is returned. Therefore, as a last

step, the method AddExtension of Subject is called, and the implementation instances impl1 and impl2 are added. The last step would be to call the Factory.CreateInstance method and use both the IBase1 and IBase2 interface instances. Following is a simple example of the NUnit test code for this step: [TestFixture] public class TestDynamicExtensions { [Test] public void TestSimple() { IBase1 base1 = Factory.CreateInstance(); IBase2 base2 = ((ISubject)base1).GetExtension< IBase2>(); Assert.IsNotNull( base2); Assert.AreEqual( 2, base2.Value()); base1 = ((ISubject)base2).GetExtension< Extensions.IBase1>(); Assert.IsNotNull( base1); Assert.AreEqual( 1, base1.Value()); } } The variable base1 is instantiated and is type IBase1, which means it s the implementation instance of Implementation1. Then in the next line where base2 is assigned, a typecast to ISubject is performed with a GetExtension method call to retrieve an instance of IBase2. The variable base2 will reference the implementation instance Implementation2. Unlike the Static Extension pattern example, the references of base1 and base2 won t be identical. However, the client using base1 and base2 doesn t know that. Several lines down the GetExtension method is called again to illustrate how it s possible to retrieve the IBase1 implementation instance from the IBase2 implementation instance.

The Extension pattern, whether static or dynamic, illustrates polymorphism using interfaces. The idea is to allow a client to reference an interface instance, and from that interface instance reference other functionality. In .NET, the System.Windows.Forms and ASP.NET classes use this capability in multiple places. Polymorphism makes it possible to use the same interfaces and groupings of interfaces in different contexts. Though the static implementation is simpler than the dynamic implementation, the dynamic implementation can exhibit dynamic polymorphism where a configuration file or some other logic determines which interfaces and implementations belong together. It s also important to realize that the Factory pattern was used for creating the dynamic extension, because the dynamic extension represents an instance of one object. At least the dynamic extension gives this impression to the client. One little annoying aspect of the Extension pattern is that the way to retrieve the interface instance using the static implementation isn t identical to that for the dynamic implementation. A solution is to use the following static class method: