Strong Vs Weak References

Strong Reference -  As long as if application refers to the object. GC will not collect those objects. Those objects we say are strong reference objects.

Weak Reference - Even though application refers to the object, GC may collect those object or may not be. Those objects are weak referenced objects.

Confused ? Let me explain in brief -

We all know GC is a non deterministic background process so we do not know when it will be called. So only weak referenced objects may reside in the memory for the long time or may not be. So it's up to us whether we want our weak references in memory or not. Lets look over the below examples -

Weak references are of two types -

Short Lived: Short weak references looses the reference when GC comes into the picture


Long Lived: Long weak references retained in the memory even GC comes and reclaims the memory. so it means it's not been collected even the Finalizer of the method is called.

How can we create Weak References ?

WeakReference objWeakReference = new WeakReference(null);

How we can achieve this long lived weak References ?

 WeakReference objWeakReference = new WeakReference(null, true);

So now you can easily see this if you want to create a long lived object then you need to set trackResurrection variable to true to stop tracking of a particular object.

So in this way you can create a weak reference. Lets understand this with one example -

So in the above code i am casting my weak reference to strong reference(as i know my strong references will not be collected by GC anyways) and checking whether it's null or not. If it is null or reclaims by GC then i am creating those strings again otherwise weak reference will fetch it from the memory.

You can also check whether your reference is alive or not.

objWeakReference.IsAlive; will return you bool whether the object is in memory or not.

Hope you enjoyed reading the article.

Happy Coding :)

Read More

What is Common Type System ?

CTS - Common Type System as name suggest it define types. How types are defined, declared , used and managed by common Language Runtime.? The main part is it supports cross language type integration. Confused ? Let me give you a simple example.

In C# i will define my Integer variable as int and in VB.Net i will say Integer. So when i will try to see the IL code in ILDASM tool .net treats both variable as Int32. The way of writing an integer may be different in different languages in .Net but Machine instructions are same and this is possible just because of Common Type System.

So that was the basic definition and understanding of CTS. Lets look over the types supported by CTS in .Net -

1. Class
2. Structure
3. Delegates
4. Interface
5. Enumerations

We all know about above types  will discuss this in my later articles

Type Definitions supported by CTS in .Net -

1. Access Modifiers( Type accessibility ) - Public, Private, protected, Internal, Protected Internal
2. Attributes - We can define our custom attributes and provide additional details
3. Base Types - You can derive your class with Base class, not more than one
4. Interfaces - You can implement multiple inheritance using Interface

Type Members supported by CTS in .Net - 

1. Fields
2. Properties
3. Indexes
4. Methods
5. Events
6. Constructors

We all know about the type members i have defined above will discuss in later articles. So these are important things CTS takes care of in .Net

Hope you enjoyed reading the article.

Read More

What is Common Language Specification ?

CLS is more about rules of .Net and it's a subset of CTS(Common Type System). You must be thinking of CTS, don't worry will discuss in my next article.

So CLS, is a basic set of language rules needed by the applications. CLS ensures Interoperability on other .Net languages. So if i want my C# code can communicate with VB code then it should be CLS compliant. If i will voilate any of C# compliant rule my VB.Net code will not be able to communicate with my C# code.

Now you must be thinking how i can assure my code is CLS compliant. So you can write an attribute in your assembly - Assembly.cs file.

[assembly : CLSCompliant(true)]

So after that whenever you will be breaking any of the rule you will get a warning in your code and CLS Compliancy

If you are interested in reading the CLS rules then visit  here

So now you understand about CLS now i will discuss some code to see live example -  

So now if i try to access my non compliant code in other language, I will not be able to use that. So using those warnings i can see that whether my code is CLSCompliant or not.


Hope you enjoyed reading the article.Let me know if you have any queries.

Read More

Garbage Collection - Automatic Memory Management Part II

Welcome friends in the second article of Garbage Collection. Those who have missed the first one can visit here. So in this article i will talk more about Generations.

So In my last article i mentioned GC has 3 generations: Gen 0, Gen1 and Gen 2. If you want to know the max generations used by application write : System.GC.MaxGeneration.

Now question comes How Generations improves the performance ?

Managed heap is divided into generations so that it is possible to eliminate dead objects by visiting a particular generation. By that way GC doesn't need to traverse complete graph of Heap and that improve performance significantly.

Generation 0 : This is the youngest Generation and all newly created and short lived objects goes under this generation until they are large objects(80000 bytes and above). Large objects goes directly in Generation 2

Generation 1 : Objects that are not reclaimed in Gen 0 promote to Gen 1. This contains short lived objects and kind of buffer between short lived and long lived objects.

Generation 2 : This contains long live objects and objects that are not reclaimed in Gen 1 promote to Gen 2. Data that lives long time in the process like static data and objects that survived in Gen 2 GC remains in Generation 2.

More objects in Gen 0, the more your application is good in performance. In my next article i will be writing about Strong Vs Weak reference and Garbage collector methods

Hope you enjoyed reading this article. 

Read More

Garbage Collection - Automatic memory management

While thinking of this question few things are coming in my mind ~ How .Net reclaims objects and memory used by an application ? So the answer is Garbage Collector

Memory management is the main part of CLR and Garbage Collector does the job for CLR. Garbage Collector attempts to reclaim garbage memory or memory occupied by objects those are no longer use by the application.

Advantages of Garbage Collector

1. Allocates memory efficiently in Managed Heap
2. Reclaims objects that are no longer be used by the application and keeps the memory available for other objects.
3. You do not need to worry about memory. You just write your code GC will take care of the things.
4.  Provides safe memory so that an object can not use content of another one.

 By default on 32 bit system each process can have 2 GB of virtual address space and on 64 bit system process can have 8 TB of address space( There is lot more concepts behind to that in case if you are interested then visit here. As .net application developer you deal with virtual address space only, never communicate with the physical memory. Virtual address space is divided into some fragments called blocks. So when application request to allocate memory GC look after these blocks and tries to find single block that is large enough to fulfill your need. It will be unsuccessful to allocate memory if virtual memory allocation manager doesn't find single block.Each proccess has its own managed heap.

When Garbage Collection Occurs ?

1. When system has low physical memory
2. When a process is initialized run time reserves a contiguous region of address space that initially has no storage allocated for it. This region is known as managed heap. The heap maintains a pointer - NextObjPtr. This pointer indicates where the next object is to be allocated within the heap. Initially, this pointer is set to the base address of the managed heap.

When ever you creates an object in the application, operator makes sure that managed heap have enough space to store this object in reserved address space region. If that object get fits in the managed heap then NextObjPTR increments itself to point to new location. If managed heap doesn't have enough space to store the object or object can not be fit it the reserved space region then garbage collection must be performed. The heap detects this by adding the size of the new object to NextObjPtr. If pointer is beyond the end of the region, then the heap is full and a collection must be performed.
         
So now you know how Garbage Collection performed in an application but this was the over view. Garbage collector maintains some generations to manage objects. So now the question comes into the mind :

How Garbage Collector reclaims memory ?

The Garbage Collector checks whether the object in heap is still in use or it's dead or not being used by the application. If it's not being used by the application then Garbage Collector claims that memory. So now the question comes in the mind How GC knows whether this object is in use or not ?

So each application has some set of application roots and these roots are maintained by CLR. These are kind of pointers those points to the storage location and those location refer objects. If those objects are null then GC reclaims that.

Application Roots: Global objects, static pointers and local object pointers that resides under thread stack are considered as application roots. From these roots GC identifies the dead objects.

Now we can see that Application roots are pointing to four objects : Object c, object D, Object F and Object H but Object C is pointing towards Object G as well. So these objects are still referring in the application but other objects are dead or not referring in the application. GC marked those objects as Garbage. So this was the first phase of GC known as Marking Phase.

Second stage is Relocation and Compaction : In this GC traverse linearly through the Heap, looking for memory blocks of Garbage objects and consider it as free memory. Now shifts all the non garbaged objects down in the heap and update the references to the objects using memcpy method. Lets look over the new graph after this phase -

                                 
GC only occurs when managed heap is full. So that's how GC algorithm works. Now GC also have Generation concepts to improve performance.

Generation 0: It's a youngest generation and contains all newly created objects.

Generation 1: Objects, who survives after next GC occurs, then they promote to Generation 1.

Generation 2: It's for long lived objects like objects those exists through out the application like static objects.
  
I will talk more about Generations in my Next article.

Hope you enjoyed this article.

Read More

Clr - Common Language Runtime

.Net framework provides a run time environment - CLR. Common language runtime takes the IL code from the compiler( language specific) and provide to code to run time compiler called JIT. So lot of confusion you must be thinking about IL code & Jit ?

IL code is half compile or partially compile code. IL code will be same for all .Net framework languages whether application is developed using C#, VB or any other .Net framework language. .Net provides you this managed environment to write your code and get benefit from this.

In short CLR comes into the picture after .Net compiles the code and convert it into IL code and then CLR takes the responsibility does the operation and provide the code to JIT. JIT are the run time compilers that converts code to machine language.

Benefits of CLR -

1. Garbage Collection - Automatic memory management
2. Thread management
3. Common type system
4. CLS - provides ability to use components developed in different languages
5. Code Access Security (CAS)
5. Exception handling
6. It converts MSIL code to Native code and provides it to Just in time compiler

So now question arises how runtime knows about the code you write in a file and provides you these benefits so here the magic comes of Metadata.

When you write your code in .net environment and compile the code. .Net creates an assembly and assembly contains metadata. Metadata resides with the code and every loadable PE(executable) contains this metadata.Metadata contains binary information of the code. Every member defined in an assembly/ module metadata contains all this info. When code is executed, Run time loads this metadata into memory and get the reference about the code to do the above mentioned operations.

code that  managed in this way called managed code. In simple way if i say the code is taken care by CLR is managed code.

Hope you enjoyed reading this article. Please provide me your feedback if you find it interesting.

Read More

.Net Framework overview

Hello friends : Here i am writing my first article on .Net framework anyways....So the question is What is .Net Framework ?

The .Net framework is a software framework / technology that supports multiple languages and designed to develop window, web & mobile apps in short next generation applications.

Points to remember:

1. It provides consistent environment to write applications in multiple languages.
2. It provides consistent OOPS environment
3. It provides an environment to reduce development effort, eliminates performance problems, provides you automatic memory management.
4. .Net ensures all communication as per industry standards so that apps can easily communicate with other frameworks/ technologies.

.Net framework consists of two important concepts : CLR and framework class libraries.

1. CLR : is the heart of .Net that takes care of code execution & services like - memory management, thread management, code access security(CAS model) & Type safety.
2. Framework Library : classes, interfaces, base data type, exceptions, perform I/O, rich gui, mostly .Net framework library is CLS compliance and can directly/indirectly interacts from any other programming languages.

I will discuss more about CLR and framework libraries in later of my articles. Hope you enjoy reading this article.

Happy Coding
Image reference from - here

Read More

What is Var keyword in C#

Var is an implicit data type. It means var can represent any data type that can represent at compile time. So it means var does compile time type casting.

Lets look on some code :

So now we can easily see that from the above code we can not implicitly convert string to int. If we check this with ILDASM tool then we will not see any var keyword in IL code. .Net will treat this as Int variable.
Some more point to notice about var :

1. We can not assign null to var keyword.
2. We can not pass var as a parameter of the method.
3. We can not define return type as var in our method.
4. There is no performance issue with var as .Net execution engine doesn't bother about Var. It will treat it as int or the type we defined at compile time.
 Var mystring = "mystring"; will define mystring as string variable.

Happy Coding Hours

Read More