EFFICIENT CODE in VB.NET

Creation Quick Response Code in VB.NET EFFICIENT CODE

[TestFixture] public class TestObjectPool { void Method1(GenericObjectPool< TestPoolAllocation> pool) { TestPoolAllocation obj = pool.GetObject(); obj.Identifier = 100; NUnit.Framework.Assert.AreEqual( 1, pool.NumActive); } void Method2(GenericObjectPool< TestPoolAllocation> pool) { NUnit.Framework.Assert.AreEqual( 0, pool.NumActive); TestPoolAllocation obj = pool.GetObject(); NUnit.Framework.Assert.AreEqual( 100, obj.Identifier); NUnit.Framework.Assert.AreEqual( 1, pool.NumActive); } [Test] public void TestAllocateFreeAndReallocate() { GenericObjectPool< TestPoolAllocation> pool = new GenericObjectPool< TestPoolAllocation>(); pool.SetFactory( new TestPoolAllocationFactory()); Method1( pool); GC.Collect(); Thread.Sleep( 500); NUnit.Framework.Assert.AreEqual( 0, pool.NumActive); NUnit.Framework.Assert.AreEqual( 1, pool.NumIdle); Method2( pool); } } In the NUnit test code method TestAllocateFreeAndAllocated, the variable pool represents the GenericObjectPool< TestPoolAllocation>. From the pool, the individual TestPoolAllocation objects are instantiated. This test code has one small change in the method TestPoolAllocationFactory in that ActivateObject and PassivateObject aren t implemented. This is done on purpose to illustrate that an object is reused. In this NUnit test code, Method1 allocates an object instance and assigns the Identifier property a value of 100. Then in Method2, when an object is retrieved from the pool, the Identifier property value of 100 is tested to indicate that an object has been recycled. Notice in the implementation of TestAllocateFreeAndReallocate the methods GC.Collect and Thread.Sleep are called to give the garbage collector a chance to execute the finalizer. Now that you ve seen how object pooling works, let s move on to creating applications with multiple threads.

Writing applications that make use of multiple threads is a complicated undertaking because when you use multiple threads, multiple things are happening at the same time. The best way to understand this complexity is to think of pairs figure skating.

When two people figure skate, they skate together in synchronization. It s expected of each to do the right thing at the right time. For example, let s say the pair does a double axel. One picks up the other and spins the person like a top, who then amazingly lands on one skate to continue skating. Writing threaded applications is like pairs skating, except that there might be more than a pair of skaters trying to skate together at the same time. The more threads, the more skaters, the more likely something is going to go wrong. Debugging and visualizing threads is futile. It s like asking one of the skaters to stop midway in the routine for inspection. The other skater will probably fall flat on his or her face because the skater who is being inspected isn t at the place that the other skater expects him or her to be at. Therefore, as a word of warning, don t believe those tools that promise to solve your threading problems in one quick-and-easy step. The only way to manage multiple threads is to use a correct architecture with targeted debugging. Applications developed today require a developer to understand threading, as computers will include central processing units (CPUs) that will have multiple cores. Multiple cores means multiple processors, which means for an application to achieve scalability, the application needs to be threaded.

Running multiple threads in .NET is simple, and involves the instantiation of a delegate that is passed to a class that calls the delegate. The following source code provides an example: class StaticMethodThreads { public static void Thread1() { for(int i = 0; i < 10; i++) { Console.WriteLine("Thread1 {0}", i); } } } [TestFixture] public class TestSimpleThreading { [Test] public void RunStaticMethodTests() { Thread tid1 = new Thread(new ThreadStart(StaticMethodThreads.Thread1)); tid1.Start(); } } The class StaticMethodThreads has a single static method, Thread1, which has no parameters and no return value. The method RunStaticMethod instantiates the type Thread, and the constructor is a delegate of type ThreadStart. When the method tid1.Start is called, the delegate ThreadStart that is part of the method StaticMethodThreads.Thread1 is executed. When the method tid1.Start returns, the calling thread that is executing is doing so at the same time as the thread executing the method StaticMethodsThreads.Thread1. When a thread executes concurrently with another thread, they can both manipulate the same data. You could consider it as two applications executing at the same time, though this is a very simplistic way of looking at threading. It s also possible to execute multiple threads