Microsoft Technologies

Threading and Perception

2010-03-26T10:34:00.000-07:00

Today I thought to tell you something on one of the most complex part of .NET Framework I.e. Threading. I was discussing some of the issues with one of our team member on threading today;

from taking inspiration on that conversion; here are the facts of .NET Threading....

.NET Thread object is "ACTUALLY" not created by .NET; its Operating level thread we are just getting a decorated version of that thread. When we talk about Thread; we must remember the thread pool. The thread pool is just a wrapper class of OS Level thread pool which is optimized for faster allocating/deal locating the memory and thread data. While taking back used thread from user application the same class is also responsible to cleared off the data. This is the internal operation; as a user we don't need to care about it.

The second fact is: some of the blogs (NOT MSDN) mentioned that when you write the code something like:

Thread t = new Thread(DoSomething);

Its actually not a part of ThreadPool and its creating new thread; which may be right in a way. But this is not the fully truth. If we believe on the blog for an instance; we may not get duplicate thread ever. Now here i am no going in depth of Allocation thread memory, execution etc. but let me tell you one point; even if you write above statement in .NET; it serves the thread object from Pool only. I know you will not believe this fact.

I have created an example which works on above assumption have a look once.. its interesting to see. I am creating thread using above code and some times i am getting new thread (Displayed in White Font) and some times i get duplicate thread (Displayed in Yellow Font). It proves that internally .NET is keeping a pool of thread.

The second point; In example;I have also set some data on fresh thread each time. Which I am trying to recover when I get the duplicate thread object. And look at the result; The Thread Slot is still there; but .NET erased the data.

In summery you can say that:

1. Thread object never created/destroyed from .NET Managed Env. user always gets the thread object from pool only.

2. The data you associates with thread (In terms of Thread Slots and ThreadStatic variables) are not persisted on the thread when .NET collects the unused thread for pooling.

When Thread Slots are getting cleared off; there is no question to persist the value of ThreadStatic variables.

Now talking about WCF execution; like this example when you open the WCF Service Channel/Port; it takes one of the available thread from same pool and starts the execution of the code using the thread. You can never get the older data associated with associated with thread earlier. So its perfectly safe to use ThreadStatic variables.

This was about console application; lets take ASP.NET application in consideration. .NET takes thread from ThreadPool to execute the request. This thread is persisted in ThreadPool even though the values of ThreadStatic variables are not getting persisted.

Check-out my ASP.NET example and observe thread static behavior in PageLoad method.

In short; make the best use of ThreadStatic without any fear.

Google says Good Bye to China

2010-03-25T00:08:00.000-07:00

Google has executed its first step towards closer of their China Operations (Google Search, Google News and Google Images mainly).

Users visiting Google.cn are now being redirected to Google.com.hk, where google offers uncensored search in simplified Chinese, specifically designed for users in mainland China and delivered via our servers in Hong Kong.

Google.cn is now Google.com.hk

--
Kaushal Patel

Playing with Generic List

2010-03-09T22:11:00.001-08:00

Generic List a new feature provided by .NET 2.0 and above which can be declared as follow: List<string> lstString = new List<string>();
Creating Generic Object using Reflection
Now; there is nothing now in this. And we all know that the generics are type safe. That means you can not pass Child object's referece (Without type casting) where the base class is expected. In case if you need to create Generic List object dynamically depending upon your business scenarios you can use Reflection API to create generic object.

Lets see how to do this:

public static object CreateGenericObject(Type genericType, Type innerType, params object[] args)

{

System.Type speType = genericType.MakeGenericType(new System.Type[] { innerType });

return Activator.CreateInstance(speType, args);

}

And your client code would be as follows:

object geneticListObject = CreateGenericObject(typeof(List<>),typeof(int));

Now lets see one more feature of .NET 2.0 i.e. Inline functions (anonymous methods):

Lets assume you have a generic collection of objects (lets assume student); and you want to search on Student Name starting with "K". You dont need to make another call to the server for this. Here is the code for the same:

List<Student> localStudentList = mainStudentList.FindAll(delegate(Student student)
{
return student.StudentName.StartsWith("K");
});

the above code will return the list of students (in localStudentList object) whose name starts with K.To extends this you can write various AND and OR conditions. Isn't this good?

--
Kaushal Patel

Contact Me

BCL new features of the .NET Framework 4.0 Beta 2

2010-03-03T23:13:00.001-08:00

Visual Studio 2010 and .NET Framework 4 Beta 2 are now available to download. .NET 4 Beta 2 contains various newly introduced BCL features and enhancements in addition to what was included in the earlier version of .NET Framework 4.0 Beta 1. Many of these enhancements were added in large part due to specific feedback and suggestions reported by customers through Microsoft Connect.

New BCL Features in .NET Framework Beta 2.0

Complex Number
Location
Stream Copy (Stream.CopyTo)
IObservable<T>
Enum.HasFlag
String.Connect & String.Join
String.IsNullOrWhiteSpace
TryParse (In Guid, Version and Enum)
Addition Environment.SpecialFolder, Environment.Is64BitProcess and Environment.Is64BitOperatingSystem
Path.Combine with params support
ObservableCollection<T> is now part of System.DLL
Int Pointer operations (IntPtr and UIntPtr Subtraction operators)
StringBuilder.Clear
ServiceInstaller.DelayedAutoStart
StopWatch.Restart

-- Kaushal Patel

Contact Me

Task Parallel Library Sample is out now!!!

2010-03-03T09:08:00.001-08:00

Microsoft .NET Framework 4.0 TPL (Task Parallel Library) sample is out now. This sample has been created in .NET Framework 4.0 Beta 2

Click here to get the newest feature of .NET Framework 4.0

Microsoft Blue & Me

2010-01-26T05:18:00.001-08:00

Blue&Me is a information & entertainment system that specially designed for Fiat Group cars as a part of Microsoft Auto initiatives and developed in a partnership which was started end of 2004 between Magenti (a Fiat group company) and MSFT. The system is based on modular structure which allows installation and use of uninformed services. The system offers various connectivity options like Bluetooth, USB, Mobile Phones, your personal media player along with hands-free operations allowing you to control all features by voice commands, using speech technology from Nuance Comm With the help of Magneti the system is developed to be compatible with most mobile phones and media players Blue&Me Nav is a next version of the same OS which adds GPS related features.

In india this os and its capabilities are not well known; at the Bologna Motor Show 2009, Fiat presented a new portable navigation unit addition to the Blue&Me system called Blue&Me Map. Exclusive for and to Fiat Professional's light commercial vehicles.

Visual Studio 2010 Beta 2

2010-01-01T01:37:00.000-08:00

On the new years eve; microsoft launched its one of the major and popular development studio i.e Visual Studio 2010. Still its early to discuss the features and improvements that VS.NET 2010 provides. But keep watching this space for more on VS.NET 2010 in coming days.

To download VS.NET 2010 with .NET Framework Beta 4.0

Different ways to Implement the Singleton in .NET

2009-12-28T18:38:00.001-08:00

Lots of blogs and sites are talking about the ways to implement the singleton in different ways; and surprisingly many of them some times miss the thread safety or the thread sync. According to the "Design Patterns: Elements of Reusable Object-Oriented Software" the implementation of Singleton should be as follow:

The above implementation may work well considering that singleton implementation can be breakable at the first call. In "GetInstance" method we are checking "instance == null" which returns true when 2 requests comes at the same time at the first call. Plus we are not taking the advantage of the .NET language features. Here is the thread safe implementation of Singleton in .NET C# language.

Here you need to watch the usage of volatile (One can consider the implementation of "volatile" exactly opposite of "ThreadStatic" keyword) and static keyword gives the grantee to be thread safe in .NET compilation. (According to Jeffrey Richter).

Microsoft Dublin & Velocity

2009-12-16T06:34:00.000-08:00

Microsoft Windows Server AppFebric (Dublin and Velocity) is a bundle of integrated technologies which makes easier to develope, extend and manage the web and composite application that runs on IIS.

If you are searching for the Windows Azure platform AppFabric, which helps developers connect apps and services between Windows Azure and on-premises deployments, see the Windows Azure site.

What is Dublin?

Dublin enriches Windows Server to give enhanced hosting and management capabilities for WCF and WF services. Dublin also adds service management extensions to the hosting features of Internet Information Services (IIS) and Windows Activation Service (WAS), and the run-time components and services of the .NET Framework 4. Dublin addresses the challenges of hosting WCF- and WF-based applications by making it easier to deploy, configure, and manage applications.

Typically in Service Oriented Architecture people are building the service for the different operations and exposes these services to the consumer to consume. Since WCF and WF released; the deployment, monitoring and scaling these services never been an easy task. Some times to consuming these service it self a trouble making task. With the help of Dublin we can perform these tasks almost effortless. Dublin can be easily introduced through IIS management console using the Dublin module of Windows Power Shell.

What is Velocity?

Velocity is a highly scalable in-memory caching mechanism using which one can improve the performance of the application with all types of data. For any application one can leverage the Velocity rather then writing new caching schema. Velocity comes with Dublin; the same setup programme installs Velocity and Dublin.

For more details about the architecture details please Click Here!!

Keep watching this space for more technical updates.

Microsoft released Web Platform Installer 2.0

2009-12-16T04:57:00.001-08:00

Commonly known as Web PI; a tool that makes user life easier to sync up with the latest updates for the MS products like Internet Information Services (IIS), Visual Web Developer, .NET Framework, SQL Server Express Edition etc. (List goes on and on and on......). The Web PI has Windows Web Application Gallery using which you can users can have pleasant experience whle blogging. It also provides the support for Content Management Activities.

For downloading Web PI 2.0 Click Here!!

For more technical updates and latest technology news keep watching this space,

All about WCF (Introduction)

2009-06-30T10:00:00.001-07:00

Here in my first series of article I will be sharing top to bottom of the WCF (The Indigo).

WCF is the great way to approach large multi-system message based communication. It seamlessly support Transaction Management, Security Implementation, Exception and Fault handling. Concurrency management etc.

Usage of WCF comes with the great amount of flexibilities' to handle. WCF is a framework for services. The user can Create, Configure, Host and consume the services. All the services are mutually agreed on SOAP concept and communicating between WCF based clients.

WCF has mainly two categories of classes:

1. Service Model Class (Handles Service Configurations & Validations).

2. Channel Classes (Handles mode of communication and related functionalities).

Each WCF service can be associated with one ore more service endpoints. One service can be hosted in WCF with different mode of communication channel. Depending upon the usage and target client WCF Service can be configured (I will focus this more on this in my up coming articles).

Configuring endpoints require (A, B & C):

1. Address ('A') = Where?

2. Binder ('B') = How?

3. Contract ('C') = What?

Address: The address means the URL/URI where the service is located. Where is the service located?
Binder: The mode ofcommunication. How to communicate with the service?
Contract: The Service. What is my service?

With the XML Based configuration approach OR with the help of coding we can configure the endpoints.

Hosting WCF Service

WCF Service is can be segregated in to two parts normally:

1. Service Contract

2. Service Implementation

Service Contract:

Service Contract is just the collection of functionality that Service will be exposed. In a way you can assume that a Service Contract is just like the interfaces in .NET.

For example

In above example, I have created a sample service with just one operation i.e. MyOperation with one parameter. As you can see i have used Attributes. ServiceContract attributes comes under System.ServiceModel. Including this DLL as in reference list is must for WCF Service Host and WCF Consumer.

You can create multiple operations by using "OperationContract" attribute. By specifying OperationContract attribute means the operation will be available for WCF Service and the WCF client can consume that.

Service Implementation:

As named Service implementation is the implementation bin of WCF Service Contract. You can implement this WCF Service Interface in 'N' number of classes.

For example

In above example I have created "HelloIndigoService" which is implementing our "IHelloIndigoService" service interface.

WCF Service can be self-hosted service but to start with we will see simple .NET consol based hosting mechanism.

Attributes of Service Contract

Using declarative model you can apply different parameters (as per your requirements) on WCF Service Contract:

CallbackContract

User can specify the call-back service that represents opposite service contract in duplex message exchange.

Example

ConfigurationName

User can specify the pre-created configuration name which is/are defined in Application's configuration file.

Example

Name:

Name property is impacting on WSDL generation. With the help of this property user can specify XML Root Tag name of WSDL. Unlike the older messaging mechanisms, WCF provides great deal of control over WSDL generation. I will discuss more about forming the WSDL with OperationContract later in this article.

Example

Namespace:

Namespace is also related with WSDL formation. After you generated the proxy of WCF Service; the given namespace will be appear in WSDL Namespace.

Example

ProtectionLevel:

User needs to use ProtectionLevel according to their service requirements and the operations that service will be exposing. There are three different ProtectinLevels are available.

1. None:

2. Sign: The protected part is signed digitally to ensure the temper less submission of data

3. EncryptAndSign: This will encrypt data before sighed it digitally.

More details on ProtectionLevel : http://msdn.microsoft.com/en-us/library/aa347692.aspx

SessionMode:

Specifying the attribute with "Allowed", "NotAllowed" and "Required". As name says "NotAllowed" will not support Session. The main difference between "Allowed" and "Required" is: "Allowed" will support Session persistent if incoming binding supports. Where as "Required" will throw an error in case binding is not supporting.

ASP.NET Cookieless Session [Pros & Cons]

2009-03-13T20:46:00.000-07:00

Enter Cookieless Sessions

you don't have to change anything in your ASP.NET application to enable cookieless sessions, just enter sessionState cookieless="true" in your web.config.

Internal Implementation of Cookieless Session in ASP.NET

The implementation of cookieless sessions includes couple of runtime modules:

1. 1. SessionStateModule [A standard session HTTP Module]
2. Aspnet_filter.dll [Works as an executable]

Once the HTTP Request come at the server, a small piece of Win32 code works as an ISAPI filter. HTTP modules and ISAPI filters are in opinion of the same concept, except that HTTP modules are created by the managed code and require ASP.NET and CLR to trigger and work. Classic ISAPI filters like aspnet_filter.dll are invoked by IIS. Both capture IIS events fired during the processing of the request.

When the first request of a new browser session comes at server to process, the SessionStateModule reads about the cookie support in the web.config file [By default “machine.config” specifies cookie enabled session]. If the “cookieless” attribute of the section is set to true, the module generates a new session ID, twists the URL by appending the session ID just before the requested page name, and redirects the browser to the newly created URL using the “HTTP 302 command”.

When each request reaches at the IIS boundary—far before it is handed over to ASP.NET—aspnet_filter.dll is given a chance to look at it. If the URL appends a session ID in parentheses, then the session ID is extracted and copied into a request header called AspFilterSessionId. The URL is then rewritten to exactly like the originally requested resource and let go. This time the ASP.NET session state module retrieves the session ID from the request header and proceeds with session-state binding.

The cookieless mechanism works great as long as the URL contains information that can be used to obtain the session ID. As you'll see in a moment, this poses some usage restrictions.

Let's review the pros and cons of cookieless sessions.

Advantages of Cookieless Session

In ASP.NET, session management and forms authentication are the only two system features that use cookies under the hood. With cookieless sessions, you can now deploy stateful applications that work regardless of the user's preferences about cookies. As of ASP.NET 1.x, though, cookies are still required to implement forms authentication. The good news is that in ASP.NET 2.0 forms authentication can optionally work in a cookieless fashion.

Another common reason advanced against cookies is security. This is a point that deserves a bit more attention.

Cookies are inert text files and as such can be replaced or poisoned by hackers, should they gain access to a machine. The real threat lies not much in what cookies can install on your client machine, but in what they can upload to the target site. Cookies are not programs and never run like programs; other software that gets installed on your machine, though, can use the built-in browser support for cookies to do bad things remotely.

Furthermore, cookies are at risk of theft. Once stolen, a cookie that contains valuable and personal information can disclose its contents to malicious hackers and favor other types of Web attacks.

Disadvantages of Cookieless Session

By looking the advantages of cookieless session we should not reach on any conclusion: Considering security aspect, your cookieless sessions are easier to hack in compare. Session Hijacking can act against this approach.

In brief, session hijacking occurs when an attacker gains access to the session state of a particular user. Basically, the attacker steals a valid session ID and uses that to get into the system and snoop into the data. One common way to get a valid session ID is stealing a valid session cookie. That said, if you think that cookieless sessions put your application on the safe side, you're deadly wrong. With cookieless sessions, in fact, the session ID shows up right in the address bar

With cookieless sessions, stealing session IDs is easier than ever.

Using cookieless sessions also raises issues with links. For example, you can't have absolute, fully qualified links in your ASP.NET pages. If you do this, each request that originates from that hyperlink will be considered as part of a new session. Cookieless sessions require that you always use relative URLs, like in ASP.NET postbacks. You can use a fully qualified URL only if you can embed the session ID in it. But how can you do that, since session IDs are generated at run time?

The following code breaks the session:

Click

To use absolute URLs, resort to a little trick that uses the ApplyAppPathModifier method on the HttpResponse class:

href= >Click

The ApplyAppPathModifier method takes a string representing a URL and returns an absolute URL that embeds session information. For example, this trick is especially useful in situations in which you need to redirect from a HTTP page to an HTTPS page.

Google Talk Hacks

2009-03-13T02:32:00.001-07:00

You can edit most settings by opening regedit and by selecting HKEY_CURRENT_USER/Software/Google/Google Talk.
Accounts: This one has subkeys for different accounts that has logged in on the your PC. These keys have different values that store the username, password and connection options.
Options: This is the most interesting part of GTalk, where most of the current hacks should be used.

1. HKEY_CURRENT_USER\Software\Google\Google Talk\Options\show_pin If "1", shows a "pin" next to the minimize button that keeps the windows on top of all the other open windows when clicked.

2. HKEY_CURRENT_USER\Software\Google\Google Talk\Options\view_show_taskbutton If "0", hides the taskbar button, and leaves the tray icon only, when the window is shown

3. HKEY_CURRENT_USER\Software\Google\Google Talk\Options\away_inactive If "1", status will be set as Away after the specified number of MINUTES.

4. HKEY_CURRENT_USER\Software\Google\Google Talk\Options\away_screensaver If "1", status will be set as Away after the specified number of MINUTES.

5. HKEY_CURRENT_USER\Software\Google\Google Talk\Options\inactive_minutes Number of inactive MINUTES to become away if auto-away is on.

Use multiple-identities with GTalk:

1. Right-click on the desktop

2. Select New

3. Select Shortcut

4. Paste this into the text box: ("C:\Program Files\Google\Google Talk\googletalk.exe" /nomutex )
5. Click Next and choose a shortcut name like "GTalk New Instance".

Here you go.... try to execute this newly created short-cut and use your alternate GTalk ID.

/nomutex, which allows you to run more than one instance of GT.
/autostart, when Google Talk is run with this parameter, it will check the registry settings to see if it needs to be started or not. If the "Start automatically with Windows" option is unchecked, it won't start.
/forcestart, same as /autostart, but forces it to start no matter what option was set.
/S upgrade, Used when upgrading Google Talk
/register: registers Google Talk in the registry, includig the GMail Compose method.
/checkupdate: check for newer versions
/plaintextauth: uses plain authentication mechanism instead then Google's GAIA mechanism. Used for testing the plain method on Google's servers.
/nogaiaauth: disables GAIA authentication method. The same as above.
/factoryreset: set settings back to default.
/gaiaserver domain.com: uses a different GAIA server to connect to Google Talk. Used for debug purposes only, there are no other known GAIA servers.
/mailto emailid@domain.com: send an email with Gmail
/diag: start Google Talk in diagnostic mode
/log: probably has something to do with the diagnostic logging

To add these, open up your GTalk shortcut, and where it says "Target:" add one or more of these inside the quotations, but after the .exe part

CX1 (A super comp from Cray) will have Windows HPC Server 2008

2008-09-16T23:25:00.001-07:00

Microsoft and Cray on Tuesday took the wraps off a petite supercomputer that runs Windows HPC Server 2008 and, unlike some other supercomputers, doesn't cost more than a Hummer limo.

In fact, Cray's new CX1 supercomputer is priced starting at a relatively cheap $25,000, not bad for an integrated box that weaves together compute, storage, and visualization functions. Cray has designed the CX1 to remove some of the complexity involved with supercomputing that has hindered its adoption, particular in smaller organizations.

Based on 64-bit Windows Server 2008, Windows HPC Server 2008 can scale to thousands of processing cores and features high end management capabilities that span both Windows and Linux platforms. The CX1 uses up to 8 nodes and 16 Intel Xeon processors, with up to 64 gigabytes of memory per node; and also includes up to 4 terabytes of internal storage.

The CX1 is the first Cray supercomputer to use Intel processors, and is also the first fruit from the pact the two companies announced in April to work together on supercomputing systems and technologies over the next few years.

The CX1 is available through Cray's Website and comes with a three-year warranty that includes next-day, on-site Cray-certified support.

Supercomputers help power research in a wide variety of fields, including aerospace, astrophysics, bioinformatics, chemical physics, climate change prediction, medical imaging and the global ATLAS project, which is investigating the forces that govern the universe.

T-Mobile to announce G-Phone late sept.

2008-09-16T23:21:00.001-07:00

T-Mobile USA will become the first company in the world to announce a mobile phone based on Google's Android OS at a New York press conference Sept. 23, the New York Times reports, citing T-Mobile.

The handset was manufactured by Taiwan's High Tech Computer (HTC), the Times said. HTC representatives in Taipei declined to comment on the report.

Several other Web sites are also reporting the Sept. 23 event, including Gizmodo, which is displaying what appears to be an announcement from T-Mobile.

HTC has already said it is developing a mobile phone developed around Google's Android and plans to call the handset "Dream."

The handset maker may end up being first in the world to put out an Android-based mobile phone, but other companies are also developing handsets around Android, including Samsung Electronics.

HTC's Google handset is just over 5-inches long and 3-inches wide, with a keypad underneath the screen that either slides out or swivels out. The aim of the keypad is for easy e-mail, note-taking and writing Web addresses.

Internet navigational controls are situated below the screen on the handset.

Android is an open source software platform that includes an OS and is designed to take advantage of Internet services for mobility. The software could become a potent new rival to Windows Mobile and other handset operating systems. At the launch ceremony early this year, Google announced that over 30 companies had joined the Open Handset Alliance.

Microsoft Introduces Zermatt [A Claim-based identity model]

2008-08-13T09:39:00.001-07:00

Most developers are not security experts and many feel uncomfortable being given the job of authenticating, authorizing, and personalizing experiences for users. It's not a subject that has been traditionally taught in computer science curriculum, and there's a long history of these features being ignored until late in the software development lifecycle.

It's not surprising nowadays to see a single company with tens or hundreds of web applications and services, many of which have their own private silo for user identities, and most of which are hardwired to use one particular means of authentication. Developers know how tedious it is to build identity support into each application, and IT pros know how expensive it is to manage the resulting set of applications.

One very useful step toward solving the problem has been to centralize user accounts into an enterprise directory. Commonly it's the IT pro that knows the most effective and efficient way to query the directory, but today the task is typically left up to the developer. And in the face of mergers, acquisitions, and partnerships, the developer might be faced with accessing more than one directory, using more than one API.

In the Microsoft .NET Framework, there are lots of different ways of building identity support into an application, and each communication framework treats identity differently, with different object models, different storage models, and so on. Even in ASP.NET, developers can get confused about where they should look for identity: should they look at the HttpContext.User property? What about Thread.CurrentPrincipal?

The rampant use of passwords has lead to a cottage industry for phishers1. And with so many applications doing their own thing, it's difficult for a company to upgrade to stronger authentication techniques.

What is Zermatt All About?

Zermatt is a set of .NET Framework classes; it is a framework for implementing claims-based identity in your applications. By using it, you'll more easily reap the benefits of claims-based systems described in this paper. Zermatt can be used in any web application or web service that uses the .NET Framework version 3.5.

Download : Zermatt Dev. Whitepaper

WPF Namespace Poster

2008-06-12T07:15:00.000-07:00

.NET Coding Guidelines

2008-06-12T06:48:00.001-07:00

1. Tabs & Indenting

Avoid tab characters (\0x09) usage in code. 4 Space charactors should be use unsteade.

2 Bracing

Open braces should always be at the beginning of the line after the statement that begins the block. Contents of the brace should be indented by 4 spaces. For example:

if (someCondition)
{
DoSomething();
}
else
{
DoSomethingElse();
}

"case" statements should be indented from the switch statement like this:

switch (someExpression)
{

case 0:
DoSomething();
break;

case 1:
DoSomethingElse();
break;

case 2:
{
int n = 1;
DoAnotherThing(n);
}
break;
}

Braces should never be considered optional. Even for single statement blocks, you should always use braces. This increases code readability and maintainability of your code.

3 Single line statements

Single line statements can have braces that begin and end on the same line.

public class Foo
{
int bar;

public int Bar
{
get { return bar; }
set { bar = value; }
}

}

It is suggested that all control structures (if, while, for, etc.) use braces, but it is not required.

4 Commenting

Comments should be used to describe intention, logical as well as execution flow, algorithmic overview. It would be ideal, if from reading the comments alone, someone other than the author could understand a function's intended behavior and general operation. While there are no minimum comment requirements and certainly some very small routines need no commenting at all, it is hoped that most routines will have comments reflecting the programmer's intent and approach.

Copyright notice

Each file should start with a copyright notice. To avoid errors in doc comment builds, you don't want to use triple-slash doc comments, but using XML makes the comments easy to replace in the future. Final text will vary by product (you should contact legal for the exact text), but should be similar to:

//-----------------------------------------------------------------------
// <copyright file="ContainerControl.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------

Documentation Comments

All methods should use XML doc comments. For internal dev comments, the <devdoc> tag should be used.

public class Foo
{

/// <summary>Public stuff about the method</summary>
/// <param name="bar">What a neat parameter!</param>
/// <devdoc>Cool internal stuff!</devdoc>
///
public void MyMethod(int bar) { … }

}

However, it is common that you would want to move the XML documentation to an external file – for that, use the <include> tag.

public class Foo
{

/// <include file='doc\Foo.uex' path='docs/doc[@for="Foo.MyMethod"]/*' />
///
public void MyMethod(int bar) { … }

}

UNDONE§ there is a big doc with all the comment tags we should be using… where is that?

Comment Style

The // (two slashes) style of comment tags should be used in most situations. Where ever possible, place comments above the code instead of beside it. Here are some examples:

// This is required for WebClient to work through the proxy
GlobalProxySelection.Select = new WebProxy("http://itgproxy/");

// Create object to access Internet resources
//
WebClient myClient = new WebClient();

Comments can be placed at the end of a line when space allows:

public class SomethingUseful
{
private int itemHash; // instance member
private static bool hasDoneSomething; // static member
}

5 Spacing

Spaces improve readability by decreasing code density. Here are some guidelines for the use of space characters within code:

Do use a single space after a comma between function arguments.
Right: Console.In.Read(myChar, 0, 1);
Wrong: Console.In.Read(myChar,0,1);
Do not use a space after the parenthesis and function arguments
Right: CreateFoo(myChar, 0, 1)
Wrong: CreateFoo( myChar, 0, 1 )
Do not use spaces between a function name and parenthesis.
Right: CreateFoo()
Wrong: CreateFoo ()
Do not use spaces inside brackets.
Right: x = dataArray[index];
Wrong: x = dataArray[ index ];
Do use a single space before flow control statements
Right: while (x == y)
Wrong: while(x==y)
Do use a single space before and after comparison operators
Right: if (x == y)
Wrong: if (x==y)

6 Naming

Follow all .NET Framework Design Guidelines for both internal and external members. Highlights of these include:

Do not use Hungarian notation
Do not use a prefix for member variables (_, m_, s_, etc.). If you want to distinguish between local and member variables you should use "this." in C# and "Me." in VB.NET.
Do use camelCasing for member variables
Do use camelCasing for parameters
Do use camelCasing for local variables
Do use PascalCasing for function, property, event, and class names
Do prefix interfaces names with "I"
Do not prefix enums, classes, or delegates with any letter

The reasons to extend the public rules (no Hungarian, no prefix for member variables, etc.) is to produce a consistent source code appearance. In addition a goal is to have clean readable source. Code legibility should be a primary goal.

7 Naming Conventions

Interop Classes

Classes that are there for interop wrappers (DllImport statements) should follow the naming convention below:

NativeMethods – No suppress unmanaged code attribute, these are methods that can be used anywhere because a stack walk will be performed.
UnsafeNativeMethods – Has suppress unmanaged code attribute. These methods are potentially dangerous and any caller of these methods must do a full security review to ensure that the usage is safe and protected as no stack walk will be performed.
SafeNativeMethods – Has suppress unmanaged code attribute. These methods are safe and can be used fairly safely and the caller isn't needed to do full security reviews even though no stack walk will be performed.

class NativeMethods
{
private NativeMethods() {}

[DllImport("user32")]
internal static extern void FormatHardDrive(string driveName);
}

[SuppressUnmanagedCode]
class UnsafeNativeMethods
{
private UnsafeNativeMethods() {}

[DllImport("user32")]
internal static extern void CreateFile(string fileName);
}

[SuppressUnmanagedCode]
class SafeNativeMethods
{
private SafeNativeMethods() {}

[DllImport("user32")]
internal static extern void MessageBox(string text);
}

All interop classes must be private, and all methods must be internal. In addition a private constructor should be provided to prevent instantiation.

8 File Organization

Source files should contain only one public type, although multiple internal classes are allowed
Source files should be given the name of the public class in the file
Directory names should follow the namespace for the class

For example, I would expect to find the public class "System.Windows.Forms.Control" in "System\Windows\Forms\Control.cs"…

Classes member should be alphabetized, and grouped into sections (Fields, Constructors, Properties, Events, Methods, Private interface implementations, Nested types)
Using statements should be inside the namespace declaration.

namespace MyNamespace
{

using System;

public class MyClass : IFoo
{

// fields
int foo;

// constructors
public MyClass() { … }

// properties
public int Foo { get { … } set { … } }

// events
public event EventHandler FooChanged { add { … } remove { … } }

// methods
void DoSomething() { … }
void FindSomethind() { … }

//private interface implementations
void IFoo.DoSomething() { DoSomething(); }

// nested types
class NestedType { … }

}

Selection in Visual Studio 2008 SP1 RTM (Multiple Control Formatting at it's best]

2008-06-11T21:36:00.001-07:00

Last week, I have installed Visual Studio 2008 SP1 RTM and I am happy to bring a new feature in your knowledge [i.e. multiple selection and alignment operations in Design]. This feature has been introduced in Visual Studio 2008 SP1 RTM and Visual Web Developer Express 2008 SP1 RTM.

I do understand that designing pages using absolute positioning of elements is a tedious task and some people avoids it. However we have to been relying on the functionality that Visual Studio used to provide since VS 2002 and expected feature to stay in subsequent versions.

But the things are changing rapidly here. In VS 2008 Microsoft Visual Studio Product Group has replaced old IE based designer by a new designer that is shared with Expression Web and is based on former FrontPage technologies. But neither FrontPage nor Expression Web ever had multiple selection functionality in their releases, even Visual Interdev 98 is amongst the same page with these tools, Thus it took us some time to implement the feature in the new code base and it was not yet ready for SP1 Beta release.

Due to time constraints, not all functionality available in VS 2005 will become available in VS 2008 SP1. Here is what will be included:

1. Multiple selection using Ctrl+Click
2. Primary selection is indicated by white tab
3. Position menu with Absolute and Relative sub items
4. Align, Make Same Size and Order menus commands.
5. Ability to apply property to multiple controls in the Properties window
6. Delete multiple controls

Excluded Functionality :

1. Ability to drag multiple controls
2. Cut/Copy/Paste multiple elements

But its an interesting move: look at these pictures.

How to Implement, Transparency, Gradients and 3D Glass Effects on .NET Compect Framework.

2008-06-11T05:19:00.001-07:00

Now mobile application developers can create more user friendly UI with .NET Compect Framework!!!

With the release of Microsoft® Windows Vista® and new development technologies such as Microsoft Silverlight™, .NET Micro Framework and Microsoft Windows® Presentation Foundation [WPF], expectations of what constitutes an acceptable application user interface on various Microsoft client platforms have never been higher. Since a long this move was expected from Microsoft as the company is aggresively capturing mobile deveolopment market, the Independent Software Vendor (ISV) creating software for Microsoft Windows Mobile® has always had to compete on features and functionality, but increasingly also faces competition on look and feel. Developers creating LOB (Line of Business) Windows Mobile solutions must now consider going beyond the out-of-the-box Windows Forms controls available in the .NET Compact Framework to create more compelling Windows Mobile–based application user interfaces that match the new graphic metaphors introduced in Windows Mobile 6.

Creating controls for .NET Compact Framework–based applications—which includes transparency, gradients, and three-dimensional glass-like appearance—is well within reach today, using existing Microsoft Windows Mobile development tools. This article will demonstrate how to achieve transparency, gradients, and glass effects by extending existing .NET Compact Framework controls and leveraging some powerful native graphics features available in the Windows Mobile operating system.

Microsoft releases ASP.NET MVC [Model-View-Controller] Preview - 3

2008-06-01T22:09:00.001-07:00

Last week (27th May 2008) , Microsoft released the latest preview version of its model-view-controller (MVC) architecture for Web application frameworks.

The debut of Version 3 was announced Tuesday on the blog of Scott Guthrie, corporate vice president of Microsoft's .NET Developer Division. This version includes many of the changes detailed in a post in April and several new ones, including improvements to the MVC, bug fixes, additions to HTML helper methods and a new URL routing engine that will also "ship in .NET 3.5 SP1 this summer," Guthrie wrote.

Another improvement he highlighted is a richer URL route mapping offering, including support for new characters.

Guthrie also commented on changes planned for upcoming versions. "In future preview releases, you'll start to see more improvements higher up the programming model stack in areas [such as] views (HTML helpers, validation helpers, etc.); AJAX; subcontrollers and site composition; deeper log-in, authentication, authorization and caching integration; as well as data scaffolding support," he wrote.

The preview is available for public download here. The source code is available here.

Microsoft Research - SecPAL (A new authorization language)

2008-05-27T22:28:00.001-07:00

The development of large-scale, decentralized distributed computing environments has highlighted the need for fine-grained control over trust relationships and delegated access rights. Existing approaches do not fully satisfy these needs. They typically lack precision and/or require an undesirable reliance on centralized administration to be effective. In addition, one finds multiple independent mechanisms, with disparate semantics, being used to manage trust, delegation and authorization. This makes it difficult to understand the effective security in large distributed systems and complicates their management.

The goal of the SecPAL project is to develop a language for expressing decentralized authorization policies, and to investigate language design and semantics, as well as related algorithms and analysis techniques. This project is a collaboration between the advanced technology incubation group of Microsoft's Chief Research and Strategy Officer and Microsoft Research Cambridge.

Download : SecPAL for .NET

Microsoft Releases ".NET Micro Framework"

2008-05-27T05:56:00.000-07:00

Microsoft has announced a new release of its .NET Micro Framework platform for low-end embedded processors. Version 2.5 adds a native TCP/IP stack and support for Web Services on Devices (WSD), which aims to allow network-connected devices to discover and connect to one another without user intervention.Networking a .NET MF device previously required calling through to an underlying operating system with sockets support, according to Microsoft. Version 2.5 now provides a stack that is available even when running directly on the hardware. Since device makers need only provide a driver for the network interface, a wider selection of network-capable hardware development platforms will be available, the company says.Microsoft adds that the new version of .NET MF will also include client and server support for Web Services on Devices, also known as Device Profile for Web Services (DPWS). Already part of Windows Vista and Windows CE 6.0 Release 2, this "enables a USB-like level of plug-and-play for networked devices," in the company's words. DPWS-enabled devices on a network can discover one another, then invoke the functionality each device provides.About .NET Micro Framework Microsoft .NET Micro Framework (.NET MF) in 2006, aiming it at wireless remote controls, watches, and other cost-sensitive devices with constrained processor and memory resources. The .NET MF grew out of Microsoft's Smart Personal Objects Technology (SPOT) initiative, with embryonic versions variously dubbed .NET Embedded and Tiny CLR.According to Microsoft, .NET MF supports low-end embedded processors and doesn't require an MMU (memory management unit). A typical runtime image is only about 300 KB in size, the company says.AvailabilityThe .NET Micro Framework, version 2.5, is available now, according to Microsoft. It is being demonstrated this week at the Embedded Workd 2008 show, in Nuremberg, Germany, in the Microsoft Windows Embedded booth (hall 11, stand 318).

ASP.NET 2.0 Page & Control Event Cycle

2008-04-22T01:42:00.000-07:00

Hi,
Here is the event cycle in ASP.NET 2.0 Page.

Application:
BeginRequestApplication:
PreAuthenticateRequestApplication:
AuthenticateRequestApplication:
PostAuthenticateRequestApplication:
PreAuthorizeRequestApplication:
AuthorizeRequestApplication:
PostAuthorizeRequestApplication:
PreResolveRequestCacheApplication:
ResolveRequestCacheApplication:
PostResolveRequestCacheApplication:
PreMapRequestHandlerPage:
ConstructApplication:
PostMapRequestHandlerApplication:
PreAcquireRequestStateApplication:
AcquireRequestStateApplication:
PostAcquireRequestStateApplication:
PreRequestHandlerExecutePage:
AddParsedSubObjectPage:
CreateControlCollectionPage:
AddedControlPage:
AddParsedSubObjectPage:
AddedControlPage:
ResolveAdapterPage:
DeterminePostBackModePage:
PreInitControl:
ResolveAdapterControl:
InitControl:
TrackViewStatePage:
InitPage:
TrackViewStatePage:
InitCompletePage:
LoadPageStateFromPersistenceMediumControl:
LoadViewStatePage:
EnsureChildControlsPage:
CreateChildControlsPage:
PreLoadPage:
LoadControl:
DataBindControl:
LoadPage:
EnsureChildControlsPage:
LoadCompletePage:
EnsureChildControlsPage:
PreRenderControl:
EnsureChildControlsControl:
PreRenderPage:
PreRenderCompletePage:
SaveViewStateControl:
SaveViewStatePage:
SaveViewStateControl:
SaveViewStatePage:
SavePageStateToPersistenceMediumPage:
SaveStateCompletePage:
CreateHtmlTextWriterPage:
RenderControlPage:
RenderPage:
RenderChildrenControl:
RenderControlPage:
VerifyRenderingInServerFormPage:
CreateHtmlTextWriterControl:
UnloadControl:
DisposePage:
UnloadPage:
DisposeApplication:
PostRequestHandlerExecuteApplication:
PreReleaseRequestStateApplication:
ReleaseRequestStateApplication:
PostReleaseRequestStateApplication:
PreUpdateRequestCacheApplication:
UpdateRequestCacheApplication:
PostUpdateRequestCacheApplication:
EndRequestApplication:
PreSendRequestHeadersApplication:
PreSendRequestContent

The SML.NET compiler

2008-04-02T05:49:00.000-07:00

What is ML?
ML is a programming language originally developed at the University of Edinburgh around twenty years ago. There are now two variants: Standard ML (also known as SML), which has a formal definition most recently revised in 1997, and O'Caml, developed at INRIA in Paris.
What is ML like?
ML is a high-level language that abstracts away from the machine so that the programmer doesn't have to worry about low-level details like memory management, data representation and pointer chasing. It therefore has advantages of increased productivity, clearer and more maintainable code, and fewer errors. Its features include:
1. Static type checking and type inference
2. Garbage collection
3. Exception handling
4. Parameterized types and parametric polymorphism
5. Recursive datatypes and pattern matching
6. Mutable references
7. First-class functions
8. Sophisticated module system with parameterized modules
What is ML good for?
ML is particularly good for language-processing, hence its widespread use amongst the research community in compilers, interpreters, program analysis tools, theorem provers and formal verifiers. But the advantages listed above make it useful for many applications.
What is SML.NET?
SML.NET is a Standard ML compiler developed at Microsoft Research Cambridge that targets the .NET Common Language Runtime (CLR). It's very easy to use: tell it where your source code lives, give it the name of a "root" structure, and it produces an assembler file which it then runs through the CLR assembler to produce an executable or DLL. The code that it produces is verifiable.

Obfuscation

2008-04-02T05:34:00.001-07:00

One topic I'm often asked about is obfuscation of managed code, What is that? Is it a new way to secure your assembly/code?. Let me tell you, obfuscation is the process of scrambling the symbols, code, and data of a program to prevent reverse engineering. The technique is also preventing code from the possible security threats.
Optimizing C++ compilers for native code tend to produce obfuscated code by default. In the process of optimizing, the code is often rearranged quite a bit and symbols are stripped from retail builds. In contrast, managed code compilers (C#, VB.NET, etc) generate IL, not native assembly code. This IL tends to be consistently structured and fairly easy to reverse engineer. Most optimization happens when the IL is JIT-compiled into native code, not during compilation.
This means it's pretty easy to take a compiled assembly and de-compile it into source code, using a tool such as Lutz’s Reflector and File Disassembler . While this is a non-issue for web scenarios where all the code resides on the server, it's a big issue for some client scenarios, especially ISV applications. These client applications may contain trade secrets or sensitive information in their algorithms, data structures, or data. This is where obfuscation tools come in.
Obfuscation tools mangle symbols and rearrange code blocks to foil decompiling. They also may encrypt strings containing sensitive data. It's important to understand that obfuscators (as they exist today) can't completely protect your intellectual property. Because the code is on the client machine, a really determined hacker with lots of time can study the code and data structures enough to understand what's going on. Obfuscators do provide value in raising the bar, however, defeating most decompiler tools and preventing the casual hacker from stealing your intellectual property. They can make your code as difficult to reverse engineer as optimize native code.
If you're interested in obfuscation for your code, I recommend taking a look at one of the third-party obfuscators that work on managed code. For example, Visual Studio ships with the community edition of Dotfuscator, a popular obfuscation package. The community edition only mangles symbol names, so it's not doing everything the full-featured editions do, but it will at least give you an idea of how an obfuscator works. And there are other third-party obfuscators that work on managed code as well. Keep in mind that obfuscating your code may make debugging more difficult or impossible. Many of the third-party obfuscators have features that help with debugging, however, such as keeping a mapping file from obfuscated symbol names to original symbol names.
I'm also asked what is Microsoft's stance on obfuscation? Do MS obfuscate their own code? The answer for the .NET Framework team is no. As a development platform, it makes more sense not to obfuscate, so MS protect their intellectual property by other means. Some Microsoft products that use managed code have opted to obfuscate.

MS Surface

2008-04-02T05:19:00.000-07:00

It's lil bit longer then expected, but Microsoft has its first customer ready to put Surface computers into public use.
Perhaps most interestingly, the first one out of the gate is not one of the company's earliest partners. Instead, it is cellular carrier AT&T that is ready to make use of the touch-screen computers.
The company will use several counter-height units inside its cellular retail stores. The company is beginning with five stores on April 17: two in New York, one in San Francisco, one in San Antonio, and one in Atlanta. Each store will have a few of the Surface machines where customers can compare the features of different phones as well as check out service plans and view coverage maps. Currently AT&T uses laptops in the store to offer such features.
"We're in business now," said Pete Thompson, the general manager of Microsoft's surface computing unit.
Microsoft had talked about such a retail use for Surface, but in its demonstrations had featured AT&T rival T-Mobile. Thompson said that T-Mobile remains a partner, but he had no update as to when that carrier will be ready to use Surface in its stores.
And, although Microsoft CEO Steve Ballmer has said he wants the consumer version of surface speed up, Thompson said he also wants to make sure that the company doesn't disappoint its earliest customers, who are all large businesses.
Microsoft has said it is aiming to have the consumer version on shelves by 2011, as much as two years earlier than its initial plan.
"We are trying to do the right thing and accelerate where we can," Thompson said, but added, "I am very much focused on making this initial commercial plan a success without getting distracted."
As for those early buyers, Thompson said that Microsoft does have other unnanounced customers for the Surface, though he declined to name names. (One name we've heard mentioned is Disney, though Thompson would not comment on that.) He did say that we would start to see activity through partners in some additional areas, such as government, health care, and education.
At last year's partner conference, Microsoft talked about having a software development kit available by April.
Thompson said that the company has started offering a development kit for some software makers and partners, but that for the time being the kit will only be available to select developers.
"We're looking at more of a managed rollout of the SDK at this point," he said, adding that he would not characterize the software kit as being broadly available. "That's where we want to get to. I don't want to say this is a closed or managed system over time."
Although AT&T will be the first place the public can go to regularly see the Surface, Microsoft has permanently installed the machines in one other place: its own campus.
"You can just walk into most lobbies," Thompson said, adding that the company has about 15 to 20 buildings with the machines so far. "We're putting in three to five a week."

Microsoft Wins Open-Format Designation

2008-04-02T05:12:00.000-07:00

Microsoft has won an international standards designation for its open-document format, according to voting results obtained Tuesday, apparently ending a divisive yearlong battle with software rivals before a global standards-setting organization.
Microsoft’s Office Open XML, a format for interchangeable Web documents, was approved by 24 of 32 countries in a core group in a ballot by the International Organization for Standardization. Approval by the standards-setting body, a nongovernmental network of 157 countries based in Geneva, is considered almost certain to influence software spending by governments and large companies.
The tally reversed a loss by Microsoft in first-round voting before an 87-nation panel in September, a process that involved blunt lobbying by both sides toward members of national standards committees — typically made up of technicians, engineers and bureaucrats.
In the final round of voting, which ended Saturday, three-quarters of the core group members — including Britain, Japan, Germany and Switzerland — supported Microsoft’s standard, according to the results document. Of the 87 votes, 10 opposed the standard: Brazil, Canada, China, Cuba, Ecuador, India, Iran, New Zealand, South Africa and Venezuela.
Under organization rules, at least 66 percent of core group members must accept a standard for it to be approved, and no more than 25 percent of all voting nations can be opposed.
Roger Frost, a spokesman in Geneva for the standardization group, would not confirm that Microsoft’s format had been designated, saying the organization would disclose the vote Wednesday after informing its members. The International Herald Tribune obtained the results from one of the delegations contacted by the standardization group.
Microsoft’s request for rapid approval of its standard in early 2007 produced an intense lobbying campaign by I.B.M. and Sun Microsystems, which had helped develop a rival interchangeable document format called Open Document Format.
This rival was the first interchangeable document format to receive approval by the standardization group in 2006, and its backers used that in selling the technology to governments and large companies. The format is now being considered for use by 70 nations.
Microsoft’s push for speedy approval led to objections from many members of the standards group. They felt pressure from the company, whose Office application suite is the standard on more than 90 percent of computers and archives worldwide, according to International Data in Framingham, Mass.
There were tart remarks even from countries that abstained from the vote, like the Netherlands. “This is like someone with six shopping carts of food trying to go through the express lane at a supermarket,” said Michiel Leenaars, a member of the Dutch delegation. “The end result of this will be confusion. The standard is simply too big. There are still a lot of questions out there.”

Design Patterns

2007-09-01T11:12:00.001-07:00

Factory Pattern

Factory Methods are usually called within Template Methods. Often, designs start out using Factory Method (less complicated, more customizable, subclasses proliferate) and evolve toward Abstract Factory, Prototype, or Builder (more flexible, more complex) as the designer discovers where more flexibility is needed. Where ever you can implement Factory, you can easily incorporate Abstract Factory and Builder.

Abstract Factory

Abstract Factory classes are often implemented with Factory Methods, but they can be implemented using Prototype. Where ever you can implement Abstract Factory, you can easily incorporate Factory and Builder. The core difference between Factory and Abstract Factory is, Abstract Factory is useful when application demands Family of objects creation, where as Factory is useful at the time of creation of an single instance of a class.

Builder

Builder focuses on constructing a complex object step by step. Abstract Factory emphasizes a family of product objects (either simple or complex). Builder returns the product as a final step, but as far as the Abstract Factory is concerned, the product gets returned immediately. Where ever you can implement Builder, you can also implement factory or abstract factory. This can be implement for Abstract Factory and Factory too.

Prototype

Factory Method: creation through inheritance. Prototype: creation through delegation. In .NET one can easily incorporate prototype using "Icloneabe--> Clone". Prototype is useful when you want to create new object without firing object's constructor. In .NET framework there are two ways to create object without calling constructor (Cloning and De-serialization).

Adapter

Adapter makes things work after they're designed; Bridge makes them work before they are. Bridge is designed up-front to let the abstraction and the implementation vary independently. Adapter is retrofitted to make unrelated classes work together.

Bridge

The structure of State and Bridge are identical (except that Bridge admits hierarchies of envelope classes, whereas State allows only one). The two patterns use the same structure to solve different problems: State allows an object's behavior to change along with its state, while Bridge's intent is to decouple an abstraction from its implementation so that the two can vary independently.

Composite

Three GoF patterns rely on recursive composition: Composite, Decorator, and Chain of Responsibility

Decorator

Decorator is designed to let you add responsibilities to objects without subclassing. Composite's focus is not on embellishment but on representation. These intents are distinct but complementary. Consequently, Composite and Decorator are often used in concert.

Façade

Facade defines a new interface, whereas Adapter uses an old interface. Remember that Adapter makes two existing interfaces work together as opposed to defining an entirely new one.

Flyweight

Flyweight is often combined with Composite to implement shared leaf nodes. Flyweight shows how to make lots of little objects. Facade shows how to make a single object represent an entire subsystem. This diagram is perhaps a better example of Composite than the Composite diagram.

Proxy

Decorator and Proxy have different purposes but similar structures. Both describe how to provide a level of indirection to another object, and the implementations keep a reference to the object to which they forward requests. Adapter provides a different interface to its subject. Proxy provides the same interface. Decorator provides an enhanced interface.

Chain of Resp.

Chain of Responsibility, Command, Mediator, and Observer, address how you can decouple senders and receivers, but with different trade-offs. Chain of Responsibility passes a sender request along a chain of potential receivers.

Command

Command and Memento act as magic tokens to be passed around and invoked at a later time. In Command, the token represents a request; in Memento, it represents the internal state of an object at a particular time. Polymorphism is important to Command, but not to Memento because its interface is so narrow that a memento can only be passed as a value.

Interpreter

Interpreter is really an application of Composite.

Iterator

Memento is often used in conjunction with Iterator. An Iterator can use a Memento to capture the state of an iteration. The Iterator stores the Memento internally.

Mediator

Mediator is similar to Facade in that it abstracts functionality of existing classes. Mediator abstracts/centralizes arbitrary communications between colleague objects. It routinely "adds value", and it is known/referenced by the colleague objects. In contrast, Facade defines a simpler interface to a subsystem, it doesn't add new functionality, and it is not known by the subsystem classes.

Memento

Command can use Memento to maintain the state required for an undo operation.

Observer

Mediator and Observer are competing patterns. The difference between them is that Observer distributes communication by introducing "observer" and "subject" objects, whereas a Mediator object encapsulates the communication between other objects. We've found it easier to make reusable Observers and Subjects than to make reusable Mediators. On the other hand, Mediator can leverage Observer for dynamically registering colleagues and communicating with them.

Strategy

Strategy, State, Bridge (and to some degree Adapter) have similar solution structures. They all share elements of the "handle/body" idiom. They differ in intent - that is, they solve different problems.

Most of the GoF patterns exercise the two levels of indirection demonstrated here.

Promote the "interface" of a method to an abstract base class or interface, and bury the many possible implementation choices in concrete derived classes.

Hide the implementation hierarchy behind a "wrapper" class that can perform responsibilities like: choosing the best implementation, caching, state management, remote access.

Strategy can be considered as a mother of all pattern.

State

Strategy is a bind-once pattern, whereas State is more dynamic.

Template Method

Template Method uses inheritance to vary part of an algorithm. Strategy uses delegation to vary the entire algorithm.

Visitor

The Visitor pattern is the classic technique for recovering lost type information without resorting to dynamic casts.

How to avoid GC-Hole

2007-05-18T04:29:00.000-07:00

To avoid GC-Hole one must use GCPROTECT_BEGIN to keep your references up to date.

Here’s how to fix our buggy code fragment.

#include “frames.h”
{
MethodTable *pNT = g_pObjectClass->GetRefTable();

//RIGHT
OBJECTREF a = AllocateObjectMemory(pNT);

GCPROTECT_BEGIN(a);
OBJECTREF b = AllocateObjectMemory(pNT);

DoSomething (a, b);

GCPROTECT_END();

}

Notice the addition of the line GCPROTECT_BEGIN(a). GCPROTECT_BEGIN is a macro whose argument is any OBJECTREF-typed storage location (it has to be an expression that can you can legally apply the address-of (&) operator to.) GCPROTECT_BEGIN tells the GC two things:

1. The GC is not to discard any object referred to by the reference stored in local “a”.
2. If the GC moves the object referred to by “a”, it must update “a” to point to the new location.

Now, if the second AllocateObjectMemory() triggers a GC, the “a” object will still be around afterwards, and the local variable “a” will still point to it. “a” may not contain the same address as before, but it will point to the same object. Hence, DoSomething() receives the correct data.

Note that we didn’t similarly protect ‘b” because the caller has no use for “b” after DoSomething() returns. Furthermore, there’s no point in keeping “b” updated because DoSomething() receives a copy of the reference (don’t confuse with “copy of the object.”), not the reference itself. If DoSomething() internally causes GC as well, it is DoSomething()’s responsibility to protect its own copies of “a” and “b”.

Having said that, no one should complain if you play it safe and GCPROTECT “b” as well. You never know when someone might add code later that makes the protection necessary.

Every GCPROTECT_BEGIN must have a matching GCPROTECT_END, which terminates “a”’s protected status. As an additional safeguard, GCPROTECT_END overwrites “a” with garbage so that any attempt to use “a” afterward will fault. GCPROTECT_BEGIN introduces a new C scoping level that GCPROTECT_END closes, so if you use one without the other, you’ll probably experience severe build errors.

Don’t do nonlocal returns from within GCPROTECT blocks.

Never do a “return”, “goto” or other non-local return from between a GCPROTECT_BEGIN/END pair. This will leave the thread’s frame chain corrupted.

One exception: it is explicitly allowed to leave a GCPROTECT block by throwing a managed exception (usually via the COMPlusThrow() function.) The exception subsystem knows about GCPROTECT and correctly fixes up the frame chain as it unwinds.

What is GC-Hole? And How to create GC-Hole?

2007-04-09T12:36:00.000-07:00

The term “GC-hole” points to a special class of bugs that bedevils the CLR. The GC hole is a pernicious bug because it is easy to introduce by accident, repros rarely and is very tedious to debug. A single GC-hole can suck up weeks of dev and test time.

Lets discuss, What is GC-Hole? And How to create it?

First, some background. One of the major features of the CLR is the Garbage Collection system. That means that allocated objects, as seen by a managed application, are never freed explicitly by the programmer. Instead, the CLR periodically runs a Garbage Collector (GC). The GC discards objects that are no longer in use. Also, the GC compacts the heap to avoid unused holes in memory. Therefore, a managed object does not have a fixed address. Objects move around according to the whims of the garbage collector.

To do its job, the GC must be told about every reference to every GC object. The GC must know about every stack location, every register and every non-GC data structure that holds a pointer to a GC object. These external pointers are called “root references.”

Armed with this information, the GC can find all objects directly referenced from outside the GC heap. These objects may in turn, reference other objects – which in turn reference other objects and so on. By following these references, the GC finds all reachable (“live”) objects. All other objects are, by definition, unreachable and therefore discarded. After that, the GC may move the surviving objects to reduce memory fragmentation. If it does this, it must, of course, update all existing references to the moved object.

Any time a new object is allocated, a GC may occur. GC can also be explicitly requested by calling the GarbageCollect function directly. GC’s do not happen asynchronously outside these events but since other running threads can trigger GC’s, your thread must act as if GC’s are aynchronous unless you take specific steps to synchronize with the GC. More on that later.

So now, we can define a GC hole. A GC hole occurs when code inside the CLR creates a reference to a GC object, neglects to tell the GC about that reference, performs some operation that directly or indirectly triggers a GC, then tries to use the original reference. At this point, the reference points to garbage memory and the CLR will either read out a wrong value or corrupt whatever that reference is pointing to.

The code snippet below is the simplest way to introduce a GC hole into the system.

//OBJECTREF is a typedef for Object*.

{
PointerTable *pTBL = o_pObjectClass->GetPointerTable();

OBJECTREF aObj = AllocateObjectMemory(pTBL);
OBJECTREF bObj = AllocateObjectMemory(pTBL);

//WRONG!!! “aObj” may point to garbage if the second
//“AllocateObjectMemory” triggered a GC.
DoSomething (aOb, bObj);
}

All it does is allocate two managed objects, and then does something with them both.

This code compiles fine, and if you run simple pre-checkin tests, it will probably “work.” But this code will crash eventually.

Why? If the second call to “AllocateObjectMemory” triggers a GC, that GC discards the object instance you just assigned to “aObj”. This code, like all C++ code inside the CLR, is compiled by a non-managed compiler and the GC cannot know that “aObj” holds a root reference to an object you want kept live.

This point is worth repeating. The GC has no intrinsic knowledge of root references stored in local variables or non-GC data structures maintained by the CLR itself. You must explicitly tell the GC about them.

Small but interesting thing about .NET Framework 2.0

2007-03-30T02:06:00.000-07:00

We always talk about the .NET Framework 2.0 the pros and cons, the scope, patterns, best practice and some of the basic class lib. But are we aware about how many types .NET Framework 2.0 have? And like this only some other basic information? I am sure we are not. So here are the small information I want to share with you.

Microsoft .NET Framework 2.0 includes 51 assemblies.
Microsoft .NET Framework 2.0 is having 18,619 Types.
Microsoft .NET Framework 2.0 is having 12,909 Classes.
Microsoft .NET Framework 2.0 is having 4,01,758 public methods.
Microsoft .NET Framework 2.0 is having 93,105 public properties.
Microsoft .NET Framework 2.0 is having 30,546 public events.

How many of events do we know or used?
How many of types we have used in our n-tire career .NET Dev. Career?
How many methods we used so far?
No question about public events.

A research says if a person dedicatedly work on .NET 2.0 to use all of the above, he/she might take more then 1 man years to complete this task. And .NET 4 is about to release in next Jan [this is my assumption, nothing declare till now about .net 4.0] or so. So guys start exploring this version more and more.

Decode ASP.NET Page's ViewState

2006-02-05T22:17:00.000-08:00

About LosFormatter

Serializes the view state for a Web Forms page. This class cannot be inherited.

The limited object serialization (LOS) formatter is designed for highly compact ASCII format serialization. This class supports serializing any object graph, but is optimized for those containing strings, arrays, and hashtables. It offers second order optimization for many of the .NET primitive types.
This is a private format, and only needs to remain consistent for the lifetime of a Web request. You are not allowed to persist objects serialized with this formatter for any significant length of time.

LosFormatter, a member of the System.Web.UI namespace, is a "stripped down" version of BinaryFormatter that is used internally by the ASP.NET runtime to create and retrieve Page - level objects to / from the hidden _VIEWSTATE field.
LosFormatter, although undocumented, can also be easily used explicitly by the developer. One of the handy features it has is that the serialized string it generates is automatically Base64 encoded so that the ViewState Collection can be persisted through page POSTs. Of course, if you explicitly call the methods of LosFormatter, you are not restricted to keeping the resulting string in the hidden _VIEWSTATE field - you can do whatever you want with it.

Code To Decode Your ViewState :)

System.Web.UI.Triplet _triplet = null;

try
{

if (txt1.Text!="")

{

LosFormatter _losFormatter = new LosFormatter();

System.IO.StringReader _reader= new System.IO.StringReader(txt1.Text);

object _deSerialized = _losFormatter.Deserialize(_reader);

_triplet = _deSerialized as Triplet;

ArrayList _Keys = (((_triplet.Second) as Triplet).First as Pair).First as ArrayList;

ArrayList _Values = (((_triplet.Second) as Triplet).First as Pair).Second as ArrayList;

txt2.Text = "Decoded Values";

txt2.Text = "No. Of Item/s Found : " + _Keys.Count.ToString();

for (int _keysCount =0;_keysCount<=_Keys.Count-1;_keysCount++)

{

txt2.Text +="\r\n" + "Key : " + _Keys[_keysCount].ToString() + "\r\n Value : " + _Values[_keysCount].ToString();

}

catch(Exception _ex)

{

throw _ex;

}

My Exam Score [Design Pattern]

2006-01-04T01:04:00.000-08:00

String Vs StringBuilder : Kaushal Patel

2005-12-22T20:37:00.000-08:00

Introduction

This is my second article regarding performance. Most of the people use string everywhere in their code. Actually when doing string concatenation, do you know what exactly your doing? It has a big drawback mainly in concatenation which can be overcome by StringBuilder. It will give vast improvement in performance when you use concatenation of string over String.

What is the exact difference?

First we will look at what happens when you concatenate two strings. For a rough idea, think like this. In a loop you are adding few numbers to get a string to give all the numbers.

string returnNumber = "";
for(int i = 0; i<1000;i++)

{

returnNumber = returnNumber + i.ToString();

}

Here we are defining a string called returnNumber and after that in the loop we are concatenating the old one with the new to get a string. Do you know when we do like that we are assigning it again and again? I mean its really like assigning 999 new strings! Actually the concatenation will create a new string returnNumber, with both old returnNumber and i.ToString(). If we think roughly, How will be the performance of the code? Can you imagine it? No one things about this when coding. If we can have something which are be defined only once and add all the strings into it, what can you say about the performance. That's what StringBuilder is doing.

StringBuilder returnNumber = new StringBuilder(10000);

for(int i = 0; i<1000;i++)

{

returnNumber.Append(i.ToString());

}

We are creating a StringBuilder of length 10000 in memory where we can add all the strings. Which surely wont create a new string each and every time. Actually we are creating a StringBinder, where whenever something added it will get copied in to that memory area. At the end we can get the string by StringBuilder.ToString(). Here also it wont create a new string. It will return a string instance that will point to the string inside the StringBuilder. See, How efficient this is? To explain this with some practical I'm not going to analyze IL code or Optimized JIT compiled code. You can see the different by running the samples.

Why string? Can't use StringBinder everywhere?

No. You can't. When initializing a StringBuilder you are going down in performance. Also many actions that you do with string can't be done with StringBinder. Actually it is used mostly for situations as explained above. Last week I show a person, who used StringBuilder to just add two strings together! its really nonsense. We must really think about the overhead of initialization. In my personal experience a StringBuilder can be used where more than four or more string concatenation take place. Also if you try to do some other manipulation (Like removing a part from the string, replacing a part in the string, etc, etc) then better not to use StringBuilder at those places. Because anyway we are creating new strings. Another important issue. We must be careful to guess the size of StringBuilder . If the size which we are going to get is more than what assigned, it must increase the size. Which will reduce the performance of it.

My Exams Score Board @ BrainBench

2005-11-07T22:15:00.000-08:00

1. .NET Framework

2. OO Design Patterns

kaushal patel
Test:	.NET Framework
Date:	08-Nov-2005
Score:	3.11
Correct/Total:	(25/40)

Topics/Subtopics

Correct/Total

.NET Programming

(5/7)

Features/Benefits

(1/1)

Attribute Programming

(2/3)

Security

(1/2)

COM+ Services

(1/1)

Common Language
Runtime (CLR)

(3/8)

Virtual Execution Engine (VEE)

(1/1)

Features/Benefits

(1/3)

Compilers and Tools

(0/1)

Runtime Hosts

(0/2)

Automatic Memory Management (Garbage Collection)

(1/1)

Assemblies

(3/7)

.NET Portable Executable (PE) File

(1/3)

Assembly Types

(0/1)

Versioning

(1/2)

Manifests/MSIL

(1/1)

.NET Architectural
Overview

(5/6)

Features/Benefits

(2/2)

Common Language Specification

(1/1)

Application Domains

(1/1)

Deployment Strategies

(0/1)

.NET Utilities/Tools

(1/1)

Common Type System
(CTS)

(4/5)

Reference Types

(2/2)

Value Types

(1/1)

Tables and Heaps

(1/1)

Common Language Specification

(0/1)

.NET Metadata

(1/3)

Benefits/Features

(1/2)

Inspecting and Emitting

(0/1)

.NET Framework Class
Library

(4/4)

Features/Benefits

(2/2)

Data Classes

(2/2)

kaushal patel
Test:	OO Design Patterns
Date:	08-Nov-2005
Score:	2.93
Correct/Total:	(21/40)

Topics/Subtopics

Correct/Total

Language Specific
Patterns

(2/10)

Java

(2/8)

C++

(0/2)

GoF Patterns

(14/22)

Behavioral

(4/8)

Structural

(8/9)

Creational

(2/5)

Persistence Patterns

(1/2)

Serialization

(1/1)

Object/Relational Mapping

(0/1)

Fundamental
Architectural Patterns

(2/3)

MVC

(1/2)

Layering

(1/1)

Distributed Patterns

(2/3)

Design

(1/1)

Architectural

(1/2)

Garbage Collection in .NET : Kaushal

2005-10-19T07:23:00.000-07:00

Implementing proper resource management for your applications can be a difficult, tedious task. It can distract your concentration from the real problems that you're trying to solve. Wouldn't it be wonderful if some mechanism existed that simplified the mind-numbing task of memory management for the developer? Fortunately, in .NET there is: garbage collection (GC).
Let's back up a minute. Every program uses resources of one sort or another—memory buffers, screen space, network connections, database resources, and so on. In fact, in an object-oriented environment, every type identifies some resource available for your program's use. To use any of these resources requires that memory be allocated to represent the type. The steps required to access a resource are as follows:

1. Allocate memory for the type that represents the resource.

2. Initialize the memory to set the initial state of the resource and to make the resource usable.

3. Use the resource by accessing the instance members of the type (repeat as necessary).

4. Tear down the state of the resource to clean up.

5. Free the memory.

This seemingly simple paradigm has been one of the major sources of programming errors. After all, how many times have you forgotten to free memory when it is no longer needed or attempted to use memory after you've already freed it?
These two bugs are worse than most other application bugs because what the consequences will be and when those consequences will occur are typically unpredictable. For other bugs, when you see your application misbehaving, you just fix it. But these two bugs cause resource leaks (memory consumption) and object corruption (destabilization), making your application perform in unpredictable ways at unpredictable times. In fact, there are many tools (such as the Task Manager, the System Monitor ActiveX® Control, CompuWare's BoundsChecker, and Rational's Purify) that are specifically designed to help developers locate these types of bugs.
As I examine GC, you'll notice that it completely absolves the developer from tracking memory usage and knowing when to free memory. However, the garbage collector doesn't know anything about the resource represented by the type in memory. This means that a garbage collector can't know how to perform step four—tearing down the state of a resource. To get a resource to clean up properly, the developer must write code that knows how to properly clean up a resource. In the .NET Framework, the developer writes this code in a Close, Dispose, or Finalize method, which I'll describe later. However, as you'll see later, the garbage collector can determine when to call this method automatically.
Also, many types represent resources that do not require any cleanup. For example, a Rectangle resource can be completely cleaned up simply by destroying the left, right, width, and height fields maintained in the type's memory. On the other hand, a type that represents a file resource or a network connection resource will require the execution of some explicit clean up code when the resource is to be destroyed. I will explain how to accomplish all of this properly. For now, let's examine how memory is allocated and how resources are initialized.

Resource Allocation

The Microsoft® .NET common language runtime requires that all resources be allocated from the managed heap. This is similar to a C-runtime heap except that you never free objects from the managed heap—objects are automatically freed when they are no longer needed by the application. This, of course, raises the question: how does the managed heap know when an object is no longer in use by the application? I will address this question shortly.
There are several GC algorithms in use today. Each algorithm is fine-tuned for a particular environment in order to provide the best performance. This article concentrates on the GC algorithm that is used by the common language runtime. Let's start with the basic concepts.
When a process is initialized, the runtime reserves a contiguous region of address space that initially has no storage allocated for it. This address space region is the managed heap. The heap also maintains a pointer, which I'll call the NextObjPtr. This pointer indicates where the next object is to be allocated within the heap. Initially, the NextObjPtr is set to the base address of the reserved address space region.
An application creates an object using the new operator. This operator first makes sure that the bytes required by the new object fit in the reserved region (committing storage if necessary). If the object fits, then NextObjPtr points to the object in the heap, this object's constructor is called, and the new operator returns the address of the object.

At this point, NextObjPtr is incremented past the object so that it points to where the next object will be placed in the heap. Figure 1 shows a managed heap consisting of three objects: A, B, and C. The next object to be allocated will be placed where NextObjPtr points (immediately after object C).
Now let's look at how the C-runtime heap allocates memory. In a C-runtime heap, allocating memory for an object requires walking though a linked list of data structures. Once a large enough block is found, that block has to be split, and pointers in the linked list nodes must be modified to keep everything intact. For the managed heap, allocating an object simply means adding a value to a pointer—this is blazingly fast by comparison. In fact, allocating an object from the managed heap is nearly as fast as allocating memory from a thread's stack!
So far, it sounds like the managed heap is far superior to the C-runtime heap due to its speed and simplicity of implementation. Of course, the managed heap gains these advantages because it makes one really big assumption: address space and storage are infinite. This assumption is (without a doubt) ridiculous, and there must be a mechanism employed by the managed heap that allows the heap to make this assumption. This mechanism is called the garbage collector. Let's see how it works.
When an application calls the new operator to create an object, there may not be enough address space left in the region to allocate to the object. The heap detects this by adding the size of the new object to NextObjPtr. If NextObjPtr is beyond the end of the address space region, then the heap is full and a collection must be performed.
In reality, a collection occurs when generation 0 is completely full. Briefly, a generation is a mechanism implemented by the garbage collector in order to improve performance. The idea is that newly created objects are part of a young generation, and objects created early in the application's lifecycle are in an old generation. Separating objects into generations can allow the garbage collector to collect specific generations instead of collecting all objects in the managed heap. Generations will be discussed in more detail in Part 2 of this article.

The Garbage Collection Algorithm
The garbage collector checks to see if there are any objects in the heap that are no longer being used by the application. If such objects exist, then the memory used by these objects can be reclaimed. (If no more memory is available for the heap, then the new operator throws an OutOfMemoryException.) How does the garbage collector know if the application is using an object or not? As you might imagine, this isn't a simple question to answer.
Every application has a set of roots. Roots identify storage locations, which refer to objects on the managed heap or to objects that are set to null. For example, all the global and static object pointers in an application are considered part of the application's roots. In addition, any local variable/parameter object pointers on a thread's stack are considered part of the application's roots. Finally, any CPU registers containing pointers to objects in the managed heap are also considered part of the application's roots. The list of active roots is maintained by the just-in-time (JIT) compiler and common language runtime, and is made accessible to the garbage collector's algorithm.
When the garbage collector starts running, it makes the assumption that all objects in the heap are garbage. In other words, it assumes that none of the application's roots refer to any objects in the heap. Now, the garbage collector starts walking the roots and building a graph of all objects reachable from the roots. For example, the garbage collector may locate a global variable that points to an object in the heap.
Figure 2 shows a heap with several allocated objects where the application's roots refer directly to objects A, C, D, and F. All of these objects become part of the graph. When adding object D, the collector notices that this object refers to object H, and object H is also added to the graph. The collector continues to walk through all reachable objects recursively.

Once this part of the graph is complete, the garbage collector checks the next root and walks the objects again. As the garbage collector walks from object to object, if it attempts to add an object to the graph that it previously added, then the garbage collector can stop walking down that path. This serves two purposes. First, it helps performance significantly since it doesn't walk through a set of objects more than once. Second, it prevents infinite loops should you have any circular linked lists of objects.
Once all the roots have been checked, the garbage collector's graph contains the set of all objects that are somehow reachable from the application's roots; any objects that are not in the graph are not accessible by the application, and are therefore considered garbage. The garbage collector now walks through the heap linearly, looking for contiguous blocks of garbage objects (now considered free space). The garbage collector then shifts the non-garbage objects down in memory (using the standard memcpy function that you've known for years), removing all of the gaps in the heap. Of course, moving the objects in memory invalidates all pointers to the objects. So the garbage collector must modify the application's roots so that the pointers point to the objects' new locations. In addition, if any object contains a pointer to another object, the garbage collector is responsible for correcting these pointers as well. Figure 3 shows the managed heap after a collection.

After all the garbage has been identified, all the non-garbage has been compacted, and all the non-garbage pointers have been fixed-up, the NextObjPtr is positioned just after the last non-garbage object. At this point, the new operation is tried again and the resource requested by the application is successfully created.
As you can see, a GC generates a significant performance hit, and this is the major downside of using a managed heap. However, keep in mind that GCs only occur when the heap is full and, until then, the managed heap is significantly faster than a C-runtime heap. The runtime's garbage collector also offers some optimizations that greatly improve the performance of garbage collection. I'll discuss these optimizations in Part 2 of this article when I talk about generations.
There are a few important things to note at this point. You no longer have to implement any code that manages the lifetime of any resources that your application uses. And notice how the two bugs I discussed at the beginning of this article no longer exist. First, it is not possible to leak resources, since any resource not accessible from your application's roots can be collected at some point. Second, it is not possible to access a resource that is freed, since the resource won't be freed if it is reachable. If it's not reachable, then your application has no way to access it. The code in Figure 4 demonstrates how resources are allocated and managed.
If GC is so great, you might be wondering why it isn't in ANSI C++. The reason is that a garbage collector must be able to identify an application's roots and must also be able to find all object pointers. The problem with C++ is that it allows casting a pointer from one type to another, and there's no way to know what a pointer refers to. In the common language runtime, the managed heap always knows the actual type of an object, and the metadata information is used to determine which members of an object refer to other objects.

Finalization
The garbage collector offers an additional feature that you may want to take advantage of: finalization. Finalization allows a resource to gracefully clean up after itself when it is being collected. By using finalization, a resource representing a file or network connection is able to clean itself up properly when the garbage collector decides to free the resource's memory.
Here is an oversimplification of what happens: when the garbage collector detects that an object is garbage, the garbage collector calls the object's Finalize method (if it exists) and then the object's memory is reclaimed. For example, let's say you have the following type (in C#):

public class BaseObj {
public BaseObj() {
}

protected override void Finalize() {
// Perform resource cleanup code here...
// Example: Close file/Close network connection
Console.WriteLine("In Finalize.");
}
}

Now you can create an instance of this object by calling:

BaseObj bo = new BaseObj();

Some time in the future, the garbage collector will determine that this object is garbage. When that happens, the garbage collector will see that the type has a Finalize method and will call the method, causing "In Finalize" to appear in the console window and reclaiming the memory block used by this object.
Many developers who are used to programming in C++ draw an immediate correlation between a destructor and the Finalize method. However, let me warn you right now: object finalization and destructors have very different semantics and it is best to forget everything you know about destructors when thinking about finalization. Managed objects never have destructors—period.
When designing a type it is best to avoid using a Finalize method. There are several reasons for this:

Finalizable objects get promoted to older generations, which increases memory pressure and prevents the object's memory from being collected when the garbage collector determines the object is garbage. In addition, all objects referred to directly or indirectly by this object get promoted as well. Generations and promotions will be discussed in Part 2 of this article.

Finalizable objects take longer to allocate.

Forcing the garbage collector to execute a Finalize method can significantly hurt performance. Remember, each object is finalized. So if I have an array of 10,000 objects, each object must have its Finalize method called.

Finalizable objects may refer to other (non-finalizable) objects, prolonging their lifetime unnecessarily. In fact, you might want to consider breaking a type into two different types: a lightweight type with a Finalize method that doesn't refer to any other objects, and a separate type without a Finalize method that does refer to other objects.

You have no control over when the Finalize method will execute. The object may hold on to resources until the next time the garbage collector runs.

When an application terminates, some objects are still reachable and will not have their Finalize method called. This can happen if background threads are using the objects or if objects are created during application shutdown or AppDomain unloading. In addition, by default, Finalize methods are not called for unreachable objects when an application exits so that the application may terminate quickly. Of course, all operating system resources will be reclaimed, but any objects in the managed heap are not able to clean up gracefully. You can change this default behavior by calling the System.GC type's RequestFinalizeOnShutdown method. However, you should use this method with care since calling it means that your type is controlling a policy for the entire application.

The runtime doesn't make any guarantees as to the order in which Finalize methods are called. For example, let's say there is an object that contains a pointer to an inner object. The garbage collector has detected that both objects are garbage. Furthermore, say that the inner object's Finalize method gets called first. Now, the outer object's Finalize method is allowed to access the inner object and call methods on it, but the inner object has been finalized and the results may be unpredictable. For this reason, it is strongly recommended that Finalize methods not access any inner, member objects.

If you determine that your type must implement a Finalize method, then make sure the code executes as quickly as possible. Avoid all actions that would block the Finalize method, including any thread synchronization operations. Also, if you let any exceptions escape the Finalize method, the system just assumes that the Finalize method returned and continues calling other objects' Finalize methods.
When the compiler generates code for a constructor, the compiler automatically inserts a call to the base type's constructor. Likewise, when a C++ compiler generates code for a destructor, the compiler automatically inserts a call to the base type's destructor. However, as I've said before, Finalize methods are different from destructors. The compiler has no special knowledge about a Finalize method, so the compiler does not automatically generate code to call a base type's Finalize method. If you want this behavior—and frequently you do—then you must explicitly call the base type's Finalize method from your type's Finalize method:

public class BaseObj {
public BaseObj() {
}

protected override void Finalize() {
Console.WriteLine("In Finalize.");
base.Finalize(); // Call base type's Finalize
}
}

Note that you'll usually call the base type's Finalize method as the last statement in the derived type's Finalize method. This keeps the object alive as long as possible. Since calling a base type Finalize method is common, C# has a syntax that simplifies your work. In C#, the following code

class MyObject {
~MyObject() {
•••
}
}

causes the compiler to generate this code:

class MyObject {
protected override void Finalize() {
•••
base.Finalize();
}
}

Note that this C# syntax looks identical to the C++ language's syntax for defining a destructor. But remember, C# doesn't support destructors. Don't let the identical syntax fool you.

Finalization Internals
On the surface, finalization seems pretty straightforward: you create an object and when the object is collected, the object's Finalize method is called. But there is more to finalization than this.
When an application creates a new object, the new operator allocates the memory from the heap. If the object's type contains a Finalize method, then a pointer to the object is placed on the finalization queue. The finalization queue is an internal data structure controlled by the garbage collector. Each entry in the queue points to an object that should have its Finalize method called before the object's memory can be reclaimed.
Figure 5 shows a heap containing several objects. Some of these objects are reachable from the application's roots, and some are not. When objects C, E, F, I, and J were created, the system detected that these objects had Finalize methods and pointers to these objects were added to the finalization queue.

When a GC occurs, objects B, E, G, H, I, and J are determined to be garbage. The garbage collector scans the finalization queue looking for pointers to these objects. When a pointer is found, the pointer is removed from the finalization queue and appended to the freachable queue (pronounced "F-reachable"). The freachable queue is another internal data structure controlled by the garbage collector. Each pointer in the freachable queue identifies an object that is ready to have its Finalize method called.
After the collection, the managed heap looks like Figure 6. Here, you see that the memory occupied by objects B, G, and H has been reclaimed because these objects did not have a Finalize method that needed to be called. However, the memory occupied by objects E, I, and J could not be reclaimed because their Finalize method has not been called yet.

There is a special runtime thread dedicated to calling Finalize methods. When the freachable queue is empty (which is usually the case), this thread sleeps. But when entries appear, this thread wakes, removes each entry from the queue, and calls each object's Finalize method. Because of this, you should not execute any code in a Finalize method that makes any assumption about the thread that's executing the code. For example, avoid accessing thread local storage in the Finalize method.
The interaction of the finalization queue and the freachable queue is quite fascinating. First, let me tell you how the freachable queue got its name. The f is obvious and stands for finalization; every entry in the freachable queue should have its Finalize method called. The "reachable" part of the name means that the objects are reachable. To put it another way, the freachable queue is considered to be a root just like global and static variables are roots. Therefore, if an object is on the freachable queue, then the object is reachable and is not garbage.
In short, when an object is not reachable, the garbage collector considers the object garbage. Then, when the garbage collector moves an object's entry from the finalization queue to the freachable queue, the object is no longer considered garbage and its memory is not reclaimed. At this point, the garbage collector has finished identifying garbage. Some of the objects identified as garbage have been reclassified as not garbage. The garbage collector compacts the reclaimable memory and the special runtime thread empties the freachable queue, executing each object's Finalize method.

The next time the garbage collector is invoked, it sees that the finalized objects are truly garbage, since the application's roots don't point to it and the freachable queue no longer points to it. Now the memory for the object is simply reclaimed. The important thing to understand here is that two GCs are required to reclaim memory used by objects that require finalization. In reality, more than two collections may be necessary since the objects could get promoted to an older generation. Figure 7 shows what the managed heap looks like after the second GC.

Resurrection
The whole concept of finalization is fascinating. However, there is more to it than what I've described so far. You'll notice in the previous section that when an application is no longer accessing a live object, the garbage collector considers the object to be dead. However, if the object requires finalization, the object is considered live again until it is actually finalized, and then it is permanently dead. In other words, an object requiring finalization dies, lives, and then dies again. This is a very interesting phenomenon called resurrection. Resurrection, as its name implies, allows an object to come back from the dead.
I've already described a form of resurrection. When the garbage collector places a reference to the object on the freachable queue, the object is reachable from a root and has come back to life. Eventually, the object's Finalize method is called, no roots point to the object, and the object is dead forever after. But what if an object's Finalize method executed code that placed a pointer to the object in a global or static variable?

public class BaseObj {

protected override void Finalize() {
Application.ObjHolder = this;
}
}

class Application {
static public Object ObjHolder; // Defaults to null
•••
}

In this case, when the object's Finalize method executes, a pointer to the object is placed in a root and the object is reachable from the application's code. This object is now resurrected and the garbage collector will not consider the object to be garbage. The application is free to use the object, but it is very important to note that the object has been finalized and that using the object may cause unpredictable results. Also note: if BaseObj contained members that pointed to other objects (either directly or indirectly), all objects would be resurrected, since they are all reachable from the application's roots. However, be aware that some of these other objects may also have been finalized.
In fact, when designing your own object types, objects of your type can get finalized and resurrected totally out of your control. Implement your code so that you handle this gracefully. For many types, this means keeping a Boolean flag indicating whether the object has been finalized or not. Then, if methods are called on your finalized object, you might consider throwing an exception. The exact technique to use depends on your type.
Now, if some other piece of code sets Application.ObjHolder to null, the object is unreachable. Eventually the garbage collector will consider the object to be garbage and will reclaim the object's storage. Note that the object's Finalize method will not be called because no pointer to the object exists on the finalization queue.
There are very few good uses of resurrection, and you really should avoid it if possible. However, when people do use resurrection, they usually want the object to clean itself up gracefully every time the object dies. To make this possible, the GC type offers a method called ReRegisterForFinalize, which takes a single parameter: the pointer to an object.

public class BaseObj {

protected override void Finalize() {
Application.ObjHolder = this;
GC.ReRegisterForFinalize(this);
}
}

When this object's Finalize method is called, it resurrects itself by making a root point to the object. The Finalize method then calls ReRegisterForFinalize, which appends the address of the specified object (this) to the end of the finalization queue. When the garbage collector detects that this object is unreachable again, it will queue the object's pointer on the freachable queue and the Finalize method will get called again. This specific example shows how to create an object that constantly resurrects itself and never dies, which is usually not desirable. It is far more common to conditionally set a root to reference the object inside the Finalize method.
Make sure that you call ReRegisterForFinalize no more than once per resurrection, or the object will have its Finalize method called multiple times. This happens because each call to ReRegisterForFinalize appends a new entry to the end of the finalization queue. When an object is determined to be garbage, all of these entries move from the finalization queue to the freachable queue, calling the object's Finalize method multiple times.

Forcing an Object to Clean Up
If you can, you should try to define objects that do not require any clean up. Unfortunately, for many objects, this is simply not possible. So for these objects, you must implement a Finalize method as part of the type's definition. However, it is also recommended that you add an additional method to the type that allows a user of the type to explicitly clean up the object when they want. By convention, this method should be called Close or Dispose.
In general, you use Close if the object can be reopened or reused after it has been closed. You also use Close if the object is generally considered to be closed, such as a file. On the other hand, you would use Dispose if the object should no longer be used at all after it has been disposed. For example, to delete a System.Drawing.Brush object, you call its Dispose method. Once disposed, the Brush object cannot be used, and calling methods to manipulate the object may cause exceptions to be thrown. If you need to work with another Brush, you must construct a new Brush object.
Now, let's look at what the Close/Dispose method is supposed to do. The System.IO.FileStream type allows the user to open a file for reading and writing. To improve performance, the type's implementation makes use of a memory buffer. Only when the buffer fills does the type flush the contents of the buffer to the file. Let's say that you create a new FileStream object and write just a few bytes of information to it. If these bytes don't fill the buffer, then the buffer is not written to disk. The FileStream type does implement a Finalize method, and when the FileStream object is collected the Finalize method flushes any remaining data from memory to disk and then closes the file.
But this approach may not be good enough for the user of the FileStream type. Let's say that the first FileStream object has not been collected yet, but the application wants to create a new FileStream object using the same disk file. In this scenario, the second FileStream object will fail to open the file if the first FileStream object had the file open for exclusive access. The user of the FileStream object must have some way to force the final memory flush to disk and to close the file.
If you examine the FileStream type's documentation, you'll see that it has a method called Close. When called, this method flushes the remaining data in memory to the disk and closes the file. Now the user of a FileStream object has control of the object's behavior.
But an interesting problem arises now: what should the FileStream's Finalize method do when the FileStream object is collected? Obviously, the answer is nothing. In fact, there is no reason for the FileStream's Finalize method to execute at all if the application has explicitly called the Close method. You know that Finalize methods are discouraged, and in this scenario you're going to have the system call a Finalize method that should do nothing. It seems like there ought to be a way to suppress the system's calling of the object's Finalize method. Fortunately, there is. The System.GC type contains a static method, SuppressFinalize, that takes a single parameter, the address of an object.
Figure 8 shows FileStream's type implementation. When you call SuppressFinalize, it turns on a bit flag associated with the object. When this flag is on, the runtime knows not to move this object's pointer to the freachable queue, preventing the object's Finalize method from being called.
Let's examine another related issue. It is very common to use a StreamWriter object with a FileStream object.

FileStream fs = new FileStream("C:\\SomeFile.txt",
FileMode.Open, FileAccess.Write, FileShare.Read);
StreamWriter sw = new StreamWriter(fs);
sw.Write ("Hi there");

// The call to Close below is what you should do
sw.Close();
// NOTE: StreamWriter.Close closes the FileStream. The FileStream
// should not be explicitly closed in this scenario

Notice that the StreamWriter's constructor takes a FileStream object as a parameter. Internally, the StreamWriter object saves the FileStream's pointer. Both of these objects have internal data buffers that should be flushed to the file when you're finished accessing the file. Calling the StreamWriter's Close method writes the final data to the FileStream and internally calls the FileStream's Close method, which writes the final data to the disk file and closes the file. Since StreamWriter's Close method closes the FileStream object associated with it, you should not call fs.Close yourself.
What do you think would happen if you removed the two calls to Close? Well, the garbage collector would correctly detect that the objects are garbage and the objects would get finalized. But, the garbage collector doesn't guarantee the order in which the Finalize methods are called. So if the FileStream gets finalized first, it closes the file. Then when the StreamWriter gets finalized, it would attempt to write data to the closed file, raising an exception. Of course, if the StreamWriter got finalized first, then the data would be safely written to the file.
How did Microsoft solve this problem? Making the garbage collector finalize objects in a specific order is impossible because objects could contain pointers to each other and there is no way for the garbage collector to correctly guess the order to finalize these objects. So, here is Microsoft's solution: the StreamWriter type doesn't implement a Finalize method at all. Of course, this means that forgetting to explicitly close the StreamWriter object guarantees data loss. Microsoft expects that developers will see this consistent loss of data and will fix the code by inserting an explicit call to Close.
As stated earlier, the SuppressFinalize method simply sets a bit flag indicating that the object's Finalize method should not be called. However, this flag is reset when the runtime determines that it's time to call a Finalize method. This means that calls to ReRegisterForFinalize cannot be balanced by calls to SuppressFinalize. The code in Figure 9 demonstrates exactly what I mean.
ReRegisterForFinalize and SuppressFinalize are implemented the way they are for performance reasons. As long as each call to SuppressFinalize has an intervening call to ReRegisterForFinalize, everything works. It is up to you to ensure that you do not call ReRegisterForFinalize or SuppressFinalize multiple times consecutively, or multiple calls to an object's Finalize method can occur.

Conclusion
The motivation for garbage-collected environments is to simplify memory management for the developer. The first part of this overview looked at some general GC concepts and internals. In Part 2, I will conclude this discussion. First, I will explore a feature called WeakReferences, which you can use to reduce the memory pressure placed on the managed heap by large objects. Then I'll examine a mechanism that allows you to artificially extend the lifetime of a managed object. Finally, I'll wrap up by discussing various aspects of the garbage collector's performance. I'll discuss generations, multithreaded collections, and the performance counters that the common language runtime exposes, which allow you to monitor the garbage collector's real-time behavior.

Convert Custom Objects in XML Data Using Reflection

2005-09-12T07:28:00.000-07:00

//Created By Kaushal
public string ConvertToXML()
{

//output will used to store parent object's xml representation

StringBuilder output = new StringBuilder();

//output will used to store child object's xml representation

StringBuilder refOutput = new StringBuilder();

//I am considering Object Node is Root Node..

output.Append("");

//Getting Count of parent Objects

for (int i=0;i<=this.Count-1;i++)
{

//Getting Properties Info using Reflection

PropertyInfo[] objFields = this.List[i].GetType().GetProperties();

//Adding Reflected Object Type in to XML String as Parent Node of an Entity as Node Name

output.Append("<" + objFields[0].ReflectedType.Name.ToString() + ">");

//Appending Data as seprate Attribute in the node

output.Append("<" + objFields[0].ReflectedType.Name.ToString());

// Accessing each property

foreach(PropertyInfo prop in objFields)
{

//Checking that the current property is Readable or not

if (prop.CanRead)
{

//If yes then checking the return type of the property. If its Value Type or Normal String I am handling it in the ELSE part.

if ((!prop.PropertyType.IsValueType) && (prop.PropertyType !=typeof(System.String)) && (prop.PropertyType !=typeof(Framework.CError)) )

{
//Getting Value from Reflected Object
object oCustomObject = prop.GetValue(this[i] as object,null);

//Appending object's value into XML

if (null!=oCustomObject)
{
//if object type is ref. type then it will go for recursion call in the next private function.

refOutput.Append(ConvertToXML(oCustomObject));
}
else
{
//Getting data of property in case of value type or String
Object strObjectString = prop.GetValue(this.List[i] as object,null);

if (null!=strObjectString)
{
output.Append(" " + prop.Name.ToString() + "='");
output.Append(strObjectString.ToString()+ "'");
}
}
}
}
output.Append("/>");
output.Append(refOutput.ToString());
refOutput.Remove(0,refOutput.Length);
output.Append(" output = output.Replace("Key","ID");
}
output.Append("");
return output.ToString();
}
//Created By Kaushal
private string ConvertToXML(object oUserObject)
{

StringBuilder output = new StringBuilder();
StringBuilder refOutput = new StringBuilder();
Type objectType = oUserObject.GetType().BaseType;
int iCount = objectType==typeof(System.Object)? 1 : (oUserObject as EntityCollectionBase).Count;
output.Append(objectType==typeof(System.Object)? "<" + oUserObject.GetType().Name + ">" : "");

for (int i=0;i<=iCount-1;i++)
{
PropertyInfo[] objFields = objectType==typeof(System.Object)? oUserObject.GetType().GetProperties() : (oUserObject as EntityCollectionBase)[i].GetType().GetProperties();
Object oTmpObject = objectType==typeof(System.Object)? oUserObject : (oUserObject as EntityCollectionBase)[i] as object;
output.Append("<" + objFields[0].ReflectedType.Name.ToString() + ">");
output.Append("<" + objFields[0].ReflectedType.Name.ToString());
foreach(PropertyInfo prop in objFields)
{
if (prop.CanRead)
{
if ((!prop.PropertyType.IsValueType) && (prop.PropertyType !=typeof(System.String)) && (prop.PropertyType !=typeof(Framework.CError)) )
{
object oCustomObject = prop.GetValue(oTmpObject as object,null) as object;
if (null!=oCustomObject)
//Making Nested Calls
refOutput.Append(ConvertToXML(oCustomObject));
}
else
{
Object strObjectString = prop.GetValue(oTmpObject,null);
if (null!=strObjectString)
{
output.Append(" " + prop.Name.ToString() + "='");
output.Append(strObjectString.ToString()+ "'");
}
}
}
}
output.Append("/>");
output.Append(refOutput.ToString());
refOutput.Remove(0,refOutput.Length);
output.Append("
output = output.Replace("Key","ID");
}

output.Append(objectType==typeof(System.Object)? "return output.ToString();
}

4 More Details Mail me @ mail2kaushal@gmail.com

Generate Property Classes On Fly : Kaushal Patel

2005-09-08T07:43:00.000-07:00

Class Used : PropertyBuilder [PropertyBuilder Class defines the properties for a type.]

Code :

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;

class PropertyBuilderDemo
{
public static Type BuildProperties()
{
AppDomain _Domain = Thread.GetDomain();
AssemblyName _AssemblyName = new AssemblyName();
_AssemblyName.Name = "DynamicAssembly";

AssemblyBuilder _AssemblyBuilder = _Domain.DefineDynamicAssembly(_AssemblyName,AssemblyBuilderAccess.RunAndSave);

ModuleBuilder _ModuleBuilder = _AssemblyBuilder.DefineDynamicModule("DynamicModule");
TypeBuilder _TypeBuilder = _ModuleBuilder.DefineType("CustomerData",TypeAttributes.Public);
FieldBuilder _customerName = _TypeBuilder.DefineField("_CustomerName",typeof(string),FieldAttributes.Private);
PropertyBuilder _CustomerName = _TypeBuilder.DefineProperty("CustomerName",PropertyAttributes.HasDefault,typeof(string),new Type[] { typeof(string) });
//Assigning 'Get' Behavior to Customer Name Property
MethodBuilder _GetCustomerName = _TypeBuilder.DefineMethod("GetCustomerName",MethodAttributes.Public,typeof(string),new Type[] { });

ILGenerator _GetILGenerator = _GetCustomerName.GetILGenerator();
_GetILGenerator.Emit(OpCodes.Ldarg_0);
_GetILGenerator.Emit(OpCodes.Ldfld,_customerName);
_GetILGenerator.Emit(OpCodes.Ret);
//Assigning 'Set' Behavior to Customer Name Property
MethodBuilder _SetCustomerName = _TypeBuilder.DefineMethod("SetCustomerName",MethodAttributes.Public,null,new Type[] { typeof(string) });

ILGenerator _SetILGenerator = _SetCustomerName.GetILGenerator();
_SetILGenerator.Emit(OpCodes.Ldarg_0);
_SetILGenerator.Emit(OpCodes.Ldarg_1);
_SetILGenerator.Emit(OpCodes.Stfld,_customerName);
_SetILGenerator.Emit(OpCodes.Ret);
//Attaching Get and Set behaviors to property
_CustomerName.SetGetMethod(_GetCustomerName);
_CustomerName.SetSetMethod(_SetCustomerName);

return _TypeBuilder.CreateType();
}
}

///Client Code

static void Main(string[] args)
{
Type customer = PropertyBuilderDemo.BuildProperties();
PropertyInfo[] properties = customer.GetProperties();
object customerData = Activator.CreateInstance(customer);
properties[0].SetValue(customerData,"CREATED BY : Kaushal Patel",BindingFlags.SetProperty,null,null,null);
string s = properties[0].GetValue(customerData,BindingFlags.GetProperty,null,null,null).ToString();
Console.WriteLine(s.ToString());
Console.ReadLine();
}

4 More Information Do Mail Me @ mail2kaushal@gmail.com

The Importance of Using Managed Code in .NET

2005-09-06T04:29:00.000-07:00

Introduction

What is managed code and why is it important to use 100% managed
code in .NET applications?

Managed code is compiled for the .NET run-time environment. It
runs in the Common Language Runtime (CLR), which is the heart of
the .NET Framework. The CLR provides services such as security,
memory management, and cross-language integration. (3) Managed
applications written to take advantage of the features of the CLR
perform more efficiently

and safely, and take better advantage of developers’
existing expertise in languages that support the .NET
Framework.

Unmanaged code includes all code written before the .NET
Framework was introduced—this includes code written to use
COM, native Win32, and Visual Basic 6. Because it does not run
inside the .NET environment, unmanaged

code cannot make use of any .NET managed facilities. (1)

Advantages of Using Managed Code

Managed code runs entirely “inside the sandbox,”
meaning that it makes no

calls outside of the .NET Framework. That’s why managed
code gets the

maximum benefit from the features of the .NET Framework, and
why

applications built with managed code perform more safely and
efficiently.

Performance

The CLR was designed from the start to provide good performance.
By using 100% managed code, you can take advantage of the numerous
built-in services of the CLR to enhance the
performance of your managed

application. Because of the runtime services and checks that the
CLR performs, applications do not need to include separate versions
of these services. (9) And by using 100% managed code, you
eliminate the

performance costs associated with calling unmanaged code.

Just-In-Time compiler

The CLR never executes Common Intermediate Language (CIL)
directly.

Instead, the Just-In-Time (JIT) compiler translates CIL into
optimized x86

native instructions. (9) That’s why using managed code
lets your software run

in different environments safely and efficiently. In addition,
using machine

language lets you take full advantage of the features of the
processor the

application is running on. For example, when the JIT encounters
an Intel

processor, the code produced takes advantage of
hyper-threading

technology. (5)

Another advantage of the JIT is improved performance. The JIT
learns when

the code
does multiple iterations. The runtime is designed to be able to

retune the JIT compiled code as your program runs. (2)

NGEN utility

NGEN.exe is a .NET utility that pre-compiles the application at
install time.

Pre-compiling improves start-up performance for managed code,
especially

when the application uses Windows Forms. Methods are JITed when
they

are first used, incurring a larger startup penalty if the
application calls many

methods during start-up. Because Windows Forms uses many
shared

libraries in the operating system, pre-compiling Windows Forms
applications

usually improves performance. (12)

Pre-compiling also makes sure that the application is optimized
for the

machine on which it is being installed.

Maintaining a 100% managed code environment

Only when your .NET application uses components that are built
using 100%

managed code do you receive the full benefits of the .NET
environment.

For example, when accessing data through ADO.NET, using wire
protocol

.NET data providers lets you preserve your managed code
environment

because they do not make calls to native Win32 APIs and Client
pieces.

The performance advantages of the managed code environment are
lost

when you (or the components you are using) call unmanaged code.
The CLR

makes additional checks on calls to the unmanaged or native
code, which

impacts performance.

Unmanaged code includes the database client pieces that some
.NET data

providers require. Examples of .NET data providers that use both
managed

and unmanaged code are IBM’s DB2 data provider and the
Oracle Data

Provider for .NET (ODP.NET). Both of these data providers must
use client

libraries to access the database. The data providers shipped
Microsoft for

SQL Server and Oracle—as well as the Microsoft OLE DB data
providers,

and ODBC.NET—make calls to native Win32 database client
pieces or other

unmanaged code.

Automatic memory management

Automatic memory management is one of the most significant
features of

managed code. The CLR garbage collector automatically frees
allocated

objects when there are no longer any outstanding references to
them. The

developer does not need to explicitly free memory assigned to an
object,

which goes a long way toward reducing the amount of time spent
debugging

memory leaks. (10) There can be no memory leaks in 100% managed
code.

Automatic lifetime control of objects

Another significant advantage of using managed code is that the
CLR

provides automatic lifetime management of components and
modules.

Lifetime control includes:

• Garbage collection, which frees and compacts
memory.

• Scalability features, such as thread pooling
and the ability to use a nonpersistent

connection with a dataset.

• Support for side-by-side versions.

Garbage collection

When an object is created with the new operator,
the runtime allocates

memory from the managed heap. Periodically, the CLR garbage
collector

checks the heap and automatically disposes of any objects that
are no longer

being used by the application, reclaiming their memory.

The garbage collector also compacts the released memory,
reducing

fragmentation. (4) This function is particularly important when
the application

runs on large memory servers. Changing the application to use
smaller

objects can help to improve the effectiveness of the garbage
collector.

Similarly, because each DLL is assigned a 64-bit chunk of
memory,

combining small DLLs avoids inefficient use of memory.

Because the garbage collector automatically closes unused
objects, memory

leaks are not possible in an application that uses 100% managed
code.

Scalability features

Thread pooling lets you make much more efficient use of multiple
threads

and is an important scalability feature of using managed code.
The .NET

Framework comes with built-in support for creating threads and
using the

system-provided thread pool. In particular, the ThreadPool class
under the

System.Threading namespace provides static methods for
submitting

requests to the thread pool. In managed code, if one of the
threads becomes

idle, the thread pool injects another worker thread into the
multithread

apartment to keep all the processors busy.

The standard ThreadPool methods capture the caller’s stack
and merge it

into the stack of the thread-pool thread when the thread-pool
thread starts to

execute a task. If you are using unmanaged code, the entire
stack will be

checked, which incurs a performance cost. In some cases, you can
eliminate

the stack checking with the Unsafe methods

ThreadPool.UnsafeQueueUserWorkItem and

ThreadPool.UnsafeRegisterWaitForSingleObject, which provide
better

performance. However, using the Unsafe method calls does not
provide

complete safety. (8)

Further adding to scalability is the ability to use a
non-persistent connection

with a dataset, which is a cache of the records retrieved from
the database.

The dataset keeps track of the state of the data and stores the
data as pure

XML. Database connections are opened and closed only as needed
to

retrieve data into the dataset, or to return updated data.
(7)

Versioning

Versioning essentially eliminates “DLL hell.” When
you define an assembly as

strongly named, the .NET executable will be executed with the
same DLL

with which it was built. This means that you can have
side-by-side versions of

a DLL, allowing you to manage shared components. Versioning
ensures that

each time an application starts up, it checks its shared files.
If a file has

changed and the changes are incompatible, the application can
ask the

runtime for a compatible version.

However, when an application calls unmanaged DLLs, you can end
up back

in “DLL hell.” For example, Oracle’s ODP.NET
data provider calls the

unmanaged Oracle Client pieces, which are specific to a
particular version of

Oracle. You could install two versions of this unmanaged
data provider, for

example, one for Oracle9i and one for the upcoming Oracle10G,
but you

would have a conflict, because each data provider will require a
particular

version of the clients. Since the clients are native Win32 DLLs,
you cannot

easily have side-by-side versions running on the same machine.
Only with

native wire protocol data providers built from 100% managed code
can you

install side-by-side versions with no configuration required by
the end-user.

Checks by the .NET runtime

The .NET runtime automatically performs numerous checks to
ensure that

code is written correctly. Because these checks prevent a large
number of

bugs from ever happening, developer productivity is improved and
the

application quality is better. In addition, these checks thwart
system attacks

such as the exploitation of buffer overruns.

The CLR checks for type safety to ensure that applications
always access

allocated objects in appropriate ways. In other words, if a
method input

parameter is declared as accepting a 4-byte value, the common
language

runtime will detect and trap attempts to access the parameter as
an 8-byte

value. Type safety also means that execution flow will only
transfer to known

method entry points. There is no way to construct an arbitrary
reference to a

memory location and cause code at that location to begin
execution.

In addition, array indexes are checked to be sure they are in
the range of the

array. For example, if an object occupies 10 bytes in memory,
the application

can’t change the object so that it will allow more than 10
bytes to be read.

(11)

Cross-language integration

You can write .NET applications in many different languages,
such as C,

C++, Visual Basic, COBOL, Fortran, Perl, Pascal, Jscript, Lisp,
Python,

Smalltalk, and others. Programmers can use the languages that
they are

most proficient with to develop portions of an application.

All CLR-compliant languages compile to Common Intermediate
Language

(CIL). CIL is the key to making the .NET application
platform-neutral and

hardware independent.

In addition, programmers can choose specific languages for
specific tasks

within the same application. Some languages are stronger than
others for

particular tasks, and programmers can choose the language best
suited for

the task. The originating language doesn’t matter, because
all .NETcompliant

compilers produce CIL.

Platform-neutrality

A managed .NET application can execute on any Windows platform
that

supports the .NET common language runtime. Currently, these
platforms are

Windows 98, Windows 2000, Windows Me, Windows NT, Windows XP,
and

Windows Server 2003 (32-bit). Support for the .NET Framework
and

Common Language Runtime on Windows Server 2003 (64-bit) is
planned for

an upcoming release.

In addition, with the Microsoft Mobile Internet Toolkit,
developers can create a

.NET compliant, mobile Web application that can be adapted to
the display of

multiple wireless devices. (6)

Security

Managed code does not have direct access to memory, machine
registers, or

pointers. The .NET Framework security enforces security
restrictions on

managed code that protects the code and data from being misused
or

damaged by other code. An administrator can define a security
policy to grant

or revoke permissions on an enterprise, a machine, an assembly,
or a user

level. For these reasons, applications that use managed code are
much

safer.

Code access security

Code access security lets the administrator specify which
operations a piece

of code can perform, stopping inappropriate behavior before it
can start. You

can configure a complex set of rules to:

Specify whether a code group can both read and write files

Demand that the code’s callers have specific
permissions

Allow only callers from a particular organization or site to
call the code

Grant permissions to each assembly that is loaded

Compare the granted permissions
of every caller on the call stack at

runtime to the permissions that callers must have and which
resources the

code can access. (6)

The access privileges an administrator assigns depend in part on
where the

application is running. For example, by default, an application
that runs from

the local computer has a higher level of trust and more
privileges, such as

accessing the file system, than an application that is running
from the

Internet.

Calling unmanaged code bypasses the .NET CLR security. An
application

that calls unmanaged code doesn’t necessarily have a
security problem—it

simply has an open door to the possibility of problems due to
the functionality

of the unmanaged code that has direct access to memory or
machine

registers, or uses pointers. Once the unmanaged code is being
executed, the

CLR can no longer check it.

Avoiding buffer overruns

One common type of attack attempts to make API methods operate
out of

specification, causing a buffer overrun. This attack typically
passes

unexpected parameters, such as an out-of-range index or offset
value.

Managed code avoids the buffer overruns that trigger so many
security

snafus.

Buffer overruns usually occur in programs written in languages
such as C or

C++, which do not check array bounds and type safety. If an
application does

not check the validity of the destination buffer size and other
parameters, the

copied data might overrun the buffer, overwriting the data in
adjacent

addresses.

Buffer overruns are theoretically impossible in managed
code.

Summary

Using 100% managed code gives you solid performance, improved
security,

and fewer bugs. The CLR provides memory management and lifetime
control

of objects, including scalability features and versioning. When
you call

unmanaged code, you lose many of the valuable benefits of the
.NET

environment.

References

1.
Gentile, Sam. “Intro to Managed C++, Part 2: Mixing Managed
and

Unmanaged Code.” The O’Reilly Network.

http://www.ondotnet.com/lpt/a/3226
<08/20/2003>

2. Gray, Jan. “Writing Faster
Managed Code: Know What Things Cost.”

MSDN Library. http://msdn.microsoft.com/library/?url=/library/enus/

dndotnet/html/fastmanagedcode.asp
<08/20/2003>

3. Gregory, Kate. “Managed,
Unmanaged, Native: What Kind of Code Is

This?” http://www.developer.com/net/cplus/print.php/2197621

<08/20/2003>

4.
Mariani, Rico. “Garbage Collector Basics and Performance
Hints.” MSDN

Library. April 2003.

http://msdn.microsoft.com/library/default.asp?url=/library/enus/

dndotnet/html/dotnetgcbasics.asp
<08/20/2003>

5. McNaughton, Allan. “Boosting
the Performance of Microsoft .NET.” MSDN

Library.
http://msdn.microsoft.com/library/default.asp?url=/library/enus/

dndotnet/html/optimaldotnet.asp
<08/20/2003>

6. Microsoft Corporation.
“Deployment Guide for the Microsoft Mobile Internet

Toolkit.”
http://msdn.microsoft.com/library/default.asp?url=/library/enus/

dnmitta/html/deploymobilwebapp.asp?frame=true
<08/20/2003>

7. Microsoft. “The Windows
Server 2003 Application Environment.” MSDN

Library.
http://msdn.microsoft.com/library/default.asp?url=/library/enus/

dnnetserv/html/windowsnetserver.asp
<08/20/2003>

8.
Microsoft. .NET Framework Developer’s Guide .
Microsoft .NET Framework

SDK1.0. 2001.

9. Noriskin, Gregor. “Writing
High-Performance Managed Applications: A

Primer.” MSDN Library.

http://msdn.microsoft.com/library/default.asp?url=/library/enus/

dndotnet/html/optimaldotnet.asp
<08/04/2003>

10. Platt, David S. Introducing Microsoft .NET .
Microsoft Press. Redmond, WA.

2001.

11. Richter,
Jeffrey. “Microsoft .NET Framework Delivers the Platform for
an

Integrated, Service-Oriented Web.” MSDN Magazine .

http://msdn.microsoft.com/msdnmag/issues/0900/Framework/default.aspx

<08/20/2003>

12. Schanzer, Emmanuel. “Performance Tips and Tricks in
.NET Applications.”

MSDN Library.
http://msdn.microsoft.com/library/default.asp?url=/library/enus/

Whidbey And Partial Classes : Kaushal Patel

2005-09-04T22:16:00.000-07:00

One of the language enhancements in .NET 2.0—available in both VB.NET 2005 and C# 2.0—is support for partial classes. In a nutshell, partial classes mean that your class definition can be split into multiple physical files. Logically, partial classes do not make any difference to the compiler. During compile time, it simply groups all the various partial classes and treats them as a single entity.

One of the greatest benefits of partial classes is that it allows a clean separation of business logic and the user interface (in particular the code that is generated by the visual designer). Using partial classes, the UI code can be hidden from the developer, who usually has no need to access it anyway. Partial classes will also make debugging easier, as the code is partitioned into separate files.

In this article, I will examine the use of partial classes in more detail and discuss how Visual Studio 2005 makes use of partial classes.

Using Partial Classes
Listing 1 contains two class definitions written in VB.NET, with the second class definition starting with the partial keyword. Both class definitions may reside in two different physical files. Functionally, Listing 1 is equivalent to Listing 2.

Listing 1
'---File1.vb---
Public Class Class1
Public Sub method1()

End Sub
End Class

File2.vb
Partial Public Class Class1
Public Sub method2()

End Sub
End Class
Listing 2
'---File1.vb---
Public Class Class1
Public Sub method1()

End Sub
Public Sub method2()

End Sub
End Class

So, what are the uses for partial classes?

Here are some good reasons to use partial classes:
They allow programmers on your team to work on different parts of a class without needing to share the same physical file. While this is useful for projects that involve big class files, be wary: If you find your class file getting too large, it may well signal a design fault and refactoring may be required.
The most compelling reason for using partial class is to separate your application business logic from the designer-generated code. For example, the code generated by Visual Studio 2005 for a Windows Form is kept separate from your business logic (we will discuss this in a later section). This will prevent developers from messing with the code that is used for the UI. At the same time, it will prevent you from losing your changes to the designer-generated code when you change the UI.

The "partial" keyword in VB.NET used to be called "expands" in pre-beta versions of Visual Studio 2005.

Examining Partial Classes
The following code sample shows the class definition of MyClass1. I declared all my properties in this file. To avoid confusion, I named my class file MyClass1.Properties.vb, in order to make it obvious that this file contains a properties definition.
'---MyClass1.Properties.vb
'---one of the classes need not have the Partial keyword
Public Class MyClass1
Private pX As Integer
Private py As Integer
Property x() As Integer
Get
Return pX
End Get
Set(ByVal value As Integer)
pX = value
End Set
End Property
Property y() As Integer
Get
Return py
End Get
Set(ByVal value As Integer)
py = value
End Set
End Property
End Class
In another file, named MyClass1.Methods.vb, I provide the methods implementation of MyClass1. I used the Partial keyword to indicate that this definition should be combined with the original MyClass1 definition.
'---MyClass1.Methods.vb
'---must have the Partial keyword
Partial Public Class MyClass1
Private py As Integer

Public Sub method1()
' implementation here
End Sub

Public Sub method3(ByVal x As Integer, ByVal y As Integer)
' implementation here
End Sub

Public Sub method2()
' implementation here
End Sub
End Class
In reality, you can mix and match properties and method definitions in any of the files, but for clarity it is a good idea to group properties definitions in one file and methods definitions in another. The usual rules of OO apply: If there is a method1 in both files, then both method1s must have unique signatures.

The syntax of partial classes in VB.NET and C# differs slightly. The following shows the implementation of partial classes in C#:
// In C#, the partial keyword must
// appear in all class definitions
public partial class MyClass1
{
public MyClass1()
{
//implementation here
}
}

public partial class MyClass1
{
//implementation here
}
Besides the order in which the "partial" keyword is placed, the most significant difference is the strict enforcement of the use of the "partial" keyword in all partial classes in C#. It is mandatory, whereas in VB.NET, not all of the partial classes have to have the "partial" keyword. This has caused a significant amount of newsgroup discussion about the rationale for the difference. My advice is that you should always prefix partial classes with the "partial" keyword. At least this will give you a visual clue that part of the implementation of the class lies somewhere else, and it is definitely useful when it comes to debugging.

While partial classes allow you to split the definition of a class into multiple files, you cannot mix languages. That is, all partial classes must be written in the same language. Besides using the "partial" keyword for classes, you can also use it for structures and interfaces.

If your class implements multiple interfaces, it is a good idea to use partial classes to contain the implementation for each interface.

Hide-protecting code is one of the best uses of partial classes; you can prevent mishaps and provide useful code-layer abstraction at the same time. In Visual Studio 2005, Microsoft uses partial classes to hide designer-generated code. For example, in Visual Studio .NET 2003, the designer-generated code for a Windows form is encapsulated within the region "Windows Form Designer generated code"Very often, developers will accidentally modify the code within this region and cause the form to display incorrectly.

In Visual Studio 2005 however, the designer-generated code is no longer visible in the Code View window (see Figure 2). Instead, it is hidden within Solution Explorer.

To see the designer-generated code, go to Solution Explorer and click on the Show All Files button (see Figure 3). Under the name of the Windows form, you will see a file post fixed with the "Designer.vb" name. Double-clicking on Form1.Designer.vb will reveal the designer-generated code:
Partial Public Class Form1
Inherits System.Windows.Forms.Form

_
Public Sub New()
MyBase.New()

'This call is required by the
' Windows Form Designer.
InitializeComponent()
...
Notice that the Form1.Designer.vb file appears under the Form1.vb file in Solution Explorer. This is a good way to represent the relationship between the two files. So what does Visual Studio do to represent this relationship? The answer lies in the .vbproj or .csproj (for C# projects) file. Open the file in Notepad and use Ctrl + F to locate the element:
...

Form

Form1.vb
Form

...
As you can see, the element indicates that Form1.Designer.vb is dependent on Form1.vb. So how is this information useful to us?

Recall that earlier in this article I mentioned two partial classes, MyClass1.methods.vb and MyClass1.properties.vb. Assume that these two classes serve as a template and contain general-purpose functions (and you generally would not make changes to these two classes). You may add a third partial class to add business-specific functions. And so, it would be useful to hide the first two partial classes in Solution Explorer by modifying the .vbproj/.csproj file:

MyClass1

MyClass1.vb
MyClass1

MyClass1.vb
MyClass1

When the project is loaded in Visual Studio 2005, you should see the two partial classes hidden

Unfortunately, at this moment you need to manually modify the project file in order to hide partial classes. Hopefully in the next beta Microsoft will build this function into Visual Studio. Or someone else will write a plugin for that.

In this article, you have seen how to split the definitions of a class into multiple classes using the "partial" keyword. The greatest use of partial classes is undoubtedly the separation of UI and business logic. I am interested to know how else you may be using partial classes.

Executing ASPX pages without a web server : Kaushal Patel

2005-09-02T04:41:00.001-07:00

For the last couple of days, I?ve been writing about creating a standalone ASPX execution environment?a Windows Forms application that executes an ASP.NET page and displays the results in a Web Browser control.

Because of the way the ASP libraries are written, this effectively requires either a couple of communicating but distinct assemblies or a strongly-named assembly in the Global Assembly Cache. In my project, I wrote two distinct assemblies, which worked. But I wondered if I could overcome this requirement, with the hope that I would learn a thing or two in the process. It took some code spelunking (and a venture beyond what is documented), but I succeeded on both fronts.

The article that got me started on this project was Ted Neward?s "Hosting ASP.NET: Running an All-Managed HTTP Server," which I can?t recommend highly enough. Neward opted for the two assembly approach (or more exactly, the same assembly copied into two different directories). My code still retains a class from his example. But while he uses an ASP.NET function to spin up the app domain that the ASPX page runs in, I create mine from scratch.

Here?s a little console app I created:

using System;
using System.Web;
using System.Web.Hosting;
using System.IO;
using System.Runtime.Remoting;
using System.Globalization;
namespace AspHostTest
{
public class MyExeHost : MarshalByRefObject
{
public void ProcessRequest(String page)
{
HttpWorkerRequest hwr =
new SimpleWorkerRequest(page, null, Console.Out);
HttpRuntime.ProcessRequest(hwr);
}
}
class MyAspHost
{
public static object CreateApplicationHost(Type hostType, string virtualDir, string physicalDir)
{
if (!(physicalDir.EndsWith("\\")))
physicalDir = physicalDir + "\\";
string aspDir = HttpRuntime.AspInstallDirectory;
string domainId = DateTime.Now.ToString(DateTimeFormatInfo.InvariantInfo).GetHashCode().ToString("x");
string appName = (virtualDir + physicalDir).GetHashCode().ToString("x");
AppDomainSetup setup = new AppDomainSetup();
setup.ApplicationName = appName;
setup.ConfigurationFile = "web.config"; // not necessary execept for debugging
AppDomain ad = AppDomain.CreateDomain(domainId, null, setup);
ad.SetData(".appDomain", "*");
ad.SetData(".appPath", physicalDir);
ad.SetData(".appVPath", virtualDir);
ad.SetData(".domainId", domainId);
ad.SetData(".hostingVirtualPath", virtualDir);
ad.SetData(".hostingInstallDir", aspDir);
ObjectHandle oh = ad.CreateInstance(hostType.Module.Assembly.FullName, hostType.FullName);
return oh.Unwrap();
}

static void Main(string[] args)
{
MyExeHost myHost = (MyExeHost)CreateApplicationHost(typeof(MyExeHost),"/",Directory.GetCurrentDirectory());
myHost.ProcessRequest("app.aspx");
}
}
}

To compile it, open a Visual Studio .NET command prompt (or any other command prompt session with the C# compiler in the path) and run this command:

csc /t:exe /r:System.Web.dll AppHostTest.cs
Put the exe file in a directory with an ASPX file named app.aspx. Here?s the simple file I?ve used in my tests:

Hello, world.

Today is
<%= DateTime.Now %>.

When you run AppHostTest.exe, you?ll see the raw html that the executed ASPX file creates.

In addition to running this program, you can use VS.NET to debug right into the ASP.NET page. For this to work, you?ll have to instruct the ASP.NET classes to compile your code with debug symbols. You can do this by creating a file called web.config in the same directory. All this file needs to contain is the following XML:

To load the debugger, run this command from the same directory:

devenv /debugexe AspHostText.exe
Load the ASPX file with the Open/File? menu choice, set a breakpoint on a line of code, press F5, and you should see the debugger stop at that line.

Okay. That was fun, but what exactly is going on in the code?

What we?ve done is to create two classes. MyAspHost includes the Main method that runs the show and a static method I?ve called CreateApplicationHost. This latter method serves the same purpose (and takes the same parameters) as a static method of the same name in the System.Web.Hosting.ApplicationHost class. The ASP.NET method does more, and calls a lot of protected functions in the process.

My method does the minimum that is required to get a simple ASPX page to execute, which is to create an app domain, create an object in the app domain, and return a reference to this object to the calling program (in the default app domain). That's essentially what the ASP.NET classes do, but I've left out what isn't absolutely necessary. (The domain ID and application name could be given simpler names, but I chose to use the same algorithm that ApplicationHost.CreateApplicationHost uses.)

The other class in the file is the one that gets instantiated in the new app domain. All it does is create a System.Web.Hosting.SimpleWorkerRequest specifying the page to run and the output System.IO.TextWriter, then hand this request to a static method in the System.Web.HttpRuntime class, which does all the rest.

Next week I?ll write about the documented way to do this same thing, but I should mention the difference between this code and the Kosher code. The salient difference (apart from all the other things I left out) is that the ASP.NET code sets up a PrivateBinPath for the new app domain so it looks for the assembly it creates in a bin directory below the virtual root is uses. This explains the need for the second assembly?ASP.NET forces the Fusion assembly resolver to look for this assembly in a separate place. That?s what allows my code to be so simple; I allow Fusion to look for the new assemblies in the same directory as the executable.

Source : http://radio.weblogs.com/0105476/stories/2002/07/12/executingAspxPagesWithoutAWebServer.html

Executing ASPX pages without a web server

2005-09-02T04:41:00.000-07:00

Hello, world.

Source : http://radio.weblogs.com/0105476/stories/2002/07/12/executingAspxPagesWithoutAWebServer.html

Comparison between J2EE and .NET

2005-08-26T21:31:00.000-07:00

A Comparison between J2EE and .NET from Software Architectureâ€™s
Perspective

Abstract
This paper compares two competing software technologies, J2EE and .NET from the
perspective of software architecture. Both technologies aim at moving the software
complexity away from the developers and letting them focus on the business logic. To
achieve this end, both technologies provide a managed execution environment, a rich set
of libraries, a method for uniform access to data, and an in-built support for backward
compatibility. However, these two technologies take different approaches to meet these
goals. This paper discusses the two approaches and their effect on non-functional
requirements. In software architecture, the non-functional requirements are used to select
the architecture that best suits the constraints of the application among different ones.
This paper compares these two technologies based on the following non-functional
requirements: Usability (how easy to use the technology), Security, Performance,
Stability, Reusability, Comprehensibility, and User Documentation. Based on the
discussion, it has been concluded that neither of the two is a clear winner. Hence that if
one has a team of skilled programmers, with an existing business system using one
technology, realistically it will be better to continue using that system, be it J2EE based
or .NET based.

1. Introduction

Large software systems are inherently complex. Developing and maintaining such large
systems has always been a monumental task. With the advent of Internet, e-business
became an indispensable aspect of a companyâ€™s success. Developing e-business solutions
poses a new set of challenges for software development. Enterprise applications or ebusiness
solutions generally run on heterogeneous networks and have to run on top of
software developed by different vendors. They also involve the use of different network
protocols. Under these constraints, enterprise applications have to satisfy the key
requirements: High availability, Security, Reliability, and Scalability. It is easy to see the
need for a managed environment or run time and a rich set of libraries to support
development of enterprise applications.
The two software giants, Microsoft and Sun, have come up with their own solution
architecture to aid the development of enterprise applications. Microsoftâ€™s .NET is a
framework with a rich set of libraries, a common language runtime and a more powerful
and unified development environment. The alternative from Sun is J2EE. It is actually an
open specification that specifies a set of technologies to solve the problems that arise in
the development of enterprise applications. However, J2EE can also refer to all the
technologies developed using Java. This paper discusses the runtime provided and their
support for enterprise applications by these two technologies. Then it presents a
comparison between these two technologies based on the following non-functional
requirements: Security, Performance, Stability, Reusability, Comprehensibility and User
Documentation.
This paper is organized as follows. Section II and III provides a brief overview of .NET
and J2EE respectively. Section IV discusses the support for runtime in these two
technologies .Section V presents the e-business architecture of .NET and J2EE. Based on
the non-functional requirements, each important aspect of .NET and JAVA are compared
in Section VI. The conclusion is presented in Section VII.
Keywords: .NET, J2EE, Comparison, Non functional Requirements

2. .NET Overview

.NET delivers the infrastructure which can be leveraged to assemble solutions ranging
from the desktop to the enterprise..NET is the amalgamation of the .NET framework, the
basic building block services known as .NET My Services, which includes development
tools such as Visual Studio.NET and infrastructure services provided by the .NET
Enterprise Servers.

2.1. .NET Framework

.NET Framework is the backbone of .NET. It can be broken down into three parts:
Common Language Runtime (CLR), Class libraries, and Web Services and Internal
System Services. It is a one-stop framework to build and deliver applications to any
.NET Framework
.NET My Services or Third
Party Web Services
.NET Enterprise Servers
(SQL Server, Biz Talk, â€¦)
Web Services
Class Libraries
Common Language Runtime (CLR)
Operating System
.NET Solutions
Figure 1: .NET Overview
device. The framework components provide various services to the applications. Some of
the important services include providing I/O, providing UI elements for building web
pages or traditional windows forms-based interfaces, handling data from disparate data
sources using ADO.NET, ensuring application and system security, improving system
stability by run time garbage collection and so forth. We will look at CLR, web services
and .NET enterprise servers in detail in later sections.

2.2 .NET Enterprise Servers

There are many enterprise servers written to help the development of enterprise
applications. Some of the important enterprise servers are SQL Server 2000, BizTalk
Server 200, Exchange Server 2000 and Internet Security and Acceleration Server 200.

3. J2EE Overview

J2EE stands for Java 2 Enterprise Edition. It is the main competitor to .NET. J2EE is an
open specification that defines a multi-tier architecture for developing enterprise
applications. The enterprise architecture is described in section 5 and the other
technologies are shown in the figure.

3.1 J2EE Technologies

The J2EE provides the APIs for integrating different applications and accessing
databases. The following are the different APIs and their functionality.

3.1.1 HTTP

The Http client-side API is defined by the java.net package. The http server-side API is
defined by the servlets and JSP interfaces. These application-programming interfaces are
used for establishing an http connection between the client and the server.
J2EE Solutions
J2EE Technologies
JSP, Servlets JTA Java Mail
Java Beans J NDI Java IDL
Enterprise Java Beans JAAS JavaRMI
JDBC JMS JAX-RPC
Operating System
Figure 2: J2EE Overview

3.1.2 Java Transaction API (JTA)

This application programming interfaces are used for creating, and maintaining a secured
transaction between the client and the server.

3.1.3 Java IDL

JavaIDL allows J2EE application components to invoke external CORBA objects using
the IIOP protocol. These CORBA object may be written in any language.

3.1.4 Java Database Connectivity (JDBC)

The java database application interface provides connectivity to different relational
databases. They provide excellent features to connect to different databases.

3.1.5 Java Message Service (JMS)

The Java Message Service is a standard API for messaging that supports reliable point-topoint
messaging.

3.1.6 Java Naming and Directory Interface (JNDI)

The JNDI API is the standard API for naming and directory access. The JNDI API
provides interfaces to the application components to access naming and directory
services.

3.1.7 Java API for XML-based RPC (JAX- RPC)

J2EE uses the Java API for XML-based RPC (JAX-RPC) to support web services. Web
services can be implemented as a separate Java application using JAX-RPC or it can be
an enterprise java bean (EJB) wrapped using JAX-RPC.

4. Runtime

Runtime is an execution environment upon which software runs. Runtime generally
makes operating system services such as starting up and stopping threads available to the
programs executed. Depending on the runtime, it might also manage memory, enforce
security policies, manage file access and determine how programs behave and interact
with each other.

4.1 .NET

One of the more technical aspects of .NET by definition is the Common Language
Runtime (CLR). The various components of CLR include the common type system
(CTS), common language specification (CLS), the garbage collector, just-in time
compiling and security. The common type system and the common language
specification are the two parts of the two-pronged attack of .NET for making crosslanguage
compatible. The CLR is capable of executing programs written using any
language that meets its common language specification. There are many .NET compliant
languages already available in the industry. Some of them are Jscript.net, C#, Managed
C++, VB.net, and Eiffel.net. The security features will be discussed in a separate section.

4.2 J2EE

The runtime in J2EE is the Java Virtual Machine (JVM). Java is the only high-level
language supported by J2EE. Java is compiled to Java Byte Code which the JVM (Java
Virtual Machine) interprets. The JVM also does garbage collection and security
checking. JVM makes J2EE platform neutral since JVM is available on almost all
platforms. Thus the Java code once written can be executed on any platform. This is one
of the important reasons behind Javaâ€™s success.

5. Enterprise Application Development

Building an enterprise application has come a long way from the days of writing static
HTML pages to complex online transaction management. Enterprise computing has a
reputation for complexity .The complexity stems from the fact that enterprise applications
run on heterogeneous networks and have to run on top of software developed by different
vendors and also involves the use of different network protocols.

5.1 .NET

.NET provides an evolutionary step toward building Web-based applications with the
introduction of ASP.NET. This is an enhancement of Active Server Page (ASP)
technology and, among other things, it introduces a new way to create Web forms. The
most significant change to ASP is the technique called Code Behind, which makes it
possible to separate user interface and business logic. The access to data is through a set
of classes called ADO.NET. This provides a uniform access to the data from enterprise
servers. The technologies ASP.NET and ADO.NET have simplified the development of
enterprise applications. A simple architecture diagram is shown in the figure below.
Client Tier
Web Clients such as browsers
Presentation Tier
ASP.Net, Web forms
Business Tier
ADO.NET
Data Tier
Enterprise Servers such as SQL Servers, Exchange Servers

5.2 J2EE

J2EE architecture contains client tier, web tier, business tier and EIS tier. The figure 2
below gives the complete details of each tier. Note that this figure shows the logical
relationships of the elements. It is not meant to imply a physical partitioning of the
elements into separate machines, processes, address spaces, or virtual machines.
The J2EE application is divided into client tier, web tier, and enterprise information
system.

5.2.1 Client Tier

The client tier is the application that is located on the client machine and it provides the
user interface. The client can be Applet Client or Application Client. The applet is a GUI
application that typically executes in web browsers. The applet client can provide a GUI
to the user. Note that applet client can also be a simple HTML page that is presented to
the user. The application client is an independent client application program that is
developed using more sophisticated GUI environments like swing and awt of JAVA.

5.2.2 Web Tier

Client Tier
Applet Client
HTML, XML
Application
Client
Web Tier
Business Tier
Enterprise Java Beans
EIS Tier
J2SE
Database
Management
Systems
JSP Servlets
Connectors
JAXP, JTA, JMS, Java Mail, JDBC
Connectors
JAXP, JTA, JMS, Java Mail, JDBC
Enterprise
Information System
This uses JSP / Servlets to generate HTML pages to the client tier. This tier takes care of
presentation of information. This tier occasionally uses Java beans for computations.

5.2.3 Business Tier

The business tier consists of the business logic of the application. This tier combined with
web tier acts as the middle ware of the application. This provides the J2EE the flexibility
to integrate with legacy systems. This serves multiple clients using multithreading.
5.2.4 Enterprise Information Systems
These are the legacy systems of the enterprise. They contain the entire data of the
enterprise. Any request from the client goes through the middleware and where it is
passed to the enterprise information systems.

6. Comparison based on Non-Functional Requirements

6.1 Usability

In the development of enterprise applications, J2EE has many advantages compared to
.NET as J2EE was developed for that purpose. The containers available in the J2EE
manage most of the system issues. Some of the important system issues that are worth
mentioning are accessing data from DBMS, managing distributed system issues like
Naming(JNDI), and remote method invocation(RMI ).This lets the application developers
concentrate on the business logic. One more advantage of J2EE is the GUI based
deployment tool which helps in packaging and deploying the enterprise java beans. .NET
has one distinct advantage over J2EE. ASP.NET provides a way to separate code and
user interface components. This is not possible using JSPs and Servlets.
In the development of GUI applications, .NET is easier to use compared to J2EE. Visual
Basic.NET (VB.NET) is a language which aids in rapid development of GUI
applications. Moreover it is easy to use and does not require a highly skilled developer. In
J2EE, Java Swing is used to develop GUI .Though it is a powerful package, it is not as
easy as VB.NET and it requires highly skilled developers.
The cross language compatibility of .NET offers users a variety of languages from which
they can choose a language that best suits their application development. Even a single
application can be written using multiple languages. Although this is a significant
advantage, it has a downside too. Maintaining an application using multiple languages is
difficult. If a person who developed a part of the application in a particular language
leaves the company/project, then it might require high cost to replace that person. In
J2EE, currently only Java is supported. Java is considered the pure language which can
be used for developing all kinds of applications. Since all applications are developed in
Java, it does not have the disadvantage mentioned for .NET. It is also possible to make
J2EE cross language compatible. The Java byte Code is general enough and that a
compiler can be written to convert any language to Java Byte code which can then be
executed by a JVM.
JVM is available in almost all different platforms. .NET is available only for windows
related platforms. However, efforts are made to implement .NET in other platforms,
especially Linux.

6.2 Security

In the world of Internet, Security is a paramount issue. The success of enterprise
computing and web services depends on how secure the application is. Both J2EE and
.NET have strong mechanism for security. Both support HTTPS secure transactions. Both
have the notion of identification, authentication of the user and access control associated
for each user. Both have two types of security: one can be specified external to code and
the other is specified in the code. We will see in detail how it is actually implemented in
each technology.

.NET

In .NET there are two types of security used by the run time (CLR): Code Access
Security and Role Based Security.
The Code Access Security means that the runtime performs security checks before code
is executed by analyzing the metadata and comparing the access requests to the system
settings and during JIT compilation. For example, one important component of code
access security is verifying that code is type-safe.
The Role based security is similar in idea to the security used in Windows today. One can
create roles and assign permissions to them.
In addition, we can have different security policies. A security policy is the set of rules
that the CLR follows when determining if it should grant permission to code.

J2EE

In J2EE, there are two types of security control: Programmatic Access Control and
Declarative Access Control. To disallow an operation based on role or identification is
called the declarative access control. Sometimes, it may be required to decide whether or
not an operation can be allowed based on the data being manipulated. This can be
handled by programmatic access control. In addition, JVM supports byte code
verification and policy based security

6.3 Performance

In .NET, intermediate language (IL) is just-in-time (JIT) compiled to native code and
executed. In J2EE, the Java byte code is interpreted by the JVM. Since interpreting is
slower than executing native code, applications written on .NET perform better than
J2EE applications. This result is published in the website (www.gotdotnet.com) based on
some experiments. It has been said at various Java related websites that if Java byte code
is just-in-time compiled, it performs better than C++ implementations.

6.4 Stability

The stability of an application is improved if it does not lose memory due to memory
leaks. Memory leak refers to a chunk of memory that has no reference in the code and
was not freed. Both runtimes CLR and JVM include a garbage collector. A garbage
collector removes memory leaks and thus increasing the stability of the application.
6.5 Reusability
Both technologies are based on Object Oriented methodologies. .NET framework has an
in-built support for object orientation. Similarly since Java is an object oriented language,
J2EE also supports object orientation. Object oriented methodology facilitates the reuse
of code to a large extent. Hence both technologies are equally powerful with respect to
reusability.

6.6 Comprehensibility

Understanding the architectures of both J2EE and .NET involves a steep learning curve.
This is because of the fact that they are huge and are composed of multiple different
technologies.

6.7 User Documentation

Excellent documentation and tutorials for all technologies related to J2EE are available at
Sunâ€™s website. Microsoft also has a host of information about .NET on its developerâ€™s
website.
Since the comprehensibility of these technologies is difficult, it is prone to misuse. This
can be avoided by providing the recommendations to utilize the technology in the best
way. Sun has created Java Blueprints that contains recommendations for Java
technologies.

7. Conclusion

This paper compared J2EE and .NET based on the non-functional requirements. From the
discussion above, it is obvious that there is no clear winner. Each technology has its own
advantages and disadvantages. Both technologies have support for backward
compatibility. So, it is concluded that if one has a team of skilled programmers, with an
existing business system using one technology, realistically it will be better to continue
using that system, be it J2EE based or .NET based.

Saving an embedded resource xml file at runtime in C#

2005-08-23T06:30:00.000-07:00

I couldn't find a cut & dry solution to this (probably b/c it's too simple for anyone to think they would need an example) so here's how I got an xml file embedded as a resource in a vs2003 project written to the filesystem.

First, you just add an xml file with some default information you want for it to your project and change its build action to Embedded Resource. Then, you find the name of the resource (it can be tricky if you have a few folders) by opening up ildasm and double clicking the MANIFEST node. Using that resource name, you would do something like this:

using System;
using System.IO;
using System.Xml;
using System.Reflection;
string path = Path.Combine(
Environment.GetFolderPath(
Environment.SpecialFolder.ApplicationData),
Application.CompanyName);
path = Path.Combine(path, Application.ProductName);
path = Path.Combine(path, subFolder);
path = Path.Combine(path, "fileName.xml");
if(!File.Exists(path)){
Assembly thisAssembly = Assembly.GetExecutingAssembly();
Stream rgbxml = thisAssembly.GetManifestResourceStream(
"YourNamespace.fileName.xml");
XmlDocument doc = new XmlDocument();
doc.Load(rgbxml);
doc.PreserveWhitespace = true;
doc.Save(path);
}