You can retrieve the sub key count calling the SubKeyCount () method on registry key object.

To create a sub key under any registry key retrieve the reference to that registry key and call CreateSubKey() method.

RegistryKey rk = Registry.CurrentUser.OpenSubKey("Software",true);

RegistryKey subkey = rk.CreateSubKey("Nasha");

rk.SetValue("abcd","abcd");

To delete keys and values there are methods like DeleteSubKey(), DeleteSubKeyTree(), DeleteValue().

There are a lot of other useful methods like

There has been a lot of times when we feel that our application is slowing down or the ASP.Net worker process is not working as its best. Although ASP.NET does recycle its process after certain number of requests or memory Limit but there are times when you feel that you could control these parameters and explicitly restart the worker process.

It is possible to restart the worker process explicitly after a certain number of requests.

In Machine.config under <configuration> <system.web><procesmodel> we have an attribute called requestLimit.

Set this request Limit to the number of requests after you want to recycle your worker process. It can be set to Infinite or any particular number. The default setting is 5000.

Suppose if we set to it say 10 then you will notice that after every 10 requests aspnet_wp process will be recycled. You can note the process id's to feel the change.

Second reason coz of which we may want our process to be recycled is because of high consumption of memory.

In Machine.config under <configuration> <system.web><procesmodel> we have an attribute called memoryLimit. Set the threshold to the amount you want. The default is 60 i.e. 60%. The moment this threshold is reached aspnet_wp will be recycled.

Before we make any changes to the machine.config we must remember that these changes are going to affect all the applications on that machine coz we are these changes at the core level. Hence after making these changes we should bench mark all our applications.

Most of us I guess are familiar with overridering from C++ or Java. Overriding as the term says is to override  the base class  implementation  or provide a new  implementation in the derived class. We can override members in the base class in VB.Net using  the keyword Overrides and in C# using the key word override. To override a base class member in VB.Net it should be marked as  Overridable and in C# they should be marked with virtual. Method signature of the overiddden methods should be same as the base  class methods.

Shadowing :- This is a VB.Net Concept by which you can provide a new implementation for the base class member without overriding  the member. You can shadow a base class member in the derived class by using the keyword "Shadows". The method  signature,access level and return type of the shadowed member can be completely different than the base class member.

Hiding : - This is a C# Concept by which you can provide a new implementation for the base class member without overriding the  member. You can hide a base class member in the derived class by using the keyword "new". The method signature,access level and  return type of the hidden member has to be same as the base class member.

Comparing the three :-

1) The access level , signature and the return type can only be changed when you are shadowing with VB.NET. Hiding and overriding  demands the these parameters as same.

2) The difference lies when you call the derived class object with a base class variable.In class of overriding although you assign a  derived class object to base class variable it will call the derived class function. In case of shadowing or hiding the base class function  will be called.

Let us create a sample application and this check out :-

1) Create a new solution and three projects to it. One VB.Net Class Library, another C# Class Library and C# Console Application as  a Client Application.

2) Name your VB.Net Class Library as Shadowing , C# library as Hiding and Your console application as Client Application.

3) In Shadowing add a class file called Shadow.vb and add the following classes to it.

Public Class BaseShadow

    Public Overridable Function OverrideMe() As String
        Return "Base Class Override Me"
    End Function

    Public Function ShadowMe() As String
        Return "Base Class Shadow Me"
    End Function

End Class


Public Class DerivedShadow
    Inherits BaseShadow

    Public Overrides Function OverrideMe() As String
        Return "Derived Class Override Me"
    End Function

    Public Shadows Function ShadowMe() As String
        Return "Derived Class Shadow Me"
    End Function

End Class

4) In Hiding add class file called Hide.cs and add the following classes to it.

using System;

namespace Hiding
{
        public class BaseHide
        {
                public BaseHide()
                {

                }

                public virtual string OverrideMe()
                {
                        return "Base Class Override Me";
                }

                public string HideMe()
                {
                        return "Base Class Hide Me";
                }

        }

        public class DerivedHide:BaseHide
        {
                public DerivedHide()
                {

                }
                public override string OverrideMe()
                {
                        return "Derived Class Override Me";
                }

                public new string HideMe()
                {
                        return "Derived Class Hide Me";
                }

        }
}

5) Build both the Class Libs and add their refernces to the client console application.

6) Add the following code in the Main of the console Application.

using System;
using Hiding;
using Shadowing;
       
namespace Client_Application
{
        /// <summary>
        /// Summary description for Class1.
        /// </summary>
        class Client
        {
                /// <summary>
                /// The main entry point for the application.
                /// </summary>
                [STAThread]
                static void Main(string[] args)
                {

                        Console.WriteLine("// ****  Overriding **** //");
                        // ****  Overriding **** //

                        Shadowing.DerivedShadow derivedShadowOverrideObject = new Shadowing.DerivedShadow();
                        Console.WriteLine("Accessing thru derived class " + derivedShadowOverrideObject.OverrideMe());

                        Shadowing.BaseShadow baseShadowOverrideObject = new Shadowing.DerivedShadow();
                        Console.WriteLine("Accessing thru base class " + baseShadowOverrideObject.OverrideMe());

                        Hiding.DerivedHide derivedHideOverrideObject = new Hiding.DerivedHide();
                        Console.WriteLine("Accessing thru derived class " + derivedHideOverrideObject.OverrideMe());

                        Hiding.BaseHide baseHideOverrideObject = new Hiding.DerivedHide();
                        Console.WriteLine("Accessing thru base class " + baseHideOverrideObject.OverrideMe());


                        // ****  Hiding **** //

                        Console.WriteLine("// ****  Hiding **** //");
               
                        Hiding.DerivedHide derivedHideObject = new Hiding.DerivedHide();
                        Console.WriteLine("Accessing thru derived class " + derivedHideObject.HideMe());
                       
                        Hiding.BaseHide baseHideObject = new Hiding.DerivedHide();
                        Console.WriteLine("Accessing thru base class " + baseHideObject.HideMe());

                        // ****  Shadowing **** //

                        Console.WriteLine("// ****  Shadowing **** //");

                        Shadowing.DerivedShadow derivedShadowObject = new Shadowing.DerivedShadow();
                        Console.WriteLine("Accessing thru derived class " + derivedShadowObject.ShadowMe());

                        Shadowing.BaseShadow baseShadowObject = new Shadowing.DerivedShadow();
                        Console.WriteLine("Accessing thru base class " + baseShadowObject.ShadowMe());

                        Console.ReadLine();
                }
        }
}

7) Execute the code and checkout the differences. You can even go ahead and change the method signature, accesslevel and return type for Shadowing and check it out.

This modifier is generally used if there are multiple threads using the same object without using the "lock" keyword. Using the volatile modifier ensures that all threads retrieve the latest value of the object.

Using volatile key word does not solve the thread synchronization problem.

Objects which can be marked volatile can be :

• Any reference type.
• Any pointer type (in an unsafe context).
• Datatypes like sbyte, byte, short, ushort, int, uint, char, float, bool.
• An enum type with an enum base type of byte, sbyte, short, ushort, int, or uint.

C# allows you to declare user defined conversions on classes or structs so that classes or structs can be converted to the other type easily. Conversions can be declared either as implicit, which occur automatically when required using the "implicit" keyword, or they occur explicitly using the "explicit" key word which require an explicit casting (i.e. type casting) of the object.

All methods which define conversions must be static.

Check out this example :

1. Create a console application.

2. Add this code given below.

3. Checkout the conversion functions i.e. the conversions of MyNameclass to int and string.

4. Currently the conversion to string and int is "implicit" and hence we have not typed casted the conversion of MyNameclass to string and int in the Main.

5. Compile the program and check the output.The out put should be "Namratha H Shah" and "13".

Code :

public class MyNameclass

{

private string FirstName =null;

private string Initial =null;

private string LastName =null;

public MyNameclass()

{

FirstName ="Namratha";

Initial ="H";

LastName ="Shah";

}

static public implicit operator string(MyNameclass o)

{

return o.FirstName + " " + o.Initial + " " + o.LastName;

}

static public implicit operator int(MyNameclass o)

{

return o.FirstName.Length + o.Initial.Length + o.LastName.Length;

}

public static void Main()

{

string s = new MyNameclass();

int i = new MyNameclass();

Console.WriteLine(s);

Console.WriteLine(i);

Console.ReadLine();

}

}

6. Replace the implicit keyword with explicit and then compile ... the program will not compile unless you explicitly type cast as follows :

string s = (string) new MyNameclass();

int i = (int) new MyNameclass();

7.Make the changes and recompile and execute the program.

• Interface accessors do not use modifiers.
• An interface accessor does not have a body.
• The purpose of the accessor is to indicate whether the indexer is read-write, read-only, or write-only.

class MyClass:Interface1,Interface2
 {
  private int[] ArrayofStrings=new int[100];
  public MyClass()
  {
   
  }

 

  public int this[int index] // Interface1
  {
   get
   {
    return ArrayofStrings[index];
   }
   set
   {
    ArrayofStrings[index]=value;
   }
  }
  
  string Interface2.this[int index]
  {
   get
   {
    return ArrayofStrings[index].ToString() + " String";
   }   
  }
 }

 

 public class MainClass
 {
  public static void Main()
  {
   MyClass o = new MyClass();

   o[1] = 1; // interface1

   Console.WriteLine(((Interface2)o)[1].ToString());  // Interface2

   Console.ReadLine();
  }
 }

 

 

 public interface Interface1
 {
  int this[int index]
  {
   get;
   set;
  }       
 }

 public interface Interface2
 {
  string this[int index]
  {
   get;
  }

 }

Conditional Attribute is defined in System.Diagnostics namespace.

When a conditional method is called its call is determined by the presence or absence of the preprocessor symbol used with the conditional attribute. If this preprocessor symbol is defined then the mehotd call is included else omitted.

Using conditional attibute is an alternative to calling methods in #if & #endif preprocessors.

A method can have multiple conditional attributes. The call to such a method is made if at least one of the conditional symbols is defined.

A conditional method has a few constraints:

• A conditional method must be a method in a class or struct declaration and should not have any return type ... i.e. the return type should be "void".
• The conditional method must be a method in a class or struct declaration a compile-time error occurs if the Conditional attribute is specified on a method in an interface declaration.
• Conditional methods cannot be marked with override keyword.
• Conditional methods can be virtual and the methods which override such a conditional method implicitly becomes Conditional
• Methods defined in an interface cannot be marked as conditional.

Example

Step :

1. Create a new Console Application and define 2 classes MyClass and MyClient.

2. In MyClass define two as shown below.

class MyClass

{

[Conditional("CON_Attrib1")]

public void MyFun1(string name)

{

Console.WriteLine(name);

}

[Conditional("CON_Attrib1"),Conditional("CON_Attrib2")]

public virtual void MyFun2(string name)

{

Console.WriteLine(name);

}

}

3. In MyClient write the preprocessor directives as shown . (They should be the first two lines in the file... above using System ... if not it will not compile)

#define CON_Attrib1

#define CON_Attrib2

4. Call the My Class methods from the main as shown

public class MyClient

{

public MyClient()

{

}

public static void Main()

{

MultiFile1.MyClass oMyClass = new MyClass();

oMyClass.MyFun1("Namratha");

oMyClass.MyFun2("Nasha");

Console.ReadLine();

}

}

4. Build the solution and run . You will see both "Namratha" & "Nasha" ... i.e both the functions were called.

5. Now change the #define CON_Attrib1 to #undef CON_Attrib1. ... i.e. undefining the attribute.

6. Build the solution and run . You will see only "Nasha" ... i.e MyFun1 was not called as the preprocosser directive "CON_Attrib1" is not defined. But MyFun2 is called coz the other preprocessor directive "CON_Attrib2" is defined. When there are moer than one directives it an OR condition hence if any of the preprocessor directive is define the function will be called.

7. MyFun2 is marked as virtual hence if another function overrides its then is becomes conditional implicitly.

.module extern MyClient.netmodule
.assembly extern mscorlib
{
  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         // .z\V.4..
  .hash = (E6 8E F4 00 2B 3C 3C 88 D6 32 F2 72 A3 22 FA C8   // ....+<<..2.r."..
           A7 7B 24 07 )                                     // .{$.
  .ver 1:0:5000:0
}
.assembly MyAssembly
{
  // --- The following custom attribute is added automatically, do not uncomment -------
  //  .custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(bool,
  //                                                                                bool) = ( 01 00 00 01 00 00 )
  .hash algorithm 0x00008004
  .ver 0:0:0:0
}
.file MyClass.netmodule
    .hash = (92 EC 2F E8 F2 90 4B 2D 54 C6 AC 4C C5 69 CF 92   // ../...K-T..L.i..
             37 2B A1 2F )                                     // 7+./
.file MyClient.netmodule
    .hash = (7B 4E 77 76 94 24 D9 3D 26 B4 3C 98 BA B1 49 3E   // {Nwv.$.=&.<...I>
             9C 45 90 0A )                                     // .E..
.class extern public MultiFile2.MyClient
{
  .file MyClient.netmodule
  .class 0x02000002
}
.module MyAssembly.exe
// MVID: {0B92C2A4-6956-4ED7-A40D-BAB2D6C505D4}
.imagebase 0x00400000
.subsystem 0x00000003
.file alignment 512
.corflags 0x00000001
// Image base: 0x071f0000

Wonder why GC has only 2 generations :

The CLR Garbage Collector is a generational, mark-and-compact collector. It follows several principles that allow it to achieve excellent performance. First, there is the notion that objects that are short-lived tend to be smaller and are accessed often. The GC divides the allocation graph into several sub-graphs, called generations, which allow it to spend as little time collecting as possible. Gen 0 contains young, frequently used objects. This also tends to be the smallest, and takes about 10 milliseconds to collect. Since the GC can ignore the other generations during this collection, it provides much higher performance. G1 and G2 are for larger, older objects and are collected less frequently. When a G1 collection occurs, G0 is also collected. A G2 collection is a full collection, and is the only time the GC traverses the entire graph. It also makes intelligent use of the CPU caches, which can tune the memory subsystem for the specific processor on which it runs. This is an optimization not easily available in native allocation, and can help your application improve performance.

What Happens When a Collection Occurs?

Let's walk through the steps a garbage collector takes during a collection. The GC maintains a list of roots, which point into the GC heap. If an object is live, there is a root to its location in the heap. Objects in the heap can also point to each other. This graph of pointers is what the GC must search through to free up space. The order of events is as follows:

1. The managed heap keeps all of its allocation space in a contiguous block, and when this block is smaller than the amount requested, the GC is called.
2. The GC follows each root and all the pointers that follow, maintaining a list of the objects that are not reachable.
3. Every object not reachable from any root is considered collectable, and is marked for collection.

4. Removing objects from the reachability graph makes most objects collectable. However, some resources need to be handled specially. When you define an object, you have the option of writing a Dispose() method or a Finalize() method (or both). I'll talk about the differences between the two, and when to use them later.
5. The final step in a collection is the compaction phase. All the objects that are in use are moved into a contiguous block, and all pointers and roots are updated.
6. By compacting the live objects and updating the start address of the free space, the GC maintains that all free space is contiguous. If there is enough space to allocate the object, the GC returns control to the program. If not, it raises an OutOfmemoryException.