What are the contents of assembly?

In general, a static assembly can consist of four elements:

The assembly manifest, which contains assembly metadata.

Type metadata.

Microsoft intermediate language (MSIL) code that implements the types.

A set of resources.

What is Manifest?

Assembly metadata is stored in Manifest. Manifest contains all the metadata needed to do the following things

Version of assembly

Security identity

Scope of the assembly

Resolve references to resources and classes.

The assembly manifest can be stored in either a PE file (an .exe or .dll) with

Microsoft intermediate language (MSIL) code or in a stand-alone PE file that contains only assembly manifest information.

What is shadowing?

When two elements in a program have same name, one of them can hide and shadow the

Other one. So in such cases the element which shadowed the main element is referenced.

Below is a sample code, there are two classes "ClsParent" and "ClsShadowedParent".In

"ClsParent" there is a variable "x" which is a integer."ClsShadowedParent" overrides

"ClsParent" and shadows the "x" variable to a string.

Public Class Form1

    Inherits System.Windows.Forms.Form

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        Dim a As New raj2

        MsgBox(a.x)

        'Dim b As New raj1

        'MsgBox(b.x)

    End Sub

    Public Class raj1

        Public x As Integer = 10

    End Class

    Public Class raj2

        Inherits raj1

        Public Shadows ReadOnly Property x() As Integer

            Get

                Return 16

            End Get

        End Property

    End Class

End Class

What is serialization?

Serialization is the process of converting an object into a stream of bytes. Deserialization is the opposite process of creating an object from a stream of bytes. Serialization/Deserialization is mostly used to transport objects (e.g. during remoting), or to persist objects (e.g. to a file or database). Serialization can be defined as the process of storing the state of an object to a storage medium. During this process, the public and private fields of the object and the name of the class, including the assembly containing the class, are converted to a stream of bytes, which is then written to a data stream. When the object is subsequently deserialized, an exact clone of the original object is created.

Binary serialization preserves type fidelity, which is useful for preserving the state of an object between different invocations of an application. For example, you can share an object between different applications by serializing it to the clipboard. You can serialize an object to a stream, disk, memory, over the network, and so forth. Remoting uses serialization to pass objects "by value" from one computer or application domain to another.

XML serialization serializes only public properties and fields and does not preserve type fidelity. This is useful when you want to provide or consume data without restricting the application that uses the data. Because XML is an open standard, it is an attractive choice for sharing data across the Web. SOAP is an open standard, which makes it an attractive choice.

There are two separate mechanisms provided by the .NET class library - XmlSerializer and SoapFormatter/BinaryFormatter. Microsoft uses XmlSerializer for Web Services, and uses SoapFormatter/BinaryFormatter for remoting. Both are available for use in your own code.

What is Delegates?

 It is a procedure pointer, which stores the memory address of another procedure. It can be applied with

1.Sub procedure

2.Function procedure

But not property procedure.

Delegate is a class that can hold a reference to a method or a function. Delegate class has

a signature and it can only reference those methods whose signature is compliant with the

class. Delegates are type-safe functions pointers or callbacks.

Program

Ex:-

Public Class Form1

    Delegate Sub abhisek(ByVal x As Integer, ByVal y As Integer)

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        Dim a As abhisek

        a = AddressOf rajiv

        a.Invoke(10, 20)

    End Sub

    Public Sub rajiv(ByVal x As Integer, ByVal y As Integer)

        Dim z As Integer

        z = x + y

        MsgBox(z)

    End Sub

End Class

Ex2

Public Class Form2

    Delegate Sub raj(ByVal x As String)

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        Dim x As raj

        x = AddressOf rajiv

        x.Invoke("Adarsh kumar")

    End Sub

    Private Sub rajiv(ByVal s As String)

        MsgBox("Hello:" & s)

    End Sub

End Class

What's an abstract class?
A class that cannot be instantiated.  An abstract class is a class that must be inherited and have the methods overridden. An abstract class is essentially a blueprint for a class without any implementation.

What is Polymorphism?

It is a feature that allows one interface to be used for general class of actions. The specific action is determined by the exact nature of the situation. In general polymorphism means "one interface, multiple methods", this means that it is possible to design a generic interface to a group of related activities. This helps reduce complexity by allowing the same interface to be used to specify a general class of action. It is the compiler's job to select the specific action (that is, method) as it applies to each situation

What is Method overloading?
Method overloading occurs when a class contains two methods with the same name, but different signatures.

Ex:-

Public Class Form1

    Inherits System.Windows.Forms.Form

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        Call pintu(60, 30)

        Call pintu("rahul")

    End Sub

    Public Sub pintu(ByVal x As Integer, ByVal y As Integer)

        Dim z As Integer

        z = x / y

        MsgBox(z)

    End Sub

    Public Sub pintu(ByVal s As String)

        MsgBox("hello" & s)

    End Sub

End Class

How a base class method is hidden?

Overriding a method, you change the behavior of the method for the derived class.  Overloading a method simply involves having another method with the same name within the class.

Public Class Form1

    Inherits System.Windows.Forms.Form

    Dim a As New sagar1

    Dim b As New sagar2

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        MsgBox(a.amit(10, 20))

        MsgBox(b.amit(5, 10))

    End Sub

    Public Class sagar1

        Public Overridable Function amit(ByVal x As Integer, ByVal y As Integer)

            Dim z As Integer

            z = x + y

            Return z

        End Function

    End Class

    Public Class sagar2

        Inherits sagar1

        Public Overrides Function amit(ByVal x As Integer, ByVal y As Integer)

            Dim z As Integer

            z = MyBase.amit(x, y) * 5

            Return z

        End Function

    End Class

End Class

What is assembly?

Assembly is unit of deployment like EXE or a DLL.

 An assembly consists of one or more files (dlls, exe's, html files etc.), and

represents a group of resources, type definitions, and implementations of those

types. An assembly may also contain references to other assemblies. These

resources, types and references are described in a block of data called a manifest.

The manifest is part of the assembly, thus making the assembly self-describing.

An assembly is completely self-describing.An assembly contains metadata

information, which is used by the CLR for everything from type checking and

security to actually invoking the components methods.As all information is in

assembly itself it is independent of registry.This is the basic advantage as

compared to COM where the version was stored in registry.

Multiple versions can be deployed side by side in different folders. These

different versions can execute at the same time without interfering with each

other.Assemblies can be private or shared. For private assembly deployment,the

assembly is copied to the same directory as the client program that references

it.No registration is needed, and no fancy installation program is required.

When the component is removed, no registry cleanup is needed,and no uninstall

program is required. Just delete it from the hard drive.

 In shared assembly deployment, an assembly is installed in the Global Assembly

Cache (or GAC). The GAC contains shared assemblies that are

globally accessible to all .NET applications on the machine.

What are Sealed classes?

Sealed classes are used to restrict the inheritance feature of object-oriented programming. Once a class is defined as sealedclass, this class cannot be inherited. In C#, the sealed modifier is used to define a class as sealed. In Visual Basic .NET, NotInheritable keyword serves the purpose of sealed. If a class is derived from a sealed class, compiler throws an error.
If you have ever noticed, structs are sealed. You cannot derive a class from a struct. 
The following class definition defines a sealed class in C#:

// Sealed class

sealed class SealedClass

{

    }

In the following code, I create a sealed class SealedClass and use it from Class1. If you run this code, it will work fine. But if you try to derive a class from sealed class, you will get an error.

using System;

class Class1

{

    static void Main(string[] args)

    {

        SealedClass sealedCls = new SealedClass();

        int total = sealedCls.Add(4, 5);

        Console.WriteLine("Total = " + total.ToString());

    }

}

// Sealed class

sealed class SealedClass

{

    public int Add(int x, int y)

    {

        return x + y;

    }

} 


Why Sealed Classes?
We just saw how to create and use a sealed class. The main purpose of a sealed class to take away the inheritance feature from the user so they cannot derive a class from a sealed class. One of the best usage of sealed classes is when you have a class with static members. For example, the Pens and Brushes classes of the System.Drawing namespace.
The Pens class represent the pens for standard colors. This class has only static members. For example, Pens.Blue represents a pen with blue color. Similarly, the Brushes class represents standard brushes. The Brushes.Blue represents a brush with blue color.
So when you're designing your application, you may keep in mind that you have sealed classes to seal user's boundaries.
In the next article of this series, I will discuss some usage of abstractclasses.

What is Catching?

Catching:- It is a performance improvement technique.

1.It handles storage of frequently accessed data in the memory of the system so that user can access data very quickly.

2.It is used to store recently visited webpage.suppose we are surfing the site and watching various pages. At the time we want to go back to the previous page it loads the page from the memory instead of the server.

3.It has a disadvantage too. Suppose the website is continuously updated the user is not able to watch the changes.

ASP.Net provides three basic types of caching:

• Page level output caching
• Fragment caching
• Data Caching

Page level output caching:

Page caching is mainly used for static pages, where the contents does not change. Output caching has the advantage of being incredibly simple to implement, and are sufficient in many cases.

This technique caches the output of a page so that content of pages are not generated every time it is loaded. Output caching simply keeps a copy of the HTML that was sent in response to a request in memory. In this case the subsequent requests are severed with the cached out until cache expires. This gives a great performance increase of web application.

Just add the OutputCache directive to the page you wish to cache.
for eg.  <%@ OutputCache Duration="30" VaryByParam="none" %>

Code snippet:

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Sample.aspx.cs" Inherits="Sample" %>

<%@ OutputCache  Duration="10"  VaryByParam="none"%>

Date time:

<% DateTime t =  DateTime.Now;

  Response.Write(t.ToString()); %>

This page is cached for 10 seconds. When this page was last cached the date/time was 1/1/2009 11:27:27 AM. When you refresh repeatedly this time remains constant until the cache is expired, then it is updated to the current time. So after 10 seconds, you can get the current time. This is because, ASP.Net caches the HTML using Output Caching.

Page Fragment Caching:

This type of technique is used when we need to cache only a part(or rather Fragment) of page instead of the whole page. Suppose, if we need to cache only header of a page, then instead of caching the whole page, its better to cache only header.

When you login to a website, you might find your name on the header. This happens with all the users. So header has to be stored in cache till he logs out. So the header has to be an user control. Fragment caching is applied to this user control.

Just add the OutputCache directive to the user control page you wish to cache.
for eg.  <%@ OutputCache Duration="30" VaryByControl="Header1" %>

This will cache Header1 for 30 seconds

Data Caching:

Data caching is also called Application caching. It is much more powerful than the other two caching options. It caches data as objects and its scope is as that of the application. Here, an item is cached under a name , then extract it with the same name when required. Data caching is done using "cache"  class.

Data caching is done in this way:

Cache["ID"] = EmployeeID;

Here EmployeeID is cached under "ID" key.

Now while extracting,

EmployeeID = Cache["ID"];

Where does cached data gets stored?

The location for cached data can be specified in OutputCache directive.

• Any - This stores the output cache in the client's browser, on the proxy server (or any other server) that participates in the request, or on the server where the request is processed. By default, Any is selected. 
• Client Caching - This stores output cache in the client's browser. 
• Downstream - This stores the output cache in any cache-capable devices that participate in the request. To store the output cache on any HTTP 1.1 cache-capable devices including the proxy servers and the client that made request.
• Web Server Caching - This stores the output cache on the Web server. 
• None - Output caching is deactivated.

What are Web form events?

Refer the below link

http://www.codeproject.com/Articles/73181/ASP-NET-Web-Form-Model-with-Partial-Rendering-and

What are Session stage options?

Refer the below link

http://www.codeproject.com/Articles/7182/Session-management-options-in-ASP-NET

What is view state?

The web is stateless. But in ASP.NET, the state of a page is maintained in the in the page itself automatically. How? The values are encrypted and saved in hidden controls. this is done automatically by the ASP.NET. This can be switched off / on for a single control

Thanks