Bruce Zhang

Handling Distributed Transactions In Visual Studio 2005

wayfarer — Wed, 15 Feb 2006 06:44:00 GMT

It provides the System.Transaction namespace in Visual Studio 2005. So it is very convenient to handle distributed transactions. In Visual Studio 2003 .Net, distributed transactions are handled by Enterprise Service and require COM+ registration. We may compare the methods of inserting the order between Pet Shop 3.0 and Pet Shop 4.0. In Pet Shop 3.0, the OrderInsert class must be derived from a Serviced Component in order to handle the transaction, as shown as below:

using System;
using System.Collections;
using System.EnterpriseServices;
using System.Runtime.InteropServices;
...
namespace PetShop.BLL {
   /// <summary>
   /// A business component to manage the creation of orders
   /// Creation of an order requires a distributed transaction
   /// so the Order class derives from ServicedComponents
   /// </summary>
   [Transaction(System.EnterpriseServices.TransactionOption.Required)]
   [ClassInterface(ClassInterfaceType.AutoDispatch)]
   [ObjectPooling(MinPoolSize=4, MaxPoolSize=4)]
   [Guid("14E3573D-78C8-4220-9649-BA490DB7B78D")]
   public class OrderInsert : ServicedComponent {
      ...
      /// <summary>
      /// A method to insert a new order into the system
      /// The orderId will be generated within the method and should not
      /// be supplied as part of the order creation the inventory will be 
      /// reduced by the quantity ordered.
      /// </summary>
      /// <param name="order">All the information about the order</param>
      /// <returns>
      /// The new orderId is returned in the order object
      /// </returns>
      [AutoComplete]
      public int Insert(OrderInfo order) {

         // Get an instance of the Order DAL using the DALFactory
         IOrder dal = PetShop.DALFactory.Order.Create();

         // Call the insert method in the DAL to insert the header
         int orderId = dal.Insert(order);

         // Get an instance of the Inventory business component
         Inventory inventory = new Inventory();
         inventory.TakeStock( order.LineItems);
         ...

         // Set the orderId so that it can be returned to the caller
         return orderId;
      }
   }
}

But in Pet Shop 4.0, we can use System.Transaction to insert an order and update the inventory stock. It has implemented the Order.Insert() method by adding a reference to the System.Transaction namespace and wrapping the order insertion and inventory stock reduction methods inside of a TranscationScope, as shown as below:

using System;
using System.Transactions;
using PetShop.IBLLStrategy;

namespace PetShop.BLL {
    /// <summary>
    /// This is a synchronous implementation of IOrderStrategy 
    /// By implementing IOrderStrategy interface, the developer can 
    /// add a new order insert strategy without re-compiling the whole 
    /// BLL.
    /// </summary>
    public class OrderSynchronous : IOrderStrategy {
      ...
        /// <summary>
        /// Inserts the order and updates the inventory stock within 
        /// a transaction.
        /// </summary>
        /// <param name="order">All information about the order</param>
        public void Insert(PetShop.Model.OrderInfo order) {

            using (TransactionScope ts = new                      
TransactionScope(TransactionScopeOption.Required)) {

                dal.Insert(order);

                // Update the inventory to reflect the current inventory 
                // after the order submission.
                Inventory inventory = new Inventory();
                inventory.TakeStock(order.LineItems);

                // Calling Complete commits the transaction.
                // Excluding this call by the end of TransactionScope's
                // scope will rollback the transaction.
                ts.Complete();
            }
        }
    }
}

Obviously, it is simpler by handling Distributed Transaction in Visual Studio 2005 than in Visual Studio 2003. Furthermore, it can improve the performance of program when handling transaction.

Encapsulation of Change (Part One)

wayfarer — Fri, 20 Jan 2006 02:59:00 GMT

The change of the requirement is an enemy we must fight against when we develop the software project. Sometimes, the change of the requirement is endless, so we have to delay our project. Of course, our customers have not been patient with our delay. They would rather believe the difficulty we meet because of the change of requirement is the foxy excuse. The change is like a sword of Damocles over our head. As brooks said, there is no silver bullet in the process of software engineering. It is same that we can't find the "silver bullet" to solve the problem of change. It's a mission impossible. But don't scare of it, we must face its difficulty actively. So Kent Beck, the leader of XP (Extreme Programming), announced that we must embrace the change. He provided the solution to solve it from the angle of Software Engineering Methodology. And now, this article will address issue how to solve the change in the process of developing the software project from the angle of Software Design Methodology. That is "Encapsulation of Change".

Design Patterns is the best interpretation of "Encapsulation of Change". No matter we use the Creational Pattern, Structural Pattern, or Behavioral Pattern, our objective is finding the change in Software, then encapsulating the change with abstraction and polymorphism. So, at the beginning of design, we not only implement the User Case, but also mark the existed change. Encapsulation of change means to discover the change or find the change. It is very important.

The objective of Creational Pattern is to encapsulate the change when creating an object. For example, it builds the specific abstract factory class when we use Factory Method Pattern or Abstract Factory Pattern. So this factory class encapsulates the creational change in the future. Bridge Pattern encapsulates the change when creating the object inside the product, so that we can replace it with the new object to fit the change of requirement.

As far as Structural Pattern, it focuses on the composite style between the object. When we change the structure of object, in fact the dependent relationship between the objects would be changed. Of course if you want to use the Structural Pattern, you will use not only encapsulation, but also inheritance and aggregation. For example, Decorate Pattern describes the dependent relationship between the decorator and the decorated object. The decorator is the abstract class so we can handle the change of the structure of the object. Similarly, Builder Pattern encapsulates the dependent relationship of an implementation of the object. Composite Pattern encapsulates the recursive relationship between the objects.

Behavioral Pattern mainly focuses on the behavior of the object. It abstracts the behavior of the object into the specific abstract class or interface, so that it becomes more extensible, because the behavior is the most unstable part in the architecture. For instance, Strategy Pattern abstracts the strategy or algorithm into a sole class or interface in order to encapsulate the strategy. Command Pattern encapsulates the request. State Pattern encapsulates the state. Visitor Pattern encapsulates the style of visiting. Iterator Pattern encapsulates the algorithm of iteration.

By using the Design Patterns and encapsulating the change, it ensures the extensible of the architecture. Maybe we can’t drive off the nightmare which was brought by the change, however, if we can foresee some changes at the beginning of the design, it will avoid the trouble caused by the change in the future. So we can say Design Patterns should be a nice spear to fight against the change, although we can’t find out the “Silver Bullet”.

My Workspaces

wayfarer — Wed, 28 Dec 2005 03:09:00 GMT

Today, I applied for the workspaces in http://www.gotdotnet.com. It is free and useful. Through it, you can upload your resources, for instance, your projects, your articles and some material you collected. It likes the storehouse so that you can backup your important stuff. At the same time you may share them with your friends who are easy to get them by visiting your workspaces website. By the way, you can assign the catchy alias to your workspaces in order to create the friendly URL at http://workspaces.gotdotnet.com/[alias]. It's cool!

More exact definition is that "Workspaces is an online collaborative development enviroment where developer can create, host and manage projects throughout the project lifecycle". Yeah, so you can invite your partners to join it. You can check in or check out your projects with teamwork.

So, do you want to own your workspaces? Please visit http://www.gotdotnet.com and create the new workspaces. Of course, welcome to my workspaces which url is http://workspaces.gotdotnet.com/wayfarer.

Terrible Harddisk

wayfarer — Fri, 23 Dec 2005 02:14:00 GMT

A couple of days ago, the harddisk of my laptop met the fatal mistake, it couldn't work. So I had to send my laptop to the headquaters of Company. The result of examination was to change the new harddisk, and my total data stored in the harddisk could not be restored. Terrible! But I must accept this fact. Fortunately, many important material had been backuped, otherwise my loss would be very serious.

So, please remember backupping your important data at any moment!

My Plan

wayfarer — Fri, 23 Dec 2005 01:56:00 GMT

These days, I get the precious leisure time. This condition will go on for half year. I'd better making the best of it. My plan to improve the technical skill is:

1. Learning C++ Programming In the Unix Environment;
2. Depth-Understanding .Net;
3. Obtain the knowledge of Architecture Design, Especially SOA(Service Oriented Architecture);
4. Master the Domain Knowledge of Semiconductor Industry.

Very difficult, but I must try my best.

Switch Statement is the poison resulting in Stiff

wayfarer — Fri, 16 Dec 2005 05:38:00 GMT

Head First Design Pattern is nice book that introduces the Design Pattern. There are a great number of samples in the book. These samples were written with Java. But we can download the C# samples from HeadFirstDesignPatternCSharp.

In this book, it introduces the Abstract Factory Pattern with the case of PizzaStore. This example is very interesting and easy to understand. The class diagram of PizzaStore is as below:

<Figure1.1 Class Diagram of PizzaStore>

Subclasses NYPizzaStore and ChicagoPizzaStore are derived from the Abstract Class PizzaStore. They are all override the CreatePizza() method. This method would create the specific pizza according to the value of string type. It would be invoked by OrderPizza() method which is contained in base class PizzaStore. The codes of OrderPizza() are as below:

public Pizza OrderPizza(string type)

{

Pizza pizza;

pizza = CreatePizza(type);

pizza.Prepare();

pizza.Bake();

pizza.Cut();

pizza.Box();

return pizza;

}

CreatePizza is the virtual method. It is overrided in subclass NYPizzaStore:
    protected override Pizza CreatePizza(string type)
    {
        Pizza pizza = null;

IPizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();

switch (type)

{

case "cheese":

pizza = new CheesePizza(ingredientFactory);

pizza.Name = "New York Style Cheese Pizza";

break;

case "clam":

pizza = new ClamPizza(ingredientFactory);

pizza.Name = "New York Style Clam Pizza";

break;

case "pepperoni":

pizza = new PepperoniPizza(ingredientFactory);

pizza.Name = "New York Style Pepperoni Pizza";

break;

}

return pizza;

}

However it occurs the terrible switch statement. The switch statement is very important when we want to make a choice by the specific condition, but it will hurt the program's flexibility also. Imaging this case, if we want to add the new kind of Pizza, we must modify all of the subclasses which are derived from PizzaStore. Absolutely, it is the poison resulting in the stiff of program structure. So how to eliminate it?

In the CreatePizza() method, its responsibility for creating the Pizza. So we may introduce the special factory class which responsibility for producing the product, that is the specific Pizza Class, like CheesePizza, ClamPizza or PepperoniPizza. The class diagram like this:

<Figure1.2 Class Diagram of PizzaFactory>

We must modify the CreatePizza() method in PizzaStore class. We should accept the parameter which type is IPizzaIngredientFactory. IPizzaIngredientFactory is the factory class. Its function is to make the Pizza which style is different. For instance, it is New York style or Chicago style. If you want to know more detail, please download the sample and refer to the source code. At last, the codes of our PizzaFactory and his subclasses are as below:

public abstract class PizzaFactory

{

public abstract Pizza CreatePizza(IPizzaIngredientFactory ingredientFactory);

}

public class CheesePizzaFactory : PizzaFactory

{

public override Pizza CreatePizza(IPizzaIngredientFactory ingredientFactory)

{

return new CheesePizza(ingredientFactory);

}

}
ClarmPizzaStore and PepperoniPizzaStore are similar to CheesePizzaFactory.

Then we must modify the CreatePizza() method in the PizzaStore family:

public class NYPizzaStore : PizzaStore

{

protected override Pizza CreatePizza(PizzaFactory pizzaFactory)

{

IPizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();

return pizzaFactory.CreatePizza(ingredientFactory);

}

public class ChicagoPizzaStore : PizzaStore

{

protected override Pizza CreatePizza(PizzaFactory pizzaFactory)

{

IPizzaIngredientFactory ingredientFactory = new ChicagoPizzaIngredientFactory();

return pizzaFactory.CreatePizza(ingredientFactory);

}

Of course we should modify the OrderPizza() method in the base class of PizzaStore like this:

public Pizza OrderPizza(PizzaFactory pizzaFactory)

{

Pizza pizza;

pizza = CreatePizza(pizzaFactory);

pizza.Prepare();

pizza.Bake();

pizza.Cut();

pizza.Box();

return pizza;

}

Great! we have eliminated the terrible switch statment in the CreatePizza() method. At the same time, it became to simple and clear. The most important thing is that the structure is more flexible than before. If we want to produce the new kind of Pizza, we only add the factory class for new Pizza. We don't need modify the existed class family of PizzaStore any more.

Easier and more convenient

wayfarer — Thu, 15 Dec 2005 02:26:00 GMT

If you want to determine if string b is substring of string a, you must write the code line in C# 1.0 or 1.1 as below:
if (a.IndexOf(b) != 0) {//...}

But it is easier and more convenient in C#2.0, like this:
if (a.Contains(b)) {//...}

If you want to determine if string s is null or empty, the logic expression using C# 1.0 or 1.1 is very complex:
if (s == null || s.Length == 0) {//...}

But it is easier and more convenient in C#2.0, like this:
if (String.IsNullOrEmpty(s)) {//...}

Why is it static method of IsNullOrEmpty() method instead of dynamic method,? Otherwise we can invoke it like this:
if (s.IsNullOrEmpty()) {//...}
It is easier than what we invoke with static method, but in fact, it will throw the NullReferenceException. So static method is the right choice.

C# Language Specification

wayfarer — Thu, 15 Dec 2005 01:16:00 GMT

If you want to learn about the new feature of C# 2.0, this document is the best choice: C# Language Specification 2.0, March 2005 Draft.

It introduces all new feature of C# 2.0 including Generics, Anonymous Methods, Iterators, etc. It is very useful and free.

If you are new guy for C#. Don't worry, there is some free resources for you too. You may refer to this document which link is C# Language Specification 1.2. It is a very excellent material and an official C# guide book provided by Microsoft Corp. Don't need buy the technical book about C# if you own it.

Don't hesitate, download and read them.

Using AppDomain.CreateInstance() method

wayfarer — Wed, 14 Dec 2005 06:32:00 GMT

Suppose my assembly's full name is: MyModule, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, can we create the instance using AppDomain.CreateInstance() method like this:
AppDomain domain = AppDomain.CurrentDomain;
domain.CreateInstance("MyModule, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", "MyType");

Absolutely no, even this assemby is current assembly or is added be dependent assembly. If you have done, it would throw the exception which message is "Could not load file or assembly 'MyModule, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null' or one of its dependencies. The system cannot find the file specified.". In this case, we must load it when AppDomain resolve the name of it. Suppose the assembly file is MyModule.dll, we may consume the AssemblyResolve Event:
try
{
      AppDomain domain = AppDomain.CurrentDomain;
      domain.AssemblyResolve += new ResolveEventHandler(LoadAssemblyHandler);
      Object obj = domain.CreateInstance("MyModule, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", "MyType").Unwrap();
}
catch (Exception ex)
{
       Console.WriteLine(ex.Message);
}

private Assembly LoadAssemblyHandler(object sender, ResolveEventArgs args)
{
      return Assembly.LoadFrom("MyModule.dll");
}

If I develope the program using .Net Framework 2.0, We'd better replace the event binding with anonymous methods:
domain.AssemblyResolve += new ResolveEventHandler(delegate()
                                                                                    {
                                                                                             return Assembly.LoadFrom("MyModule.dll");
                                                                                    });
Easier than before, isn't it?

Change the Schema and Restart My Blog

wayfarer — Wed, 14 Dec 2005 06:23:00 GMT

I nearly dump my blog because of my lazy. Now I decide to restart my blog, so I changed my blog's schema as the start point. I will record my gain and experience during developing software project and learning programing.

Debug And Release in Visual Studio.Net 2003®

wayfarer — Tue, 21 Dec 2004 11:55:00 GMT

Don't forget to change the debug mode to the release in Visual Studio.Net 2003^® before you compile and publish your project.

I didn't realize the difference between these until I read the K. Scott Allen's article which title was Get a Charge From Statics with Seven Essential Programming Tips, published on the MSDN Magazine January. He intruduced some tips of the statics in .Net. One of these, if you want to initialize the static field, there are two scenarios: “The first scenario is when a developer explicitly adds a type constructor using the Shared keyword on a New subroutine in Visual Basic, or by adding a static, parameterless method with the same name as the type in C#. The second scenario is when a type has a initializer for a static field, in which case the compiler adds a type constructor behind the scenes.”[Scott]

There was an example in his article written by VB.Net, and I translated it into C#. The source code is following:

using System;
namespace Exceptions
{
class Class1
{
private static int max = Int32.MaxValue - 1;
[STAThread]
static void Main(string[] args)
{
TestStaticPropertyAccess();
Console.ReadLine();
}

static void TestStaticPropertyAccess()
{
   DateTime begin = DateTime.Now;
   for (int i=0;i<max;i++)
   {
    string message = ExplicitConstructor.Message;
   }
   PrintResult(DateTime.Now.Subtract(begin),"ExplicitConstructor");

   begin = DateTime.Now;
   for (int i=0;i<max;i++)
   {
    string message = ImplicitConstructor.Message;
   }
   PrintResult(DateTime.Now.Subtract(begin),"ImplicitConstructor");
}

static void PrintResult(TimeSpan span,string result)
{
Console.WriteLine("{0} took {1} ms.",result,span.Milliseconds);
}
}

class ExplicitConstructor
{
private static string message;

static ExplicitConstructor()
{
message = "Hello World";
}

public static string Message
{
get { return message; }
}
}

class ImplicitConstructor
{
private static string message = "Hello World";

public static string Message
{
get { return message; }
}
}

He told us: “the first loop (with ExplicitConstructor) executes approximately eight times slower than the second loop (with ImplicitConstructor).” So I tried it, but I got the opposite result. Why? What happen? I couldn't get the right answer, so I had to mail Scott. Soon he answered my stupid question. The reason was the difference between Debug and Release mode in Visual Stuio.Net 2003^®.

His mail script is :

Hi Bruce:

I'm glad you enjoyed the article. Thank you for the kind note.

A couple thing to check:

1. Make sure you compile the program in release mode
2. Make sure to run the program outside of the IDE.

Those two steps make sure the program is in release and has full optimizations.

Oh, my god, I forget it can optimize the performance when your programs are in the release mode. Thank Scott!

I got a mywallop account today

wayfarer — Tue, 14 Dec 2004 10:55:00 GMT

A couples of day ago, my friend gave me an invitation from http://www.mywallop.com. But I was very busy these days, I didn't forget it nearly until the wallop sent a mail to me and informed me that the invitation would be expired in 3 days.

After I registered it and entered the homepage of wallop, I was very surprised by its very nice ang great features. Inconceivably, all these were disigned by Flash. Through it, you can share the photos and music with your friends, and communicated with them online. You can registered your blog also. In a word, the wallop is very nice. You should register it as fast as you can, and enjoy it by yourself.

Btw: I have five invitations now. So if you want, contact me please:)

I Quit my Job

wayfarer — Fri, 12 Nov 2004 01:54:00 GMT

Today I quitted my job, and I will move another city and work in another corporation after a couple of days. I hope this decision can turn my life into better.

Check Channel Before Registering the New Channel in .Net Remoting

wayfarer — Tue, 02 Nov 2004 08:39:00 GMT

I don't understand what happen when I was prepared to register the new channel. It always warned the Channel had been used. I am clear that we can't use the same channel repeatedly in .Net Remoting, however I didn't use any channel before registering it. Even I restarted my computer, ran my project then, it occurred also. Oops, it's so terrible, isn't it? I don't know the reason that the exception was thrown, but fortunately, I can solve it.

That is, when you are going to register the new channel, you might check the channel:

if (ChannelServices.RegisteredChannels.GetLength(0) > 0)
{
    foreach (IChannel channel in ChannelServices.RegisteredChannels)
    {
        ChannelServices.UnregisterChannel(channel);
    }
}

//registering the new channel now.
TcpChannel newChannel = new TcpChannel(8080);

//...

So, if there are some channels have been used by some application, it can unregister them by ChannelServices.UnregisterChannel(). Maybe, you should remember checking it before registering the new channel, don't you think so?

There are some tips about C# Written By Andrew Troelsen

wayfarer — Sat, 23 Oct 2004 12:27:00 GMT

General Tips and Tricks for C# developers

Bruce Zhang

Handling Distributed Transactions In Visual Studio 2005

Encapsulation of Change (Part One)

My Workspaces

Terrible Harddisk

My Plan

Switch Statement is the poison resulting in Stiff

Easier and more convenient

C# Language Specification

Using AppDomain.CreateInstance() method

Change the Schema and Restart My Blog

Debug And Release in Visual Studio.Net 2003®

I got a mywallop account today

I Quit my Job

Check Channel Before Registering the New Channel in .Net Remoting

There are some tips about C# Written By Andrew Troelsen

Preprocess Win32 Messages through Windows Forms

Be Mindful of the References / 'using' / Manifest Relationship

Activate 'Full Screen Mode' During your Source Code Editing

Leverage the C# Preprocessor

Avoiding Type Name-Clashes using 'using'

Build 'Consistent' .NET assemblies with FxCop

Simplified Interface Implementation a la VS .NET 2003

Simplified Event Handling a la VS .NET 2003

Integrate ildasm.exe into VS .NET 2002

Add Custom .NET Assemblies to the Add Reference Dialog