. Net Framework Cornucopia ....

Export to MS word document from ASP .net

2010-09-08T13:07:00.001-05:00

The below C# .Net code will export the data in the data table Dt_Export to an MS word format document. This will be needed in many of the Asp.net application.

Before using this code. Make a template in word, Then save it as Word XML document (File Version 2003 ). Now open it with Notepad or an HTML / XML editor Insert a {0} symbol at the place where you would like the data to be appeared, Now when you do the String.Format {0} will be replace with the required data in the tabular format. This uses XML word format

System.Text.StringBuilder Row_Template = new System.Text.StringBuilder();

Row_Template.Append("");

Row_Template.Append("{0}");

Row_Template.Append("{1}");

Row_Template.Append("{2}");

foreach (DataRow dr in Dt_Exprt.Rows)

{

Acct_NO = dr[0].ToString();

Vnd_Name = dr[1].ToString().Replace("&", "&");

LST_TRNSDT = Convert.ToDateTime(dr[2]).ToString("MM/dd/yyyy");

WordDoc_RowCollection += string.Format(Row_Template.ToString(), Acct_NO, Vnd_Name, LST_TRNSDT);

}

Response.Clear();

Response.ClearHeaders();

Response.Charset = "";

string attachment = "attachment; filename=My Word doc.Doc";

Response.ClearContent();

Response.AppendHeader("content-disposition", attachment);

Response.ContentType = "application/vnd.ms-word";

Response.BufferOutput = false;

//System.IO.StringWriter tw = new System.IO.StringWriter();

//System.Web.UI.HtmlTextWriter hw = new System.Web.UI.HtmlTextWriter(tw);

//DG.RenderControl(hw);

Word_Doc = string.Format(Word_Doc, WordDoc_RowCollection);

Response.Write(Word_Doc);

Response.End();

Converting from MS Word to HTML / XHML

2010-09-08T12:44:00.003-05:00

The below C# .net code helps you to clean your HTML which you may have copied from Microsoft word. This .Net code will remove the unwanted XML and other word specific symbols and gives you a clean and tidy HTML which you can then easily convert to XHTML. In short this C# code will help you to convert MS Word specific HTML document to HTML and there by XHTML

static string CleanHtml(string html)

{

StringCollection sc = new StringCollection();

html = Regex.Replace(html, @"<(o:p|\/o:p)>", "", RegexOptions.IgnoreCase|RegexOptions.Compiled|RegexOptions.Compiled);

html = Regex.Replace(html, @"\s*mso-[^:]+:[^;\x22]+;?", "", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"\s*MARGIN-\w{3,6}:\s*0\w{2}\s*;?", "", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"\s*MARGIN\s*:(\s*0\w{2}){3}\s*;?", "", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"\s*TEXT-INDENT: 0.{2}\s*;", "", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = html.Replace("
", "
");

html = html.Replace(" ", "\t");

html = html.Replace("align=\"middle\"", "align=\"center\"");

Application.DoEvents();

html = Regex.Replace(html, @"<\\?\?xml[^>]*>", "", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"<\/?\w+:[^>]*>", "", RegexOptions.IgnoreCase|RegexOptions.Compiled);

//html = Regex.Replace(html, @", "$1", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"-->\s*\r*( )", "$1", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"(<\w[^>]*style=)(')([^ |>]*)'", "$1$3$5$7", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"(font-family:)\s*(\x22)([\w\s-]*)\s*(\x22)(,)\s*(\x22)([\w\s-]*)\s*(\x22)(,)\s*(\x22)([\w\s-]*)\s*(\x22)(,)\s*(\x22)([\w\s-]*)\s*(\x22)", "$1$3$5$7$9$11$13$15", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"(font-family:)\s*(\x22)([\w\s-]*)\s*(\x22)(,)\s*(\x22)([\w\s-]*)\s*(\x22)(,)\s*(\x22)([\w\s-]*)\s*(\x22)", "$1$3$5$7$9$11",RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"(font-family:)\s*\x22([\w\s-]*)\s*\x22(,)\s*\x22([\w\s-]*)\s*\x22", "$1$2$3$4",RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"(font-family:)\s*(\x22)([\w\s-]*)\s*(\x22)", "$1$3", RegexOptions.IgnoreCase|RegexOptions.Compiled);

Application.DoEvents();

html = html.Replace("·", "\xB7");

if (Quotes)

{

html = Regex.Replace(html, @"(]*)([^/]>)\s*()?", "$1\"/>", RegexOptions.IgnoreCase|RegexOptions.Compiled);

}

else

{

html = Regex.Replace(html, @"(]*)([^/]>)\s*()?", "$1/>", RegexOptions.IgnoreCase|RegexOptions.Compiled);

}

html = Regex.Replace(html, @"(]*)([^/]>)\s*()?", "", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"Style\s*=\x22?\s*mso-?\w*\s*\x22?", "", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"]*>\s*", "", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"]*/>", "", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"(style\s*=\s*\x22[^\x22]*)(\s*\x22\s*Style\s*=\s*\x22)", "$1;", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"Class\s*=\x22?\s*\d*-\d*\s*\x22?", "", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = Regex.Replace(html, @"()([\s\w]*)()", "$2", RegexOptions.IgnoreCase|RegexOptions.Compiled);

html = html.Replace("®", "®");

html = html.Replace("©", "©");

html = html.Replace("™", "™");

return html;

}

.Net Serialization Bug or design ?

2010-06-30T11:47:00.001-05:00

Here in this post i am depicting the most common pattern in our software life, the singleton pattern. But there is another catch on how .Net is designed to handle this pattern. Below is the code for a typical single ton pattern.

class Singleton
{
// Static members are lazily initialized.
// .NET guarantees thread safety for static initialization
private static readonly Singleton instance;
// Note: Constructor is 'protected' but of course child objects can access
protected Singleton()
{ }
public static Singleton Instance()
{
return instance;
}
}
when we say singleton it should not create more than one instance at any point of time at any cost and thereby it should ensure a class has only one instance and provide a global point of access to it.

From the above code it is obvious that no one can create an instance of this class because it is having a private/Protected constructor

But any idea what will happen if you try to de-serialise an instance of this anywhere outside the class?

..........

...........

Yes. In this scenario a new instance of the class would be created and the values from the incoming stream will be assigned to it.

Seems disgusting? Confused? You think that the whole pattern and .Net has broken its rules. These are some of the scenarios which .Net considers as special situations. So .Net CLR is designed in such a way that it allows only the serialising engine to create an instance of this class. And you should take care of this condition separately. Say, the serialised singleton object should always get saved to the same particular location. Or you’ll end up in n number of instance for a singleton object. J

Dynamic Webservice Invoke

2010-06-03T22:44:00.000-05:00

Recently in one of the projects which i am working i came into such a situation in which i need to read a number of web service URL’s, then dynamically call a particular method in it. First i thought of going with reflection alone but further analysis led me to more in depths of reflection which includes a bit of dynamic compilation thereby to create a “webproxy” like stuff at runtime. Thus we can get the actual metadata of the target type using which we can invoke the required method. Here we might need the type definition of the method and return parameter too (if any).

Luckily i just had a common return type which i don’t have to worry too much about. Now that we decided to go with dynamic compilation in .Net Clr and reflection we need to start with a ServiceDescription class to which we can assign a stream which will in turn read the required data from a WSDL URL, a ServiceDescriptionImporter class to import it. Now we need to add the necessary references and do the compilation as required.

Below is just the main part of the code for dynamic compilation in C#

ServiceDescription description = ServiceDescription.Read(stream);
ServiceDescriptionImporter imp = new ServiceDescriptionImporter();
imp.ProtocolName = "Soap"; // Use SOAP
imp.AddServiceDescription(description, null, null);

CodeNamespace namspace = new CodeNamespace();
CodeCompileUnit unt = new CodeCompileUnit();
unt.Namespaces.Add(namspace);
ServiceDescriptionImportWarnings warning = imp.Import(namspace, unt);
if (warning == 0)
{
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
string[] assemblyReferences = new string[2] { "System.Web.Services.dll", "System.Xml.dll" };
CompilerParameters parms = new CompilerParameters(assemblyReferences);
CompilerResults results = provider.CompileAssemblyFromDom(parms, unt);
object o = results.CompiledAssembly.CreateInstance("MyService");
Type t = o.GetType();

And now we can dynamically invoke webservice method with the following code

t.InvokeMember("MyParam", System.Reflection.BindingFlags.InvokeMethod, null, o, null);

}

Code access security in .Net (CAS)

2007-12-13T22:32:00.000-06:00

Code access security in .net (CAS) is a better way of implementing application security by controlling authorization to a particular code part of an assembly there by preventing the execution of unauthorized code from unknown origins. You can do authorization for most of the resource like which you do in RBS (Role based security). But more than a role based security; it is based up on controlling what rights a particular code chunk is having. Like whether it can make an HTTP request, whether it should allow or deny IO access etc. in short CAS assigns permission to a code or code group rather than a role or a name. And mostly it will not consider any ACL (Access control list) parameter during its decision.

CAS uses assembly’s evidence to do or make its decision. Evidence tell us the exact identity of the assembly, it’s originating zone, which code group it belongs to etc. each default code group will be having some permission set. We can change these setting either through configuration wizard present in the control panel or through declarative programming which uses attributes in .net to specify the security permissions it requires. So each time when a .net type is loaded, CLR performs a Code Access Security (CAS) check

CAS is applied to a code mainly by configuring security policy. By default there are 3 security policy levels

These are :

Enterprise Level – This is used for setting policy for an entire enterprise
Machine Level – For setting machine level policies
User Level – For setting policy at user level in a machine

Under each policy level there will be code groups which are then configured to grant some permission sets. For a Default configuration Both enterprise and user will be given full trust and Machine level will be having various code groups which will be configured for Local, intranet, internet, restricted and trusted zones. Later you can configure this according to your need.

So a user can control and decide to trust all assemblies published by a particular publisher like Microsoft or not to trust any assemblies downloaded from the Internet etc…

Console commands like Caspol.exe can also be used to control these permissions. Use a command line argument (- ?) to get help on this tool

The myth in Exception Handling

2007-12-13T02:41:00.000-06:00

Here I would like to explain a bit about one of the best practices in application error handling or exception handling in C#. Normally an exception is raised when a runtime error or an unexpected condition is incurred. So, how to deal with this kind of situations? Whether to trap it in each and every situation (method) you handle? What is the need and use of different exception types?
.
.
.
The answer is, you should trap an exception (By writing the try… catch block) only if you are expecting some particular type of exception for which you know the reason. So that you can rectify and come out of the situation which causing the exception
The other situation is like you have to add some more information to the exception object or you want to wrap the exception caused with some another type and re-throw a different kind of exception.

Don’t ever try to simply catch the exceptions about which you don’t know anything or want to do nothing, but just a re-throw.

Always try to use a much similar or exact exception type which you are expecting and try to stop using the base “Exception” class in each and every situation. For instance if you use SQLexception to catch errors while interacting with the database, it can provide you more properties like SQL error code etc which will help you to get more idea about the situation which has caused the exception

In many place we see code like this.

Catch(Exception ex)
{
throw ex;
}

Here the developer’s intention is just to re-throw the exception. But in most of the situations CLR think that the developer is doing a manual exception throw and it will start building the stack trace from this point, As a result when we see the error page’s stack trace we will not be able to find the exact place or line which caused the actual error, since stack trace will be pointing to the line containing “throw ex” statement.
So better is to avoid this type of coding in future or use just “throw” instead of “throw ex” which will re-throws the exception already available in the context and thus the original stack trace information will be maintained

Attributes in .Net

2007-12-11T23:53:00.000-06:00

So what is a c# attribute or what is an attribute in .Net? Yes, this is one of the main facilities available in .Net which paves the way to declarative programming. When we say declarative, it is when you use data rather than write source code to instruct your application or component to do something like how to behave in a situation or what characteristic these object (.net data type) posses etc

Attributes defines or demands some particular characteristics of a .Net class. If you declare an attribute on a class, it is like either notifying or demanding the CLR that this class needs to be treated in some particular manner or that class is having some particular characteristic

For e.g.:-
Applying the [Serializable] attribute to a class informs the execution runtime that an instance's fields can be serialized and desterilized

Applying the [DllImport] attribute to a method notifies the CLR that the implementation of the method is actually in unmanaged code contained in the specified DLL.
Conversely

Applying the [AssemblyVersion] attribute to an assembly sets the version number of the assembly which is just a characteristic property used for identification

These attributes are recorded in that particula .net type’s metadata table. This extensible metadata information can be queried at run time to dynamically alter the way code executes

There are so many such in-built attributes available in .Net. All of them derives or inherits from System.attribute. This helps us in building custom attributes. We can make a class inherit from System.attribute and define our own attribute rules or behaviors

Code for List.Find in . Net Framework 2.0

2007-11-06T06:51:00.002-06:00

In one of my project I was in need of the List.FindAll method in . Net 2.0. I was unable to find any useful enough details about this, even though I did a good amount of searching in google. After a while, I ended up in the following code . My need was to find the exact object of my custom class in the collection given, matching my criteria. The List.FindAll accepts a predicate as parameter in which we can specify our own criteria. Predicate (System.predicate) is a new facility introduced in .Net 2.0 which enables us to mention our custom criteria.

Here is the code:
public class MYList:List<MyCustomCLASS>
{
private int currentindex;
///

/// Constructor
///

public MYList ()
{}

public List<> GetItemsContaining(double text)
{
return this.FindAll(delegate(MyCustomCLASS myobj) {return myobj.ItemId == text; });

}

Here the GetItemsContaining uses the base class‘s FindAll method to check and return a list of objects matching the criteria. We can also use List.Find (if you want a single object to be returned from the colllection) and List.ConvertAll (Which converts all objects in the collection to specified objects) in the same logic.

And the MyCustomCLASS is nothing but a normal class which contains an ItemId as one of it's property and ofcourse... ya it contaims some other properties too which holds the buisness specific data records

WeakReference in .Net

2007-10-22T02:06:00.000-05:00

There will be scenarios like you have to use a variable or object in .Net, which uses a good part of your computer memory. And then, if the user starts accessing a different part of your application, this object may no longer be necessary and is wasting valuable memory. At this time you can you can end the scope of this variable or delete it, but if the user happens to switch back to this part of the application again, then you'll need to reconstruct this object.

This is the situation in which the WeakReference (System.WeakReference) object in .Net helps us a lot. Also it helps in performance optimization of the application with good memory management.

When the user switches away from the first part of the application, you can create a weak reference to this massive object and destroy all strong references. So that, if memory pressure is high GC will reclaim the memory or else it won’t. You can create a week reference to an object by passing that object as a parameter to the WeakReference’s constructor

Eg:-
WeakReference eg = New WeakReference (obj)

Where obj is your massive object

When the user switches back to the first part of the application, the application can attempt to obtain a strong reference for the massive object (Obj) by accessing the eg’s Target property (WeakReference.Target). If successful, the application doesn't have to do the heavy job of recreating that heavy object again. Target is not a static property so you need to call that object Target property

Eg:-
Obj = eg.Target;

The WeakReference type offers two constructors, this first one receives an object and the second done receives an extra parameter called TrackResurrection which is Boolean value. When this is true, reference is retained after the object's Finalize method has been called. This allows the object to be recreated, but the state of the object remains unpredictable. Use this with heavy objects only and remember that the object WeakReference is also a manage object and will having its own overheads

Predicate and Anonymous functions in . Net

2007-09-26T02:31:00.000-05:00

During the development of one of my project I realized that using predicates are much faster that manual iterations in collections and array list. Just I was wondering why... because any way libraries too have to iterate by each object. But the truth is that when we use predicate or the Action delegate, the is a huge amount of gain both in execution time and performance

Basically a predicate in .Net (System.Predicate) is just a delegate to a user defined method which return true of false base upon some criteria, thus helps in decision making to the call of certain functions like List.FindAll, List.Find etc.

Where as Action delegate (System.Action) specifies a particular action or procedure which has to be applied on each element of the array List and obviously will not be just a Boolean condition determining function
E.g.:- List.ConvertAll for converting each element in an array or List to some another type.
List.Foreach etc….

While Explaining about this there is one more concept or in other words .Net compatible language compiler magic mainly called as anonymous functions in .Net

This makes searching much easier and much cleaner and also some extensibility to the developer, so that he can implement his own decision while searching.

This function may look like

delegate (string msg) { return “ I am anonymous” }

As the function denotes the method is almost passed like inline and there is no name specified for this function. That means we will not be able to recall this method in another place unless if we don’t have the delegate reference. We used to directly assign this type functions to the required delegate reference

Boxing / Unboxing in .Net

2007-09-20T06:19:00.000-05:00

Normally Reference types as the name indicates, are allocated into managed heap were as value types remain in stack and will not be neither garbage collected nor referred to by pointers. But, in many cases, you must get a reference to an instance of a value type mainly because the calling method might be expecting a reference type, in many cases an “object” data type

So in all these scenarios a value type should be converted to a reference type by using a process called boxing. The process goes like this.

1. The amount of Memory needed by the value type is allocated from the managed heap, along with two more additional members which is needed for a reference type . That is type object pointer and the sync block index.
2. The value type's fields are copied to the newly allocated memory in heap.
3. The address of the object is returned. This address is now a reference to an object

And this returned address is passed to the calling function.

Whole of the above process of boxing is automatically taken care and necessary code is generated by the compilers like CSC, (the C# compiler) when value types need to be boxed. But this will definitely degrade and hurt the performance of your code application and memory management, also a garbage collection is needed to free the memory allocated while boxing. Better choice is to avoid writing code which will lead to boxing and use the Generic equivalents of objects and methods whenever it is possible, so that we can avoid boxing and get a compile time type safe code.

Converting a boxed reference type to a value type is called unboxing. For this the values in the reference type need to be copied to the stack. First, CLR check whether the reference type which is going to be boxed is null or a different undesired type when compared to the destination value type. If yes then appropriate exceptions are thrown. Else the address of raw value type (fields) contained within an object is obtained and the values of these fields are copied from the heap to the stack-based value type instance.

In .Net 2.0, CLR allows you to unbox a value type into a nullable version of the same value type.

Unboxing is not the exact opposite of boxing. The unboxing operation is much less costly than boxing.

so you should be aware of when the compiler generates code to perform the boxing /unboxing operations automatically and try to write code that minimizes this code generation, so that you can optimize your application performance .

Finalization / Freachable queue in .Net

2007-09-17T03:41:00.000-05:00

When an application instantiates a new object, if the object's type defines a Finalize method, a pointer to the object is placed on the finalization queue just before the type's instance constructor is called. The finalization queue is an internal data structure controlled by the garbage collector. Each entry in the list points to an object that should have its Finalize method called before the object's memory can be reclaimed.

The garbage collector scans the finalization queue looking for pointers to the objects which are identified as garbage. And when found, it is moved to freachable queue which is another data structure maintained by garbage collector's internal. A special high-priority CLR thread is dedicated to calling Finalize methods and CLR uses a high priority thread to finalize these objects which appear in this freachable queue. The object in Freachable queue is reachable only to this finalization thread. So When writing the finalization method it should concentrate on disposing the local and native objects and shouldn't execute any that makes any assumptions about the thread that's executing the code.

Generics in .Net

2007-07-13T07:34:00.000-05:00

Generics is another mechanism offered by the common language runtime (CLR) and programming languages that provides one more form of code re-use: algorithm re-use.
Basically it is a template like algorithm, procedure or object which doesn't specify what data type it operates on. And later on while instantiating or using this object or procedure we can pass in the actual type we need as type parameter in to this already defined chunk. This can be generically applied to objects of any type.This functionslity is almost similar to template classes in C++ and Generics in Java.

We can use generics for both reference types as well as value types, but it does not allow the creation of generic enumerated types. Also the CLR allows the creation of generic interfaces and generic delegates.
We can make a class generic by placing the immediately after the class name and at this time the data type of is unspecified. And here is called as the type parameters. It is possible to send more than one type parameter to a generic class.

Generics provide the following big benefits to developers:

• Source code protection :

The developer using a generic algorithm doesn't need to have
access to the algorithm's source code.

• Type Safety :

When a generic algorithm is used with a specific type, the compiler and the CLR understand this and ensure that only objects compatible with the specified data type are used with the algorithm. Attempting to use an object of an incompatible type will result in either a compiler error or a run-time exception being thrown. So for this we use generic constraints ,which says that if you want to use me, you have to be this type, inherit this type or implement this interface to call or instantiate this generic algorithm. We implement this using the where clause.

• Cleaner Code:

Since the compiler enforces type safety, fewer casts are required in your source code, meaning that your code is easier to write and maintain.

• Better Performance:

Before generics, the way to define a generalized algorithm was to define all of its members to work with the Object data type. If you wanted to use the algorithm with value type instances, the CLR had to box the value type instance prior to calling the members of the algorithm and this ignites frequent garbage collections.

Type Safety and unsafe Code

2007-07-12T04:09:00.000-05:00

Safe code is code that is verifiably safe. That is, runtime can verify and make sure that it is not referring to inappropriate memory or memory of the wrong type. If we want to work directly with memory addresses and can manipulate bytes at these addresses then we have to declare that code chunk as unsafe using the unsafe Keyword in C#. So that CLR will not do any do any extra verification on this code and it is really possible to verify this code by CLR even if it is required.

Thus the unsafe just means that it is unverifiable by the runtime. And the normal managed code which is verifiable in every means is called the Type Safe code.

All methods that contain unsafe code should be marked with the unsafe keyword. In
addition, the C# compiler requires you to compile the source code by using the /unsafe
compiler switch.

When the JIT compiler attempts to compile an unsafe method, it checks to see if the assembly containing the method has been granted the System.Security.Permissions.Security-Permission with the System.Security.Permissions.SecurityPermission Flag's
SkipVerification flag set. If this flag is set, the JIT compiler will compile the unsafe code and allow it to execute. The CLR is trusting this code and is hoping the direct address and byte manipulations do not cause any harm. If the flag is not set, the JIT compiler throws either a System.InvalidProgramException or a System.Security.VerificationException, preventing the method from executing

All Normal managed code are labeled as type safe by default because it will be using the .Net provided libraries and classes for accomplishing the task

Microsoft supplies a utility called PEVerify.exe, which examines all of an assembly's methods
and notifies you of any methods that contain unsafe code. This will let you know if there may be
Problems running your application via the intranet or Internet

Type in .NET environment

2007-07-11T06:03:00.000-05:00

Type defines a particular structure in which contains some well known phrases like fields, Method, Property, Event. Etc. anything and everything in .Net world should be in the form of this type, so that any other .Net compliant language can understand, query and use these types very easily. And this is what the common type system (CTS) mean. CTS is one of the standard among CLI, common language infrastructure which specify lots of other standards like file formats, metadata which are the trunk parts of the language specification

A sneak look into Object

2007-06-20T02:25:00.000-05:00

In .NET, each heap-allocated object consists of a 4 byte objectheader and 4 byte pointer to a method table, may be called as MethodTablePointer and contains the memory address to the type's method table. Basically, this pointer makes it possible to obtain the type information about any object in the heap as and when you call System.Object’s GetType () method.

The 4 byte objectheader provides five bit flags, one of which is reserved for the garbage collector to mark an object as reachable/unreachable and whether to free or not free the space allocated by that object. The remaining bits refer to a 27 bit index called a syncindex or SyncBlockIndex, which may refer to another table. This index has multiple purposes: As implied by its name it is used for synchronization, whenever the "lock" keyword is used. It is also used as the default hash code for Object.GetHashCode (). It does not provide the best distribution properties for a hash code, but it meets the minimum requirements for a hash code for reference equality.

The syncindex remains constant throughout the life of the object. But we cannot assure that the integer values from Object.GetHashCode () will be unique. The string class overrides this method to take care of the object equality, that’s why the identical string objects are returning the same hash code. And also we are able to use the EQUALS method to compare between two string objects. So whenever you are overriding the EQUALS method you have to override the GetHashCode () also and vise versa in order to bring out a proper meaning while using the EQUALS method.

In future i think that i can find more about these things. so this is only an initial post

LINQ

2007-06-07T01:15:00.000-05:00

So what is LINQ ??. LINQ stands for Language INtegrated Queries. This is one of the important new feature which is going to get released with the next version of Visual Studio (9.0) code-named 'Orcas'. To read more about LINQ visit the following links to read the article written by Marius Bancila who is an MVP .

Article 1
Article 2
Article 3

It’s seems interesting. Let’s wait and see what is going to be the actual chunk

WOW 64 ???

2007-06-06T22:53:00.000-05:00

This is a layer of code in 64-bit versions of Windows that allows a file with a PE32 (32bit) header along with x86 instructions to run under a 64-bit address space, there by providing backward compatibility. This technology even allows 32-bit applications with x 86 native codes in them to run on an Itanium machine, because theWoW64 technology can emulate the x86 instruction set; albeit with a significant performance cost.

Basically
WOW64 = Windows On Windows64

In fact you can find a good indicator of this by looking in your WINDOWS directory where now you will not only find the misnamed SYSTEM32 directory (which holds the 64bit dll’s for the 64bit OS) but also the SYSWOW64 directory which holds 32bit versions of dll’s for the virtual 32bit OS. You can read more about this on the below URL

http://blogs.msdn.com/joshwil/archive/2004/03/11/88280.aspx

A referencing problem

2007-06-04T01:47:00.000-05:00

It’s possible that you can place any data type even though it is not advisable because “struct” belongs to a value type. But the actual problem arises when we place a type like array or some thing as a buffer and call some unmanaged external API to fill it. In this case when a garbage collection occurs there is a chance that the memory of the buffer can get reallocated as a result of GC’s memory compaction process and thus a page fault will result when the API function try to access this buffer. A kind of work around can be done using the “Fixed” keyword which will pin that data type to memory. But this is not the exact one. For a long time I was searching for a solution and I came across a code snippet in one web site which is as follows

using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Explicit)]
struct tstruct
{
[FieldOffset(0)]
public byte service1;
[FieldOffset(1)]
public byte service2;
[FieldOffset(2)]
public byte data1;
[FieldOffset(12)]
public byte data2;
[FieldOffset(22)]
public byte max_data1;
[FieldOffset(23)]
public byte max_data2;
}

To access the data1/2 arrays,use:
tstruct t;
...
byte* b1=&t.data1;
byte* b2=&t.data2;

Then just access b1/2 like a normal array. The thing is that there is will be no index-checking or other thing done by CLR because it directly considers it as a perfect value type and will get completely allocated into stack there by avoiding all operations of GC

Remoting Architecture

2007-06-01T01:24:00.001-05:00

Recently i happened to write a detailed Document on .Net Remoting. I've tried to include almost all the the concepts about remoting and have posted in code project. It also contains a short description about Appdomains,Serialization,Remoting Channels,Channel Sinks ,Sink providers,Formatters etc. To read this article visit http://www.codeproject.com/KB/IP/Remoting_Architecture.aspx and don't forget to cast your vote there if you enjoy it.

WPF (Avalon)

2007-05-21T05:28:00.000-05:00

So at last the Long awaited WPF is going to be launched along with .Net 3.0. The Microsoft Windows Presentation Foundation (formerly code named "Avalon") is built on the .NET Framework, provides new techniques for developing applications, and makes better use of current hardware and technologies

The current Win32-based Windows UI graphics subsystem is aging and limited, and as a result, user interface development has been somewhat, well, constrained at best. While GDI+ allows arbitrary clip regions to be applied when drawing, WPF takes this feature even further: the opacity mask feature not only lets you clip output to any shape, but also lets you modify the opacity of any arbitrary content.

With Win32, and the associated GDI and GDI+ drawing APIs, each control in the UI owns its part of the window exclusively. Windows are carved up by the controls into a set of disjointed regions that are usually, but not necessarily, rectangular. If you pick any single pixel on a window, there will be exactly one control responsible for drawing that pixel.

The problem with this approach is that it makes certain UI effects impossible. WPF breaks free from this limitation. The WPF graphics system offers a completely new programming style. With Win32-based UI technologies, if you want to draw customized graphics, you must write code that responds to repaint requests, drawing the details on demand. This code effectively paints directly to the screen. If that part of the screen becomes obscured by another window and then uncovered, Windows sends a message requesting that this be redrawn. If you want to change the appearance of your graphics, you need to instruct Windows to invalidate the relevant areas of the screen in order to initiate a repaint. Below images depicts this.

Painting in Normal win32

Painting in WPF

While WPF still supports this model, it offers a simpler alternative. In WPF, you can create objects that represent the drawing primitives you wish to use and add these to your UI and thus create a user interface element tree. You can use either XAML markup (XAML is an XML-based language for building trees of .NET objects. It provides a compact and convenient way of creating WPF objects) or traditional application code to do this.

And they are rendered by WPF—you do not need to write any code to handle repaint requests as shown in the above figure. Moreover, when you change a property of such an object, such as the Width property of a Rectangle, the display is updated automatically.

Thus no single control or UI element has exclusive ownership of any part of the window in a WPF application. You can create partially transparent UI elements, or controls that are not visually constrained to their logical rectangle. For example, it's possible for a control to cast a shadow that falls outside of its logical region.

Because WPF composes all of the controls in the window as a single drawing, rather than segregating each control to its own region, it is easy to apply scaling or rotation transformations to the UI as a whole. Thus, since we can scale any WPF UI up or down, WPF applications are effectively resolution-independent.

WPF provides built-in support for animation and video, allowing you to build dynamic UIs more easily.
You can put a Media Element anywhere you might put a button or an ellipse. You can apply all the usual visual operations, such as scaling, rotation, or clipping. It's just a UI element that happens to show video clips. Also you can apply Rich text formatting to any of your control

WPF also provides triggers which is a declarative mechanism that specifies how a control should respond to certain stimuli. Triggers can be declared inside either styles or templates. For example, you could use a trigger to indicate that buttons should always turn green when the mouse is over them

WPF content model allows any content to be used liberally in a content placeholder. For example, the Button control doesn't require you to supply text—you can put anything you want in there. You could put a bitmap, a drawing, or even a layout panel containing several drawings, as shown in this code:

It's even technically possible to use a menu or a textbox as the content of a Button, although that is not a recommended design

Most WPF controls are lookless , meaning they just provide behavior. The appearance is supplied separately in the form of a template. A control typically provides a built-in template so it has a default appearance. Better yet, it can supply several templates—perhaps one to match the XP Luna theme, another to blend in with Aero, and a third to match the classic Windows 2000 theme. However, the template that defines a control's default appearance can be replaced in order to change the look of the control.

For more information click on this link:
http://msdn2.microsoft.com/en-us/netframework/aa663321.aspx

The garbage collector (GC)

2007-05-21T03:12:00.000-05:00

A garbage collector will finalize the objects in the memory heap which is marked as un reachable and their by freeing the allocated memory by that object. GC also performs memory compaction soon after its execution in order to prevent memory fragmentation. Frequent garbage collection could be detrimental to performance

.NET uses a three-generation approach to collecting memory, based on the heuristic that newly allocated memory tends to be freed more frequently than older allocations, which tend to be more permanent. Gen 0 (Zero) is the youngest generation and, after a garbage collection, any survivors go on to Gen 1. Likewise, any survivors of a Gen 1 collection go on to Gen 2. Usually garbage collection will occur only on Gen 0, and only if after it has reached some limit. The cost of allocating memory on the heap under garbage collection is less than that under the C runtime heap allocator. Until memory is exhausted, the cost of allocating each new object is that of incrementing a pointer--which is close to the performance of advancing the stack pointer.

One book by Jeffrey Richter that I have read suggested theoretical limits of 250Kb for Gen 0, 2Mb for Gen 1 and 10Mb for Gen 2. The thresholds are automatically adjusted dynamically according to actual program allocations. If very little memory is being freed in Gen 0 and survives to Gen 1, the threshold is expanded and like wise it is maintained.

The Runtime calls GC when there is a high memory pressure and runtime is not able to find any exact place to allocate a new object or the applied threshold is reached. Normally the Gc is executed as a very low priority thread which will obviously get executed in the absence of other prior threads which can take over the priority.

We can Explicitly call GC by a call to Gc.Collect() and optionally we can pass the generation number on which a garbage collection should occur.
By the method GC.SuppressFinalize(object obj) we can requests that the system not call the finalizer for the specified object.
GC.ReRegisterForFinalize(object obj) will requests that the system call the finalizer for the specified object, for which System.GC. SuppressFinalize(System.Object) has previously been called. Gc. WaitForPendingFinalizers() Suspends the current thread until the thread processing the queue of finalizers.

2007-05-17T05:31:00.000-05:00

Since this is the first post to my blog, I would like to go with a very basic concept of .NET. That is managed and unmanaged.
Managed Code is the code generated by .NET compilers which will be in MSIL form. In other words managed code for which the execution and management is done only by CLR which can understand MSIL. And unmanaged is the code which is not under the control of CLR and will be mostly in the form of normal machine code.
The IL is kept in a file called an assembly, along with metadata that describes the classes, methods, and attributes of the code you've created. This assembly is the single unit of deployment which we need to consider in the .NET world which helps us a lot with X-copy deployment and also it will have a have a strong name as identity which helps to get rid of that worst DLL hell mess. The CLR also JIT compiles the code to machine code at the same machine in which it’s going to execute their by producing suitable code for the machine the assembly is running on. In this way it utilizes the whole power and facility of instruction set provided in that machine.
And the concept of “Appdomains” really makes it easy to manage the execution of assemblies and get rid of the whole over head of Win32 process isolation and management.
The phrase native code is to describe the output of the JIT compiler, the machine code that actually runs in the runtime. It's managed, but it's not IL, it's machine code.
The managed types will get allocated in to a memory heap which is internally managed by garbage collector. (Normally reference types go to heap and value types uses stack and there so emerges the need of boxing and unboxing)
There are restrictions on managed types: They can't use multiple inheritance or inherit from unmanaged types, they can't allow private access with the friend keyword and so on.

First Note

2007-04-26T23:26:00.000-05:00

You Can Expect some good Chunks here sooon