DOTNET FAQ-5

4. Remoting and Webservices


(B)What is an application domain?
Previously “PROCESS” where used as security boundaries. One process has its own
virtual memory and does not over lap the other process virtual memory; due to this one
process can not crash the other process. So any problem or error in one process does not
affect the other process. In .NET they went one step ahead introducing application domains.
In application domains multiple applications can run in same process with out influencing
each other. If one of the application domains throws error it does not affect the other
application domains. To invoke method in a object running in different application domain
.NET remoting is used.
Figure :- 4.1 One process can have multiple Application domains
(B) What is .NET Remoting ?
.NET remoting is replacement of DCOM. Using .NET remoting you can make remote
object calls which lie in different Application Domains. As the remote objects run in
different process client calling the remote object can not call it directly. So the client uses
a proxy which looks like a real object.
When client wants to make method call on the remote object it uses proxy for it. These
method calls are called as “Messages”. Messages are serialized using “formatter” class
and sent to client “channel”. Client Channel communicates with Server Channel. Server
Channel uses as formatter to deserialize the message and sends to the remote object.
4. Remoting and Webservices
151
Figure :- 4.2 Channels, Formatters and Proxy in action.
(B) Which class does the remote object has to inherit ?
All remote objects should inherit from System.MarshalbyRefObject.
(I) What are two different types of remote object creation mode in .NET ?
There are two different ways in which object can be created using Remoting :-
√ SAO (Server Activated Objects) also called as Well-Known call mode.
√ CAO (Client Activated Objects)
SAO has two modes “Single Call” and “Singleton”. With Single Call object the object is
created with every method call thus making the object stateless. With Singleton the object
is created only once and the object is shared with all clients.
CAO are stateful as compared to SAO. In CAO the creation request is sent from client
side. Client holds a proxy to the server object created on server.
(A) Describe in detail Basic of SAO architecture of Remoting?
For these types of questions interviewer expects small and sweet answers. He is basically
looking at what you know about the specific subject. For these type of question this book
will provide detail code which is not necessary to be said during interview. Only the basic
steps and overall brief are enough to convince that you have knowledge about the subject.
Even though this question has detail code and answer say only what is needed in interview.
152
Remoting has at least three sections :-
√ Common Interface which will be shared between them.
√ Server.
√ Client.
Figure :- 4.3 Solution Explorer of Remoting Project
In CD “RemotingSample(SAO)” project is provided which gives a insight of remoting.
Above is the figure which shows the three important project sections needed to implement
remoting.
First important section is the common interface between Server and
Client.”InterFaceRemoting” project has the interface code. For sample project interface
is very simple with only two methods :- SetValue and GetValue.
Public Interface InterFaceRemoting
Sub SetValue(ByVal value As String)
Function GetValue() As String
End Interface
Second important section is the server.In this sample server is using HTTP channel and
the server object is singleton.
Imports System
Imports System.Runtime.Remoting
Imports System.Runtime.Remoting.Channels.Http
Imports System.Runtime.Remoting.Channels
Imports InterFaceRemoting
Public Class RemotingServer
Inherits MarshalByRefObject
153
Implements InterFaceRemoting.InterFaceRemoting
Private strData As String
Public Function GetValue() As String Implements
InterFaceRemoting.InterFaceRemoting.GetValue
Return strData
End Function
Sub New()
strData = “testing..”
End Sub
Public Sub SetValue(ByVal value As String) Implements
InterFaceRemoting.InterFaceRemoting.SetValue
strData = value
End Sub
End Class
Module ModuleRemotingStartUp
Sub Main()
Dim objHttpChannel As HttpChannel
Console.WriteLine(“Server Started....”)
objHttpChannel = New HttpChannel(1234)
ChannelServices.RegisterChannel(objHttpChannel)
RemotingConfiguration.RegisterWellKnownServiceType(GetType(RemotingServer),
“RemoteObject”, WellKnownObjectMode.Singleton)
Console.WriteLine(“Server registered and listening waiting
for clients...”)
Console.ReadLine()
End Sub
End Module
Following is detail explanation :-
√ Channel object is created and registered.
Following is the code.
Dim objHttpChannel As HttpChannel
Console.WriteLine(“Server Started....”)
objHttpChannel = New HttpChannel(1234)
ChannelServices.RegisterChannel(objHttpChannel)
√ Server then hosts the object so that client can connect to it. This is the time
when we specify what mode the server object will be created i.e. Singleton or
SingleCall. This is done by the following below given code. Note in sample we
154
are hosting the server object in singleton mode that means that the same object
will be shared between all clients. Also note the server object is implementing
“InterFaceRemoting” and inheriting from “MarshalByRefObject”.
RemotingConfiguration.RegisterWellKnownServiceType(GetType(RemotingServer),
“RemoteObject”, WellKnownObjectMode.Singleton)
Now comes the final section that is third section the client which will connect to this
hosted remoting object.
Following is a detail explanation of client code :-
√ First we create the channel i.e. HTTP. Note whatever channel the server is
using same will be used by the client.
ChannelServices.RegisterChannel(objHttpChannel)
√ As said before the common interface i.e.“InterFaceRemoting” will be used
to communicate with client.
√ After that we can get the server object reference using following code
objRemoting = CType(Activator.GetObject(GetType(InterFaceRemoting.InterFaceRemoting),
“http://localhost:1234/RemoteObject”), InterFaceRemoting.InterFaceRemoting)
√ Then the client can make method call as if the object is local. But actually the
object is a proxy.
Console.WriteLine(“Value on server :- “ & objRemoting.GetValue.ToString())
Imports System
Imports System.Runtime.Remoting
Imports System.Runtime.Remoting.Channels.Http
Imports System.Runtime.Remoting.Channels
Imports InterFaceRemoting
Module ModuleStartClient
Sub Main()
Dim objHttpChannel As New HttpChannel
Dim objRemoting As InterFaceRemoting.InterFaceRemoting
ChannelServices.RegisterChannel(objHttpChannel)
objRemoting =
CType(Activator.GetObject(GetType(InterFaceRemoting.InterFaceRemoting),
“http://localhost:1234/RemoteObject”),
155
InterFaceRemoting.InterFaceRemoting)
Console.WriteLine(“Referenced the main object.... Now
displaying Data”)
Console.WriteLine(“Value on server :- “ &
objRemoting.GetValue.ToString())
Console.WriteLine(“Press enter to Terminate”)
Console.ReadLine()
End Sub
End Module
You an run the program and see the output. For running the program run the server
program which is in server directory. Run “Server.exe” from BIN directory. If the EXE
runs properly following will be the screen as shown below.
Figure :- 4.4 Running Server Program of Remoting
Now run “Client.exe” from client folder in BIN directory.Following will be the output
seen.This means that the client connected to the server program and displayed the data in
the server object. In the server object we have initialized value “testing......”. In constructor
of class “RemotingServer” same value is displayed at the client side as shown in figure
below.
156
Figure :- 4.5 Client Program output of Remoting
(A) What are the situations you will use singleton architecture in
remoting ?
If all remoting clients have to share the same data singleton architecture will be used.
(A) What is fundamental of published or precreated objects in Remoting
?
In scenarios of singleton or single call the objects are created dynamically. But in situations
where you want to precreate object and publish it you will use published object scenarios.
Dim obj as new objRemote
obj.Initvalue = 100
RemotingServices.Marshal(obj,”RemoteObject”)
As shown in above sample following changes will be needed on server side.
RemotingConfiguration.RegisterWellKnownServiceType is replaced by
RemotingServices.Marshal(obj,”RemoteObject”) where “obj” is the precreated objected
on the server whose value is initialized to 100.
(A) What are the ways in which client can create object on server in CAO
model ?
There are two ways by which you can create Client objects on remoting server :-
157
√ Activator.CreateInstance().
√ By Keyword “New”.
(A) Are CAO stateful in nature ?
Yes. In CAO remoting model client creates a instance on server and instance variable set
by client on server can be retrieved again with correct value.
(A) In CAO model when we want client objects to be created by “NEW”
keyword is there any precautions to be taken ?
Remoting Clients and Remoting Server can communicate because they share a common
contract by implementing Shared Interface or Base Class (As seen in previous examples).
But according to OOP’s concept we can not create a object of interface or Base Classes
(Abstract Class). Shipping the server object to client is not a good design practice. In
CAO model we can use SOAPSUDS utility to generate Metadata DLL from server which
can be shipped to client, clients can then use this DLL for creating object on server. Run
the SOAPSUDS utility from visual studio command prompt for syntax see below :-
soapsuds -ia:RemotingServer -nowp -oa:ClientMetaData.dll
Where RemotingServer is your server class name.
ClientMetaData.dll is the DLL name by which you will want to create the metadll.
Server code will change as follows :-
ChannelServices.RegisterChannel(objHttpChannel)
RemotingConfiguration.ApplicationName = “RemoteObject”
RemotingConfiguration.RegisterActivatedServiceType(GetType(InterFaceRemoting.InterFaceRemoting))
Note :- We have to provide applicationname and register the object as ActivatedServiceType.
On client side we have to reference the generated ClientMetaData.dll from SOAPSUDS
utility. Below are changes which are needed to be incorporated at the Remoting Client :-
RemotingConfiguration.RegisterActivatedClientType(typeof(RemoteObject),“http://
localhost:1234/MyServer”)
Dim objRemoteObject as new RemoteObject().
158
RemoteObject is class which is obtained from ClientMetaData.dll which we created using
SOAPSUDS utility. Now you can reference the object as normal object.
(I) Is it a good design practice to distribute the implementation to
Remoting Client ?
It’s never advisable to distribute complete implementation at client, due to following
reasons:-
√ Any one can use ILDASM and decrypt your logic.
√ It’s a bad architecture move to have full implementation as client side as any
changes in implementation on server side you have to redistribute it again.
So the best way is to have a interface or SOAPSUDS generated meta-data DLL at client
side rather than having full implementation.
(A) What are LeaseTime, SponsorshipTime, RenewonCallTime and
LeaseManagerPollTime?
This is a very important question from practical implementation point of view. Companies
who have specific requirement for Remoting projects will expect this question to be answered.
In normal .NET environment objects lifetime is managed by garbage collector. But in
remoting environment remote clients can access objects which are out of control of
garbage collector. Garbage collector boundary is limited to a single PC on which framework
is running; any remote client across physical PC is out of control of GC (Garbage
Collector).
This constraint of garbage collector leads to a new way of handling lifetime for remoting
objects, by using concept called as “LeaseTime”. Every server side object is assigned by
default a “LeaseTime” of five minutes. This leasetime is decreased at certain intervals.
Again for every method call a default of two minutes is assigned. When i say method call
means every call made from client. This is called as “RenewalOnCallTime”.
Let’s put the whole thing in equation to make the concept more clear.
Total Remoting object life time = LeaseTime + (Number of method calls) X
(RenewalTime).
If we take NumberOfMethodCalls as one.
159
Then default Remote Object Life Time = 5 + (1) X 2 = 10 minutes (Everything is in
minutes)
When total object lifetime is reduced to zero, it queries the sponsor that should the object
be destroyed. Sponsor is an object which decides should object Lifetime be renewed. So
it queries any registered sponsors with the object, if does not find any then the object is
marked for garbage collection. After this garbage collection has whole control on the
object lifetime. If we do not foresee how long a object will be needed specify the
“SponsorShipTimeOut” value. SponsorShipTimeOut is time unit a call to a sponsor is
timed out.
“LeaseManagerPollTime” defines the time the sponsor has to return a lease time extension.
(A) Which config file has all the supported channels/protocol ?
Machine.config file has all the supported channels and formatter supported by .NET
remoting.Machine.config file can be found at
“C:\WINDOWS\Microsoft.NET\Framework\vXXXXX\CONFIG” path. Find
element in the Machine.config file which has the channels
and the formatters. Below is a figure shown which can give a clear idea of how the file
looks like.
Note :- Interviewer will not ask you to name all channels and formatters in machine.config
but will definitely like to know in which file are all the formatter and channels specified, one
sweet answer “Machine.config” can fetch you handsome job.
160
Figure :- 4.6 Channels and Formatter in machine.config file
(A) How can you specify remoting parameters using Config files ?
Both remoting server and remoting client parameters can be provided through config
files. Below is a sample of server config file which provides all remoting parameter values
which we where providing through code.




161
mode=”SingleCall”
type=”Server.ClsServer, Server”
objectUri=”RemoteObject” />







Later this config file can be loaded using the following code.
RemotingConfiguration.Configure(AppDomain.CurrentDomain.SetupInformation.ApplicationBase
& “Server.config”)
Same way we also have client.config file for loading the client remoting parameters.




type=”CommonInterface.Icommon, Icommon”
url = “tcp://localhost:9000/Server/RemoteObject”/>







client remoting can then load the configuration file by using :-
Dim IobjCommon As CommonInterFace.Icommon
Dim StrData As String
Dim objServiceEntries As WellKnownClientTypeEntry()
RemotingConfiguration.Configure(AppDomain.CurrentDomain.SetupInformation.ApplicationBase
& “Client.config”)
objServiceEntries =
RemotingConfiguration.GetRegisteredWellKnownClientTypes()
IobjCommon = Activator.GetObject(GetType(Icommon),
objServiceEntries(0).ObjectUrl.ToString())
StrData = IobjCommon.GetValue()
162
Console.WriteLine(“ Serve side Data is “ & StrData)
Console.ReadLine()
Note :- Complete source is provided in CD in folder “RemotingObjectLifeTime”.If you run
Server and Client following output can be seen. All source is compiled using VS2005
BETA1
Figure : - 4.7 Output of Server and Client for RemotingObjectLifeTime project
(A) Can Non-Default constructors be used with Single Call SAO?
Twist :- What are the limitation of constructors for Single call SAO ?
163
Non-Default constructors can not be used with single call objects as object is created
with every method call, there is no way to define Non-default constructors in method
calls.
It’s possible to use Non-Default constructor with Client activated objects as both methods
:-
“NEW” keyword and “Activator.CreateInstance” provide a way to specify Non-Default
constructors.
(I) How can we call methods in remoting Asynchronously ?
All previous examples are a synchronous method calls that means client has to wait until
the method completes the process. By using Delegates we can make Asynchronous method
calls.
(A) What is Asynchronous One-Way Calls ?
One-way calls are a different from asynchronous calls from execution angle that the .NET
Framework does not guarantee their execution. In addition, the methods used in this kind
of call cannot have return values or out parameters. One-way calls are defined by using
[OneWay()] attribute in class.
(B) What is marshalling and what are different kinds of marshalling ?
Marshaling is used when an object is converted so that it can be sent across the network
or across application domains. Unmarshaling creates an object from the marshaled data.
There are two ways to do marshalling :-
√ Marshal-by-value (MBV) :- In this the object is serialized into the channel, and
a copy of the object is created on the other side of the network. The object to
marshal is stored into a stream, and the stream is used to build a copy of the
object on the other side with the unmarshalling sequence.
√ Marshaling-by-reference (MBR):- Here it creates a proxy on the client that is
used to communicate with the remote object. The marshaling sequence of a
remote object creates an ObjRef instance that itself can be serialized across
the network.
Objects that are derived from “MarshalByRefObject” are always marshaled by reference.
All our previous samples have classes inherited from “MarshalByRefObject”
164
To marshal a remote object the static method RemotingServices.Marshal() is
used.RemotingServices.Marshal() has following overloaded versions:-
public static ObjRef Marshal(MarshalByRefObject obj)
public static ObjRef Marshal(MarshalByRefObject obj, string objUri)
public static ObjRef Marshal(MarshalByRefObject obj, string objUri,Type
requestedType)
The first argument obj specifies the object to marshal. The objUri is the path that is
stored within the marshaled object reference; it can be used to access the remote object.
The requestedType can be used to pass a different type of the object to the object reference.
This is useful if the client using the remote object shouldn't use the object class but an
interface that the remote object class implements instead. In this scenario the interface is
the requestedType that should be used for marshaling.
(A) What is ObjRef object in remoting ?
All Marshal() methods return ObjRef object.The ObjRef is serializable because it
implements the interface ISerializable, and can be marshaled by value. The ObjRef knows
about :-
√ location of the remote object
√ host name
√ port number
√ object name.
(B) What is a Web Service ?
Web Services are business logic components which provide functionality via the Internet
using standard protocols such as HTTP.
Web Services uses Simple Object Access Protocol (SOAP) in order to expose the business
functionality.SOAP defines a standardized format in XML which can be exchanged
between two entities over standard protocols such as HTTP. SOAP is platform independent
so the consumer of a Web Service is therefore completely shielded from any
implementation details about the platform exposing the Web Service. For the consumer it
is simply a black box of send and receive XML over HTTP. So any web service hosted on
windows can also be consumed by UNIX and LINUX platform.
165
(B) What is UDDI ?
Full form of UDDI is Universal Description, Discovery and Integration. It is a directory
that can be used to publish and discover public Web Services. If you want to see more
details you can visit the http://www.UDDI.org .
(B) What is DISCO ?
DISCO is the abbreviated form of Discovery. It is basically used to club or group common
services together on a server and provides links to the schema documents of the services
it describes may require.
(B) What is WSDL?
Web Service Description Language (WSDL)is a W3C specification which defines XML
grammar for describing Web Services.XML grammar describes details such as:-
√ Where we can find the Web Service (its URI)?
√ What are the methods and properties that service supports?
√ Data type support.
√ Supported protocols
In short its a bible of what the webservice can do.Clients can consume this WSDL and
build proxy objects that clients use to communicate with the Web Services. Full WSDL
specification is available at http://www.w3.org/TR/wsdl.
(A) What the different phase/steps of acquiring a proxy object in
Webservice ?
Following are the different steps needed to get a proxy object of a webservice at
the client side :-
√ Client communicates to UDI node for WebService either through browser or
UDDI's public web service.
√ UDII responds with a list of webservice.
166
√ Every service listed by webservice has a URI pointing to DISCO or WSDL
document.
√ After parsing the DISCO document, we follow the URI for the WSDL document
related to the webservice which we need.
√ Client then parses the WSDL document and builds a proxy object which can
communicate with Webservice.
(B) What is file extension of Webservices ?
.ASMX is extension for Webservices.
Note :- After this we are going to deal with a sample of webservice. In VS2005 webproject
is created from the menu itself as compared to 2003 where it was present in the explorer.
167
Figure :- 4.8 Create Web project menu in VS2005
(B)Which attribute is used in order that the method can be used as
WebService ?
WebMethod attribute has to be specified in order that the method and property can be
treated as WebService.
(A) What are the steps to create a webservice and consume it ?
Note :- For this question this book will make a attempt by creating a simple webservice and
explaining steps to acheive it. A simple webservice will be created which takes two number
and gives addition result of the two number. In CD sample webservice project with folder
name “MathsWebService” is provided and same will be explained below. Definitely the
168
interviewer will not expect such a detail answer but this book will explain you in detail so
that you are on right track during interview.
This webservice will add two numbers and give to the calling client.All the below steps
are according to VS2005 beta editor :-
√ First create a website by clicking on File -- New WebSite.
√ From “Visual Studio Installed Templates” click on “Asp.NET Web Service”.
See figure below. Name the figure as “Maths Web Service”.
169
Figure :- 4.9 Create WebService Project
√ By default the .NET editor has made a default webservice method called as
"HelloWord" which returns a string datatype. Let's rename "Service.vb" to
"Maths.vb" and "Service.asmx" to "Maths.asmx". Let’s replace the
“HelloWorld” with following code below :-
_
Public Function AddTwoNumbers(ByVal Number1 As Integer, ByVal
Number2 As Integer) As Integer
Return Number1 + Number2
170
End Function
Figure :- 4.10 Rename all your default “Service” to “Maths”
√ After the webservice is done click on add Webreference. Normally for
components we do a “Add Reference” and for Webservices we do “Add Web
Reference”.
171
Figure :- 4.11 Click on Add Web Reference
√ You will be shown with a list of webservices which are known to the
solutions. As we are looking for our “Maths” webservice which exist in the
172
same solution, we click “Webservices in this solution”.
Figure :- 4.12 List of webservices for browsing
√ Your editor has located the “Maths” webservice.Select the webservice.
173
Figure :- 4.13 Solution showing the availability of Maths Webservice.
174
√ After you have clicked on “Maths” webservice you will see a search progress
bar as shown in figure below. This process will start the webservice, reference it
and create a proxy for the client, so that using it client can absorb the
webservice.
Figure :- 4.14 Starting the webservice and creating the proxy for your solution.
175
√ Finally you are able to see your webservice which is ready for use. Click on
Add Reference and you will see a “Localhost” reference in your .NET solution.
Figure :- 4.15 Starting the webservice and creating the proxy for your solution.
√ We need to make a client who will absorb this “Maths Webservice”. Add
“WebserviceClient.aspx” and create a UI as shown below. In the button click
put in the following code. “LocalHost.ClsMaths” is the proxy object by which
you can make calls to the webservice.
Sub cmdCalculate_Click(ByVal sender As Object, ByVal e As
176
System.EventArgs)
Dim pobjMaths As New localhost.ClsMaths
lblResultDisplay.Text =
Convert.ToString(pobjMaths.AddTwoNumbers(Convert.ToInt16(txtNumber1.Text),
Convert.ToInt16(txtNumber2.Text)))
End Sub
Figure :- 4.16 Complete Webservice in action.
Note :- The whole point of creating this “Maths Webservice” step by step was to have a
understanding of practical angle of how webservices are created. It’s very rare that you will
be asked to explain every step of how to write a webservice. But in case your interviewer is
too bend down to also know what are the actual steps in creating a Webservice.
(A) Do webservice have state ?
Twist :- How can we maintain State in Webservices ?
177
Webservices as such do not have any mechanism by which they can maintain state.
Webservices can access ASP.NET intrinsic objects like Session, application and so on if
they inherit from “WebService” base class.
<%@ Webservice class="TestWebServiceClass" %>
Imports System.Web.Services
Public class TestWebServiceClass
Inherits WebService
Public Sub SetSession(value As String)
session("Val") = Value
End Sub
end class
Above is a sample code which sets as session object called as “val”. TestWebserviceClass
is inheriting from WebService to access the session and application objects.

DOTNET FAQ-4

3. Threading

(B)What is Multi-tasking ?
It’s a feature of modern operating systems with which we can run multiple programs at
same time example Word, Excel etc.
(B)What is Multi-threading ?
Multi-threading forms subset of Multi-tasking. Instead of having to switch between
programs this feature switches between different parts of the same program. Example
you are writing in word and at the same time word is doing a spell check in background.
(B)What is a Thread ?
A thread is the basic unit to which the operating system allocates processor time.
(B)Did VB6 support multi-threading ?
While VB6 supports multiple single-threaded apartments, it does not support a freethreading
model, which allows multiple threads to run against the same set of data.
(B)Can we have multiple threads in one App domain ?
One or more threads run in an AppDomain. An AppDomain is a runtime representation
of a logical process within a physical process. Each AppDomain is started with a single
thread, but can create additional threads from any of its threads.
Note :- All threading classes are defined in System.Threading namespace.
(B)Which namespace has threading ?
Systems.Threading has all the classes related to implement threading. Any .NET application
who wants to implement threading has to import this namespace.
Note :- .NET program always has at least two threads running one is the main program
and second is the garbage collector.
(I)Can you explain in brief how can we implement threading ?
3. Threading
143
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
Dim pthread1 As New Thread(AddressOf Thread1)
Dim pthread2 As New Thread(AddressOf Thread2)
pthread1.Start()
pthread2.Start()
End Sub
Public Sub Thread1()
Dim pintcount As Integer
Dim pstr As String
pstr = “This is first thread”
Do Until pintcount > 5
lstThreadDisplay.Items.Add(pstr)
pintcount = pintcount + 1
Loop
End Sub
Public Sub Thread2()
Dim pintcount As Integer
Dim pstr As String
pstr = “This is second thread”
Do Until pintcount > 5
lstThreadDisplay.Items.Add(pstr)
pintcount = pintcount + 1
Loop
End Sub
Above is a sample code which shows simple sample code for threading. Above sample
code can be found in “Threading” folder in CD provided. Above sample has two methods
“Thread1()” and “Thread2()” which are started in multi-threaded mode in Form load
event of the sample.
Note :- If you run the sample you will see that sometimes the first thread runs first and
then the second thread.This happens because of thread priorities . The first thread is run
with highest priority.
(A)How can we change priority and what the levels of priority are
provided by .NET ?
144
Thread Priority can be changed by using Threadname.Priority = ThreadPriority.Highest.
In the sample provided look out for code where the second thread is ran with a high
priority.
Following are different levels of Priority provided by .NET :-
√ ThreadPriority.Highest
√ ThreadPriority.AboveNormal
√ ThreadPriority.Normal
√ ThreadPriority.BelowNormal
√ ThreadPriority.Lowest
(A)What does AddressOf operator do in background ?
The AddressOf operator creates a delegate object to the BackgroundProcess method. A
delegate within VB.NET is a type-safe, object-oriented function pointer. After the thread
has been instantiated, you begin the execution of the code by calling the Start() method
of the thread
(A)How can you reference current thread of the method ?
"Thread.CurrentThread" refers to the current thread running in the
method."CurrentThread" is a public static property.
(I) What's Thread.Sleep() in threading ?
Thread's execution can be paused by calling the Thread.Sleep method. This method takes
an integer value that determines how long the thread should sleep. Example
Thread.CurrentThread.Sleep(2000).
(A)How can we make a thread sleep for infinite period ?
You can also place a thread into the sleep state for an indeterminate amount of time by
calling Thread.Sleep (System.Threading.Timeout.Infinite). To interrupt this sleep you can
call the Thread.Interrupt method.
(A) What is Suspend and Resume in Threading ?
145
It is Similar to Sleep and Interrupt. Suspend allows you to block a thread until another
thread calls Thread.Resume. The difference between Sleep and Suspend is that the latter
does not immediately place a thread in the wait state. The thread does not suspend until
the .NET runtime determines that it is in a safe place to suspend it. Sleep will immediately
place a thread in a wait state.
Note :- In threading interviews most people get confused with Sleep and Suspend. They look
very similar.
(A)What the way to stop a long running thread ?
Thread.Abort() stops the thread execution at that moment itself.
(A) How do I debug thread ?
Figure :- 3.1 Debug thread window
This window is only seen when the program is running in debug mode. In windows one of
the window is “Threads”.
146
(A)What is Thread.Join() in threading ?
There are two versions of Thread.Join :-
√ Thread.join().
√ Thread.join(Integer) this returns a Boolean value.
The Thread.Join method is useful for determining if a thread has completed before starting
another task. The Join method waits a specified amount of time for a thread to end. If the
thread ends before the time-out, Join returns true; otherwise it returns False. Once you
call Join, the calling procedure stops and waits for the thread to signal that it is done.
Example you have "Thread1" and "Thread2" and while executing 'Thread1" you call
"Thread2.Join()".So "Thread1" will wait until "Thread2" has completed its execution
and the again invoke "Thread1".
Thread.Join(Integer) ensures that threads do not wait for a long time. If it exceeds a
specific time which is provided in integer the waiting thread will start.
(A)What are Daemon threads and how can a thread be created as
Daemon?
Daemon thread's run in background and stop automatically when nothing is running
program. Example of a Daemon thread is "Garbage collector". Garbage collector runs
until some .NET code is running or else its idle.
You can make a thread Daemon by
Thread.Isbackground=true
(A) When working with shared data in threading how do you implement
synchronization ?
There are certain somethings that you need to be careful with when using threads. If two
threads (e.g. the main and any worker threads) try to access the same variable at the same
time, you'll have a problem. This can be very difficult to debug because they may not
always do it at exactly the same time. To avoid the problem, you can lock a variable
147
before accessing it. However, if the two threads lock the same variable at the same time,
you'll have a deadlock problem.
SyncLock x
'Do something with x
End SyncLock
(I)Can we use events with threading ?
Yes, you can use events with thread; this is one of the techniques to synchronize one
thread with other.
(A)How can we know a state of a thread?
"ThreadState" property can be used to get detail of a thread. Thread can have one or a
combination of status.System.Threading. Threadstate enumeration has all the values to
detect a state of thread. Some sample states are Isrunning, IsAlive, suspended etc.
(A) What is use of Interlocked class ?
Interlocked class provides methods by which you can achieve following functionalities :-
√ Increment Values.
√ Decrement values.
√ Exchange values between variables.
√ Compare values from any thread.
in a synchronization mode.
Example :- System.Threading.Interlocked.Increment(IntA)
(A) What is a monitor object?
Monitor objects are used to ensure that a block of code runs without being interrupted by
code running on other threads. In other words, code in other threads cannot run until
code in the synchronized code block has finished.
SyncLock and End SyncLock statements are provided in order to simplify access to monitor
object.
148
(A) What are wait handles ?
Twist :- What is a mutex object ?
Wait handles sends signals of a thread status from one thread to other thread. There are
three kind of wait modes :-
√ WaitOne.
√ WaitAny.
√ WaitAll.
When a thread wants to release a Wait handle it can call Set method. You can use Mutex
(mutually exclusive) objects to avail for the following modes. Mutex objects are
synchronization objects that can only be owned by a single thread at a time. Threads
request ownership of the mutex object when they require exclusive access to a resource.
Because only one thread can own a mutex object at any time, other threads must wait for
ownership of a mutex object before using the resource.
The WaitOne method causes a calling thread to wait for ownership of a mutex object. If
a thread terminates normally while owning a mutex object, the state of the mutex object
is set to be signaled and the next waiting thread gets ownership
(A) What is ManualResetEvent and AutoResetEvent ?
Threads that call one of the wait methods of a synchronization event must wait until
another thread signals the event by calling the Set method. There are two synchronization
event classes. Threads set the status of ManualResetEvent instances to signaled using
the Set method. Threads set the status of ManualResetEvent instances to no signaled
using the Reset method or when control returns to a waiting WaitOne call. Instances of
the AutoResetEvent class can also be set to signaled using Set, but they automatically
return to nonsignaled as soon as a waiting thread is notified that the event became signaled.
(A) What is ReaderWriter Locks ?
You may want to lock a resource only when data is being written and permit multiple
clients to simultaneously read data when data is not being updated. The ReaderWriterLock
class enforces exclusive access to a resource while a thread is modifying the resource, but
it allows nonexclusive access when reading the resource. ReaderWriter locks are a useful
alternative to exclusive locks that cause other threads to wait, even when those threads
do not need to update data.
(I) How can you avoid deadlock in threading?
A good and careful planning can avoid deadlocks.There are so many ways Microsoft has
provided by which you can reduce deadlocks example Monitor, Interlocked classes, Wait
handles, Event raising from one thread to other thread, ThreadState property which you
can poll and act accordingly etc.
(B) What is the difference between thread and process?
A thread is a path of execution that run on CPU, a process is a collection of threads that
share the same virtual memory. A process has at least one thread of execution, and a
thread always run in a process context.
Note:- Its difficult to cover threading interview question in this small chapter. These
questions can take only to a basic level. If you are attending interviews where people are
looking for threading specialist, try to get deeper in to synchronization issues as that's the
important point they will stress.

DOTNET FAQ-3

2..NET Interoperability

(I) How can we use COM Components in .NET?
Twist : What is RCW ?
.NET components communicate with COM using RCW (Runtime Callable Wrapper). Following
are the ways with which you can generate RCW :-
√ Adding reference in Visual Studio.net. See figure below (Adding reference using VS.NET
2005). Wrapper class is generated and placed in the “BIN” directory.
Figure :- 2.1 Adding Reference using VS.NET 2005
2..NET Interoperability
129
√ Using Type library import tool. Tlbimp.exe yourname.dll.
√ Using interopservices.System.runtime.Interopservices namespace contains class
TypeLib Converter which provides methods to convert COM classes and interface in
to assembly metadata.
√ Make your custom wrappe rs.If your COM component does not have type library
then the only way to communicate is writing custom wrappers. That means
communicating directly with COM components.
(I) Once I have developed the COM wrapper do I have to still register the
COM in registry?
Yes.
(A)How can we use .NET components in COM?
Twist :- What is CCW (COM callable wrapper) ?, What caution needs to be taken in
order that .NET components is compatible with COM ?
.NET components can not be used in straight forward way with COM. You will need to create
CCW in order that COM components communicate with .NET assemblies. Following are the
different approaches to implement it :-
√ Explicitly declare interfaces..
Public Interface ICustomer
Property CustomerName() As String
Property CustomerCode() As String
Sub AddCustomer()
End Interface
Public Class Customer
Implements ICustomer
Private PstrCustomerName As String
Private PstrCustomerCode As String
Public Sub AddCustomer() Implements ICustomer.AddCustomer
Try
‘ addin of database code can go here
Catch ex As Exception
Throw ex
End Try
130
End Sub
Public Property CustomerCode() As String Implements
ICustomer.CustomerCode
Get
Return PstrCustomerCode
End Get
Set(ByVal value As String)
PstrCustomerCode = value
End Set
End Property
Public Property CustomerName() As String Implements
ICustomer.CustomerName
Get
Return PstrCustomerName
End Get
Set(ByVal value As String)
PstrCustomerName = value
End Set
End Property
Public Sub New()
End Sub
End Class
Note :- Source code of this is provided in CD in SOURCECODE folder in
COMCALLABLEWRAPPER
The above customer class is going to be used by COM components so all the properties and
methods are declared in interface and implemented in the customer class. Customer Name.Customer
Code and AddCustomer are first declared in ICustomer and then implemented in Customer
Class. Also note that the class must have a default constructor.
Note :- All source code in this book is provided in VB.NET that does not mean that
author of the book does not like C#. In fact the main programming language of author is
C#. In order to keep things small I have only used one language. But the conversion is so
seamless that it is of least matter.
131
√ The second way to create CCW is by using InteropServices attributes. Here interfaces
are created automatically.
Following are different type of class attributes :
None:-No class interface is generated for the class. This is default setting when you do not specify
anything.
AutoDispatch :- Interface that supports IDispatch is created for the class. However, no type
information is produced.
AutoDual :- A dual interface is created for the class. Type information is produced and made
available in the type library.
Below in the source code we have used the third attribute.
Imports System.Runtime.InteropServices
_
Public Class ClsCompliant
End Class
Other than class attributes defined up there are other attributes with which you can govern other
part of assembly.Example “GuidAttribute” allows you to specify the GUID,
“ComVisibleAttribute” can be used to hide .NET types from COM etc. All attributes are not in
scope of the book as this is a interview questions book refer MSDN for more details.
√ Once .NET assembly is created using either interface or using interopservices method
we need to create a COM type library using Type library export tool.
Tlbexp (AssemblyName)
√ The final thing is registering the CCW in registry using regasm tool.
regasm AssemblyName [Options]
√ Finally refer the TLB in your COM IDE Below is figure showing VB6 IDE referencing
the DLL
Note :- DLL and TLB should be in same directory where the application is executed.
132
Figure :- 2.2 VB6 IDE referencing the CCW
(A)How can we make Windows API calls in .NET?
Windows API call are not COM based and they are invoked through Platform Invoke Services.
Declare StringConversionType (Function | Sub) MethodName Lib "DllName" ([Args])
As Type
√ StringConversionType is for what type of conversion should take place. Either we
can specify Unicode to convert all strings to Unicode values, or Auto to convert
strings according to the .NET runtime rules.
√ MethodName is the name of the API to call.
√ DllName is the name of the DLL.
√ Args are any arguments to the API call.
133
√ Type is the return type of the API call.
Below is a sample code for VB.NET which uses Sleep windows API for delaying.
Public Class Form1
Declare Auto Sub Sleep Lib “kernel32.dll” (ByVal dwMilliseconds
As Long)
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
MessageBox.Show(“ start sleeping for 5000 Milli
seconds.....”)
Sleep(5000)
MessageBox.Show(“ end of sleeping.....”)
End Sub
End Class
Note:- Source code is provided in CD in “APICALL” folder
In VB.NET we use declare keyword but in C# it goes little bit different, we use DLLIMPORT
here.
Note :- We have interopservices in this and EXTERN keyword.
#region Using directives
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Windows.Forms;
using System.Runtime.InteropServices;
#endregion
namespace CSharpCode
{
partial class Form1 : Form
{
[DllImport(“Kernel32.dll”)]
static extern int Sleep(long dwMilliseconds);
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
134
{
MessageBox.Show(“Starting of 5000 ms...”);
Sleep(5000);
MessageBox.Show(“End of 5000 ms...”);
}
}
}
(B)When we use windows API in .NET is it managed or unmanaged code
?
Windows API in .NET is unmanaged code.
Note:- Even though VB6 and V C++ has gone off still many people do ask these old
questions again and again. Still there are decent old application which are working with
COM very much fine. So interviewer still asks you these questions so that those
application’s can be ported to .NET. So let’s play some old music... By the way my
favourite music is Kishore, what’s yours???
(I)What is COM ?
Microsoft’s COM is a technology for component software development. It is a binary standard
which is language independent. DCOM is a distributed extension of COM.
(A) What is Reference counting in COM ?
Reference counting is a memory management technique used to count how many times an object
has a pointer referring to it. The first time it is created, the reference count is set to one. When the
last reference to the object is nulled, the reference count is set to zero and the object is deleted.
Care must be exercised to prevent a context switch from changing the reference count at the time
of deletion. In the methods that follow, the syntax is shortened to keep the scope of the discussion
brief and manageable.
(A) Can you describe IUKNOWN interface in short ?
Every COM object supports at least one interface, the IUnknown interface. All interfaces are
classes derived from the base class IUnknown. Each interface supports methods access data and
perform operations transparently to the programmer. For example, IUnknown supports three
methods, AddRef, Release(), and QueryInterface(). Suppose that pinterf is a pointer to an IUnknown.
pinterf->AddRef() increments the reference count. pinterf->Release() decrements the reference
count, deleting the object when the reference count reaches zero. pinterf->QueryInterface( IDesired,
135
pDesired) checks to see if the current interface (IUnknown) supports another interface, IDesired,
creates an instance (via a call to CoCreateInstance()) of the object if the reference count is zero (the
object does not yet exist), and then calls pDesired->AddRef() to increment the reference count
(where pDesired is a pointer to IDesired) and returns the pointer to the caller.
(I)Can you explain what is DCOM ?
DCOM differs from COM in that it allows for creating objects distributed across a network, a
protocol for invoking that object’s methods, and secures access to the object. DCOM provides a
wrapper around COM, hence it is a backwards compatible extension. DCOM uses Remote
Procedural Calls (RPC) using Open Software Foundation’s Distributed Computing Environment.
These RPC are implemented over TCP/IP and named pipes. The protocol which is actually being
used is registered just prior to use, as opposed to being registered at initialization time. The reason
for this is that if a protocol is not being used, it will not be loaded.
In order to inform an object that the client is still alive, periodic pinging is used. Hence, when the
client has died and no ping has been received (to refresh it) before the expiration time, the server
object will perform some clean up tasks (including decrementing its reference count).
Since RPC across a network are typically slow (compared to processes residing on the same
machine), DCOM sends multiple requests in the same call. For example, in COM, the program
performs a QueryInterface, one interface at a time. In DCOM, multiple QueryInterfaces are all
clustered into one call.
This clustering optimization trick is also used when creating an instance of the object and serializing
it with data. Since these two operations usually occur together, DCOM allows one method which
will perform both operations in one call without waiting for an acknowledgment from the first
task before performing the second one.
Similarly, when a client pings its server object, he can do it in one call. Moreover, if there are
multiple clients sending pings to multiple servers, an optimization is made where the multiple
pings going to the same object are consolidated into just one ping. This is to cut down on the use
of precious bandwidth used only for pinging.
The client has the control to set the computer which will be responsible for the lifetime of the
object. That is to say, these objects are not created just somewhere where the system resources and
access privileges allow for it.
Call security is implemented in all four ways: authentication (to prevent false clients from
impersonating the true client), authorization (to insure that a client only does what it is authorized
to do), data integrity (to insure that data was not tampered with during transit) and data privacy (to
insure that only designated sources can read it). The security issues are handled as they are on
136
operating systems. The client gives the server various access privileges to access memory or disk
space
(B)How do we create DCOM object in VB6?
Using the CreateObject method you can create a DCOM object. You have to put the server
name in the registry.
(A)How to implement DTC in .NET ?
DTC is implemented using COM+.
Following are the steps to implement COM + in .NET :-
√ “EnterpriseService” namespace has all the classes by which we can implement DTC
in .NET. You have to add reference “EnterpriseService” namespace.
137
Figure :- 2.3 Add reference to EnterpriseServices.
√ You class must derive from “Serviced Component” object.
√ Then you have to define your class with the transaction attribute
(For all transaction attribute look the down question)
[ Transaction(TransactionOption.RequiresNew) ]
√ After the class level transaction type is defined. Its time to define at the method level
the AutoComplete attribute. Autocomplete attribute says that if no exception is thrown
then mark its part of the transaction as being okay. This helps cut down on the
amount of code required. If the implementation sets AutoComplete to false, or
138
omits it all together, then we would need to manage the transaction manually. To
manually control the transaction you will need to use the ContextUtil class and its static
members. Following is small snippet of ContextUtil: -
public void SampleFunction()
{
try
{
// Do something to a database
// ...
// Everything okay so far Commit the transaction
ContextUtil.SetComplete();
}
catch(Exception)
{
// Something went wrong Abort and Rollback the Transaction.
ContextUtil.SetAbort();
}
}
√ Component derived from “ServicedComponent” should be strong named as they
run under COM+.
√ Once the classes are compiled using the string name.Register the Component in COM+
services using
regsvcs c:\DllPath\TransactionComponent.dll
√ You can see that the component is registered using the COM+ explorer.
(A)How many types of Transactions are there in COM + .NET ?
139
There are 5 transactions types that can be used with COM+. Whenever an object is registered with
COM+ it has to abide either to these 5 transaction types.
Disabled: - There is no transaction. COM+ does not provide transaction support for this
component.
Not Supported: - Component does not support transactions. Hence even if the calling component
in the hierarchy is transaction enabled this component will not participate in the transaction.
Supported: - Components with transaction type support will be a part of the transaction. This will
be only if the calling component has an active transaction. If the calling component is not transaction
enabled this component will not start a new transaction.
Required: - Components with this attribute require a transaction i.e. either the calling should have
a transaction in place else this component will start a new transaction.
Required New: - Components enabled with this transaction type always require a new transaction.
Components with required new transaction type instantiate a new transaction for themselves every
time.
(A)How do you do object pooling in .NET ?
COM+ reduces overhead by creating object from scratch. So in COM+ when object is activated
its activated from pool and when its deactivated it’s pushed back to the pool. Object pooling is
configures by using the “ObjectPoolingAttribute” to the class.
Note:- When a class is marked with objectpooling attribute it can not be inherited.
ObjectPooling(MinPoolSize := 2, MaxPoolSize := 5, CreationTimeout := 20000)> _
Public Class testingclass
Inherits ServicedComponent
Public Sub DoWork()
' Method contents go here.
End Sub
End Class
Above is a sample code which has the “ObjectPooling” attribute defined. Below is a sample code
which uses the class.
140
Public Class App
Overloads Public Shared Sub Main(args() As String)
Dim xyz As New TestObjectPooling()
xyz.doWork()
ServicedComponent.DisposeObject (xyz)
End Sub
End Class
Above is a sample code which uses the object pooled object. Note the DisposeObject() This
ensures its safe return to the object pool.
(A)What are types of compatibility in VB6?
There are three possible project compatibility settings:
√ No Compatibility
√ Project Compatibility
√ Binary Compatibility
No Compatibility
With this setting, new class ID’s, new interface ID’s and a new type library ID will be generated by
VB each time the ActiveX component project is compiled. This will cause any compiled client
components to fail (with error 429!) and report a missing reference to the 'VB ActiveX Test
Component' when a client project is loaded in the VB IDE.
Note :- Use this setting to compile the initial release of a component to other developers.
Project Compatibility
With this setting, VB will generate new interface ID’s for classes whose interfaces have changed,
but will not change the class ID’s or the type library ID. This will still cause any compiled client
components to fail (with error 429!) but will not report a missing reference to the 'VB ActiveX
Test Component' when a client project is loaded in the VB IDE. Recompilation of client
components will restore them to working order again.
Note:- Use this setting during the initial development and testing of a component within
the IDE and before the component is released to other developers.
141
Binary Compatibility
VB makes it possible to extend an existing class or interface by adding new methods and properties
etc. and yet still retain binary compatibility. It can do this, because it silently creates a new interface
ID for the extended interface and adds registration code to register the original interface ID but
with a new Forward key containing the value of this new interface ID. COM will then substitute
calls having the old ID with the new ID and hence applications built against the old interface will
continue to work (assuming the inner workings of the component remain backward compatible!).
With this setting, VB will not change any of the existing class, interface or type library ID’s, however
in order that it can do so, VB requires the project to specify an existing compiled version that it can
compare against to ensure that existing interfaces have not been broken
(A)What is equivalent for regsvr32 exe in .NET ?
Regasm

DOTNET FAQ-2

1. Basic .NET Framework

(B)What is a IL?
Twist :- What is MSIL or CIL , What is JIT?
(IL)Intermediate Language is also known as MSIL (Microsoft Intermediate Language) or CIL
(Common Intermediate Language). All .NET source code is compiled to IL. This IL is then
converted to machine code at the point where the software is installed, or at run-time by a Just-In-
Time (JIT) compiler.
(B)What is a CLR?
Full form of CLR is Common Language Runtime and it forms the heart of the .NET framework.
All Languages have runtime and its the responsibility of the runtime to take care of the code
execution of the program. For example VC++ has MSCRT40.DLL,VB6 has MSVBVM60.DLL,
Java has Java Virtual Machine etc. Similarly .NET has CLR. Following are the responsibilities of
CLR
√ Garbage Collection :- CLR automatically manages memory thus eliminating
memory leaks. When objects are not referred GC automatically releases those
memories thus providing efficient memory management.
√ Code Access Security :- CAS grants rights to program depending on the security
configuration of the machine. Example the program has rights to edit or create
a new file but the security configuration of machine does not allow the program
to delete a file. CAS will take care that the code runs under the environment of
machines security configuration.
√ Code Verification :- This ensures proper code execution and type safety while
the code runs. It prevents the source code to perform illegal operation such as
accessing invalid memory locations etc.
√ IL( Intermediate language )-to-native translators and optimizer’s :- CLR uses
JIT and compiles the IL code to machine code and then executes. CLR also
determines depending on platform what is optimized way of running the IL
code.
(B)What is a CTS?
In order that two language communicate smoothly CLR has CTS (Common Type System).Example
in VB you have “Integer” and in C++ you have “long” these datatypes are not compatible so the
interfacing between them is very complicated. In order to able that two different languages can
1. Basic .NET Framework
99
communicate Microsoft introduced Common Type System. So “Integer” datatype in VB6 and
“int” datatype in C++ will convert it to System.int32 which is datatype of CTS. CLS which is
covered in the coming question is subset of CTS.
Note: If you have undergone COM programming period interfacing VB6 application with
VC++ application was a real pain as the datatype of both languages did not have a
common ground where they can come and interface, by having CTS interfacing is smooth.
(B)What is a CLS(Common Language Specification)?
This is a subset of the CTS which all .NET languages are expected to support. It was always a
dream of Microsoft to unite all different languages in to one umbrella and CLS is one step
towards that. Microsoft has defined CLS which are nothing but guidelines that language to follow
so that it can communicate with other .NET languages in a seamless manner.
(B)What is a Managed Code?
Managed code runs inside the environment of CLR i.e. .NET runtime. In short all IL are managed
code. But if you are using some third party software example VB6 or VC++ component they are
unmanaged code as .NET runtime (CLR) does not have control over the source code execution
of the language.
(B)What is a 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 the
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.
100
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.
(A) What are the different types of Assembly?
There are two types of assembly Private and Public assembly. A private assembly is normally used
by a single application, and is stored in the application's directory, or a sub-directory beneath. A
shared assembly is normally stored in the global assembly cache, which is a repository of assemblies
maintained by the .NET runtime. Shared assemblies are usually libraries of code which many
applications will find useful, e.g. Crystal report classes which will be used by all application for
Reports.
(B) What is NameSpace?
Namespace has two basic functionality :-
√ NameSpace Logically group types, example System.Web.UI logically groups
our UI related features.
√ In Object Oriented world many times its possible that programmers will use the
same class name.By qualifying NameSpace with classname this collision is able to
be removed.
(B) What is Difference between NameSpace and Assembly?
Following are the differences between namespace and assembly :
√ Assembly is physical grouping of logical units. Namespace logically groups
classes.
√ Namespace can span multiple assembly.
(A)If you want to view a Assembly how do you go about it ?
Twist : What is ILDASM ?
When it comes to understanding of internals nothing can beat ILDASM. ILDASM basically converts
the whole exe or dll in to IL code. To run ILDASM you have to go to "C:\Program Files\Microsoft
101
Visual Studio .NET 2003\SDK\v1.1\Bin". Note that i had v1.1 you have to probably change it
depending on the type of framework version you have.
If you run IDASM.EXE from the path you will be popped with the IDASM exe program as
shown in figure ILDASM. Click on file and browse to the respective directory for the DLL
whose assembly you want to view. After you select the DLL you will be popped with a tree view
details of the DLL as shown in figure ILDASM. On double clicking on manifest you will be able
to view details of assembly, internal IL code etc as shown in Figure Manifest View.
Note : The version number are in the manifest itself which is defined with the DLL or
EXE thus making deployment much easier as compared to COM where the information
was stored in registry. Note the version information in Figure Manifest view.
You can expand the tree for detail information regarding the DLL like methods etc.
Figure:- 1.1 ILDASM
102
Figure :- 1.2 Manifest View
(A) What is Manifest?
Assembly metadata is stored in Manifest. Manifest contains all the metadata needed to do the
following things (See Figure Manifest View for more details):
√ 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.
103
(B)Where is version information stored of an assembly ?
Version information is stored in assembly in manifest.
(I)Is versioning applicable to private assemblies?
Versioning concept is only applicable to global assembly cache (GAC) as private assembly lie in
their individual folders.
(B) What is GAC ?
Twist :- What are situations when you register .NET assembly in GAC ?
GAC (Global Assembly Cache) is used where shared .NET assembly reside. GAC is used in the
following situations :-
√ If the application has to be shared among several application.
√ If the assembly has some special security requirements like only administrators
can remove the assembly. If the assembly is private then a simple delete of
assembly the assembly file will remove the assembly.
Note :- Registering .NET assembly in GAC can lead to the old problem of DLL hell,
where COM version was stored in central registry. So GAC should be used when absolutely
necessary.
(I) What is the concept of strong names ?
Twist :- How do we generate strong names or what is the process of generating strong
names, What is use the of SN.EXE , How do we apply strong names to assembly, How
do you sign an assembly?
Strong name is similar to GUID(It is supposed to be unique in space and time) in COM
components.Strong Name is only needed when we need to deploy assembly in GAC. Strong
Names helps GAC to differentiate between two versions. Strong names use public key cryptography
(PKC) to ensure that no one can spoof it.PKC use public key and private key concept.
Following are the step to generate a strong name and sign a assembly :-
104
√ Go to “Visual Studio Command Prompt”. See below figure “Visual studio
Command Prompt”. Note the samples are compiled in 2005 but 2003 users do
not have to worry about it. Same type of command prompt will be seen in
2003 also.
Figure :- 1.3 Visual Studio Command Prompt
√ After you are in command prompt type sn.exe -k “c:\test.snk”.
Figure :- 1.4 Running SN.EXE
Figure :- 1.5 Successful output of SN.EXE
105
Figure :- 1.6 Sample view of test.snk file
√ After generation of the file you can view the SNK file in a simple notepad.
√ After the SNK file is generated its time to sign the project with this SNK file.
106
Figure:- 1.7 Click on project and then click on “classlibrary1 properties” menu to sign the assembly
√ Click on project -- properties and the browse the SNK file to the respective
folder and compile the project.
107
Figure :- 1.8 Click on Use a key file to sign the assembly with strong name
(I)How to add and remove an assembly from GAC?
There are two ways to install .NET assembly in GAC:-
√ Using Microsoft Installer Package. You can get download of installer from
http://www.microsoft.com.
√ Using Gacutil. Goto “Visual Studio Command Prompt” and type “gacutil –i
(assembly_name)”, where (assembly_name) is the DLL name of the project.
108
(B) What is Delay signing ?
During development process you will need strong name keys to be exposed to developer which
is not a good practice from security aspect point of view.In such situations you can assign the key
later on and during development you an use delay signing
Following is process to delay sign an assembly:
√ First obtain your string name keys using SN.EXE.
√ Annotate the source code for the assembly with two custom attributes from
System.Reflection: AssemblyKeyFileAttribute, which passes the name of the file
containing the public key as a parameter to its constructor. AssemblyDelaySignAttribute,
which indicates that delay signing, is being used by passing true as a parameter to its
constructor. For example as shown below:
[Visual Basic]


[C#]
[assembly:AssemblyKeyFileAttribute("myKey.snk")]
[assembly:AssemblyDelaySignAttribute(true)]
The compiler inserts the public key into the assembly manifest and reserves space in the PE file for
the full strong name signature. The real public key must be stored while the assembly is built so
that other assemblies that reference this assembly can obtain the key to store in their own assembly
reference.
√ Because the assembly does not have a valid strong name signature, the verification of
that signature must be turned off. You can do this by using the –Vr option with the
Strong Name tool.The following example turns off verification for an assembly called
myAssembly.dll.
Sn –Vr myAssembly.dll
109
√ Just before shipping, you submit the assembly to your organization's signing authority
for the actual strong name signing using the –R option with the Strong Name tool.
The following example signs an assembly called myAssembly.dll with a strong name
using the sgKey.snk key pair.
Sn -R myAssembly.dll sgKey.snk
(B)What is garbage collection?
Garbage collection is a CLR feature which automatically manages memory. Programmers forget
to release the objects while coding ..... Laziness (Remember in VB6 where one of the good
practices is to set object to nothing). CLR automatically releases objects when they are no longer in
use and refernced. CLR runs on non-deterministic to see the unused objects and cleans them. One
side effect of this non-deterministic feature is that we cannot assume an object is destroyed when
it goes out of the scope of a function. Therefore, we should not put code into a class destructor
to release resources.
(I) Can we force garbage collector to run ?
System.GC.Collect() forces garbage collector to run. This is not recommended but can be used if
situations arises.
(B)What is reflection?
All .NET assemblies have metadata information stored about the types defined in modules. This
metadata information can be accessed by mechanism called as “Reflection”.System. Reflection
can be used to browse through the metadata information.
Using reflection you can also dynamically invoke methods using System.Type.Invokemember.
Below is sample source code if needed you can also get this code from CD provided, go to
“Source code” folder in “Reflection Sample” folder.
Public Class Form1
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
Dim Pobjtype As Type
Dim PobjObject As Object
Dim PobjButtons As New Windows.Forms.Button()
Pobjtype = PobjButtons.GetType()
For Each PobjObject In Pobjtype.GetMembers
LstDisplay.Items.Add(PobjObject.ToString())
Next
End Sub
End Class
110
Note :- Sample source code are compiled using VB.NET 2005.
Figure:- 1.9 Sample reflection display
Sample source code uses reflection to browse through “Button” class of “Windows.Forms”. If
you compile and run the program following is output as shown in “Sample Reflection Display”.
Using reflection you can also dynamically invoke a method using “System.Type.InvokeMember”.
Note :- System.Type.InvokeMember is left as homework for readers. Believe me you will
enjoy doing it yourself and the concept of reflection will be clearer.
(P)What are different types of JIT ?
Note :- This question can only be asked when the interviewer does not know what he wants.
It was asked to me in one of interview and for 15 minutes he was roaming around the
same question in order to get answer from me (requirement was for a simple database
project). Beware of such companies and interviewers you can land up no where.
JIT compiler is a part of the runtime execution environment.
In Microsoft .NET there are three types of JIT compilers:
111
√ Pre-JIT :- Pre-JIT compiles complete source code into native code in a single
compilation cycle. This is done at the time of deployment of the application.
√ Econo-JIT :- Econo-JIT compiles only those methods that are called at runtime.
However, these compiled methods are removed when they are not required.
√ Normal-JIT :- Normal-JIT compiles only those methods that are called at runtime.
These methods are compiled the first time they are called, and then they are stored in
cache. When the same methods are called again, the compiled code from cache is
used for execution.
(B) What are Value types and Reference types ?
Value types directly contain their data which are either allocated on the stack or allocated in-line in
a structure.
Reference types store a reference to the value's memory address, and are allocated on the heap.
Reference types can be self-describing types, pointer types, or interface types.
Variables that are value types each have their own copy of the data, and therefore operations on
one variable do not affect other variables. Variables that are reference types can refer to the same
object; therefore, operations on one variable can affect the same object referred to by another
variable. All types derive from the System.Object base type.
(B) What is concept of Boxing and Unboxing ?
Boxing permits any value type to be implicitly converted to type object or to any interface type
implemented by value type. Boxing is a process in which object instances are created and copy
values in to that instance.
Unboxing is vice versa of boxing operation where the value is copied from the instance in to
appropriate storage location.
Below is sample code of boxing and unboxing where integer data type is converted in to object
and then vice versa.
Dim x As Integer
Dim y As Object
x = 10
‘ boxing process
y = x
112
‘ unboxing process
x = y
(B) What is the difference between VB.NET and C# ?
Well this is the most debatable issue in .NET community and people treat there languages like
religion. Its a subjective matter which language is best. Some like VB.NET’s natural style and some
like professional and terse C# syntaxes. Both use the same framework and speed is also very much
equivalents. But still let’s list down some major differences between them :-
Advantages VB.NET :-
√ Has support for optional parameters which makes COM interoperability much easy.
√ With Option Strict off late binding is supported.Legacy VB functionalities can be
used by using Microsoft.VisualBasic namespace.
√ Has the WITH construct which is not in C#.
√ The VB.NET part of Visual Studio .NET compiles your code in the background.
While this is considered an advantage for small projects, people creating very large
projects have found that the IDE slows down considerably as the project gets larger.
Advantages of C#
√ XML documentation is generated from source code but this is now been incorporated
in Whidbey.
√ Operator overloading which is not in current VB.NET but is been introduced in
Whidbey.
√ Use of this statement makes unmanaged resource disposal simple.
√ Access to Unsafe code. This allows pointer arithmetic etc, and can improve
performance in some situations. However, it is not to be used lightly, as a lot of the
normal safety of C# is lost (as the name implies).This is the major difference that you
can access unmanaged code in C# and not in VB.NET.
* How much ever this book tries it can not match the huge variations of questions that have
been asked in.NET interviews.But note there will be variations and they will map to some
question of this book.
113
(I)What is the difference between System exceptions and Application
exceptions?
All exception derives from Exception Base class. Exceptions can be generated programmatically
or can be generated by system. Application Exception serves as the base class for all applicationspecific
exception classes. It derives from Exception but does not provide any extended functionality.
You should derive your custom application exceptions from Application Exception.
Application exception is used when we want to define user defined exception, while system
exception is all which is defined by .NET.
Figure :- 1.10 Exception Hierarchy
Note:- Frankly I have always relied on using Microsoft exception application blocks. As
such I have never used application exception; I think most of the work is done using System
exception classes.
(I)What is CODE Access security?
114
CAS is part of .NET security model that determines whether or not a piece of code is allowed to
run and what resources it can use while running. Example CAS will allow an application to read
but not to write and delete a file or a resource from a folder..
(I)What is a satellite assembly?
Refer Localization chapter for more details
(A)How to prevent my .NET DLL to be decompiled?
By design .NET embeds rich Meta data inside the executable code using MSIL. Any one can easily
decompile your DLL back using tools like ILDASM (owned by Microsoft) or Reflector for
.NET which is a third party. Secondly there are many third party tools which make this decompiling
process a click away. So any one can easily look in to your assemblies and reverse engineer them
back in to actual source code and understand some real good logic which can make it easy to
crack your application.
The process by which you can stop this reverse engineering is using “obfuscation”. It’s a technique
which will foil the decompilers. There are many third parties (XenoCode, Demeanor for .NET)
which provide .NET obfuscation solution. Microsoft includes one that is Dotfuscator Community
Edition with Visual Studio.NET.
Note: - I leave this as homework to reader’s compile, a DLL obfuscate it using
“Dotfuscator Community Edition” which comes with Visual Studio.NET and try viewing
the same using ILDASM.
(I) What is the difference between Convert.toString and .toString()
method ?
Just to give an understanding of what the above question means seethe below code.
int i =0;
MessageBox.Show(i.ToString());
MessageBox.Show(Convert.ToString(i));
We can convert the integer “i” using “i.ToString()” or “Convert.ToString” so what’s the difference.
The basic difference between them is “Convert” function handles NULLS while “i.ToString()”
does not it will throw a NULL reference exception error. So as good coding practice using
“convert” is always safe.
115
(A) What is Native Image Generator (Ngen.exe)?
The Native Image Generator utility (Ngen.exe) allows you to run the JIT compiler on your assembly's
MSIL and generate native machine code which is cached to disk. After the image is created .NET
runtime will use the image to run the code rather than from the hard disk. Running Ngen.exe on
an assembly potentially allows the assembly to load and execute faster, because it restores code
and data structures from the native image cache rather than generating them dynamically.
Below are some points to be remembered for Native Image Generator:-
√ Native images load faster than MSIL because JIT compilation and type-safety verification
is eliminated.
√ If you are sharing code between process Ngen.exe improves the performance
significantly. As Native image generated Windows PE file so a single DLL file can be
shared across applications. By contrast JIT produced code are private to an assembly
and can not be shared.
√ Native images enable code sharing between processes.
√ Native images require more storage space and more time to generate.
√ Startup time performance improves lot. We can get considerable gains when applications
share component assemblies because after the first application has been started the
shared components are already loaded for subsequent applications. If assemblies in
an application must be loaded from the hard disk, does not benefit as much from
native images because the hard disk access time shadows everything.
√ Assemblies in GAC do not benefit from Native image generator as the loader performs
extra validation on the strong named assemblies thus shadowing the benefits of Native
Image Generator.
√ If any of the assemblies change then Native image should also be updated.
√ You should have administrative privilege for running Ngen.exe.
√ While this can fasten your application startup times as the code is statically compiled
but it can be somewhat slower than the code generated dynamically by the JIT compiler.
So you need to compare how the whole application performance with Ngen.exe and
with out it.
To run Ngen.exe, use the following command line.
ngen.exe install
116
This will synchronously precompile the specified assembly and all of its dependencies. The generated
native images are stored in the native image cache.
In .NET Framework 2.0 there is a service (.NET Runtime Optimization Service) which can
precompile managed assemblies in the background. You can schedule your assemblies to be
precompiled asynchronously by queueing them up with the NGEN Service. Use the following
command line.
ngen.exe install /queue:
Assemblies which are critical to your application's start up time should either be precompiled
synchronously or asynchronously with priority 1. Priority 1 and 2 assemblies are precompiled
aggressively while Priority 3 assemblies are only precompiled during machine idle-time.
Synchronously precompiling your critical assemblies guarantees that the native images will be
available prior to the first time your end user launches the application but increases the time taken
to run your application's set up program.
You can uninstall an assembly and its dependencies (if no other assemblies are dependent on
them) from the native image cache by running the following command.
ngen.exe uninstall
Native images created using Ngen.exe cannot be deployed; instead they need to be created on the
end user's machine. These commands therefore need to be issued as part of the application's
setup program. Visual Studio .NET can be used to implement this behavior by defining custom
actions in a Microsoft Installer (MSI) package.
Note: - One of the things the interviewer will expect to be answered is what scenario will
use a Native Image generator. Best is to say that we first need to test the application
performance with Native Image and with out it and then make a decision.
(A) We have two version of the same assembly in GAC? I want my client
to make choice of which assembly to choose?
Note: - I really want to explain this in depth for two reasons. First I have seen this
question been frequently asked and second it’s of real practical importance. I have faced this
in every of my .NET projects...So let’s try to get this fundamental not in our brain but in
our heart.
OK first let’s try to understand what the interviewer is talking about. Let’s say you have made an
application and its using a DLL which is present in GAC. Now for some reason you make second
version of the same DLL and put it in GAC. Now which DLL does the application refer? Ok by
default it always refers the latest one. But you want that it should actually use the older version.
117
So first we answer in short. You need to specify “bindingRedirect” in your config file. For instance
in the below case “ClassLibraryVersion” has two versions “1.1.1830.10493” and “1.0.1830.10461”
from which “1.1.1830.10493” is the recent version. But using the bindingRedirect we can specify
saying “1.0.1830.10461” is the new version. So the client will not use “1.1.1830.10493”.




publicKeyToken="b035c4774706cc72"
culture="neutral"/>
newVersion= "1.0.1830.10461"/>




Ok now I will try to answer it in long way by doing a small sample project. Again this project will
be done using C#. So in CD you can find the “Versioning” project. Below is the solution display,
it has two projects one the windows client project ( “WindowsVersioningCSharp” ) and second
the class library project ( “ClassLibraryVersion” ) which will be installed in GAC with two versions.
118
Figure 1.11: - Solution files for the versioning project.
Our first primary goal is to put two different versions of the same DLL in GAC. So let’s make a
walk through of “ClassLibraryVersion” project. It’s a very simple class which has “Version” function
which just sends a string “This is old Version”. Second we will also just ensure that the assembly
version is “1.0” in the “AssemblyInfo.cs”.
119
Figure 1.12 : - Assembly Version 1.0
Second in order that we can put a DLL in GAC we need to create generate strong names and
assign the same to the class. For instance, in below figure I have generated the strong name in
“mykey.snk” and assigned the same to the DLL.
120
Figure 1.13 : - Strong naming your DLL
Finally we need to install the same in GAC using “gacutil” tool. Below is the figure which shows
the same. This installs one version of “ClassLibraryVersion.dll” in GAC.
Figure 1.14 : - Install the same in GAC
Now it is time to create a second version of the DLL. So here is what we will do first we will just
return a different string value for this new version DLL. You can see in the below figure I have
changed the string to return “This is New Version”. Secondly we also need to change the
AssemblyVersion to “1.1.*” in the “AssemblyInfo.cs” file. After that again compile the DLL and
run the “gacutil” to register this second version of the “ClasLibraryVersion.dll”.
121
Figure 1.15 : - Rename to Assembly Version 1.1
Now when we view the GAC we can see two version of “ClassLibraryVersion” i.e. “1.1.1832.2619”
and “1.0.1832.2172” (see figure below).
Figure 1.16 : - Two version of “ClassLibraryVersion” dll.
122
Now that we have created the environment of two version of the same DLL in GAC its time to
look at how client can make a choice between those versions. We need to generate “publicKeyToken”
in order to move ahead. Below is a sample print screen which shows how we can use “sn.exe” to
generated the public key token. Note the “-T” parameter.
Figure 1.17 : - Get the PublicKeyToken
Now let’s look at the client which will consume this DLL. I have just added windows form and
a button to the same. In the button click we will try to call the version function and display the
data. So below is the code in the first step we create the object of “ClassLibraryVersion.Class1”
and in the second step we call the “Version” function to display the data.
Figure 1.18 : - Client code calling the GAC class.
Now comes the most important part of the whole thing the “app.config” file which will decide
which version should be used. So add a new “app.config” file in the project and add the
“AssemblyBinding” section as show below. So you need to specify the following things:-
√ Assembly name in the “name” attribute of “assemblyIdentity” section.
√ Specify the “publicKeyToken” value in the “assemblyIndentity” section which was generated
using “sn.exe –T ‘dllname.dll’ “.
√ Specify the “oldVersion” and “newVersion” values in the “bindingRedirect” element. So
what ever version we want the client to use should be specified in the “newVersion” attribute.
123
You can see from the figure below I have specified that client should use “1.0.*” version. So
the client will display “This is old Version”.
Figure 1.19 : - App.config file using the BindingRedirect
If you run the source code with changing version numbers you can see the below two message
boxes on different version numbers. That is “This is old version” will be displayed when
“newVersion” value is “1.0.1832.5411” and “This is new Version” will be displayed when
“newVersion” value is “1.1.1832.5427”.
124
Figure 1.20 : - Different Display depending on version numbers
Note: - Source code is provided in “versioning” folder. But as you compile the DLL’s
different publicToken numbers are created so you need to run the sn.exe in your machine and
change the token number accordingly in the “App.config” file.
(A)What is CodeDom?
“CodeDom” is an object model which represents actually a source code. It is designed to be
language independent - once you create a “CodeDom” hierarchy for a program we can then
generate the source code in any .NET compliant language. So let’s try to do something real
practical and simple to just get a feel of how powerful “CodeDom” is.
Note :- You can get the source code in CD in “CodeDom” folder.
We will try to generate the following code below. The below code which will be generated does
not do anything special buy just displays a hello message and waits for the key to be pressed.
namespace InterviewQuestions
{
using System;
public class EntryPoint
{
public static void Main()
{
System.Console.WriteLine(“Hello from Interview Question series”);
System.Console.ReadLine();
125
}
}
}
The “Codedom” folder in the CD has one “GenerateCode” method which returns
“CodeCompileUnit” object. “CodeDom” is nothing but a full DOM model where every object
in the structure represents a code unit. I have put comments the code so that the code is self
understandable. I have commented the code below so that readers can follow what is exactly
happening. When you click the button it generates the “MyCode.cs” and also compiles the
“Mycode.exe” in the “bin” folder.
//private CodeCompileUnit GenerateCode()
{
// Definition of the Main method which will be entry point
CodeEntryPointMethod objMainMethod = new CodeEntryPointMethod();
objMainMethod.Name = “Main”;
// generate this expression: Console
CodeTypeReferenceExpression consoleType = new CodeTypeReferenceExpression();
consoleType.Type = new CodeTypeReference(typeof(Console));
// Set up the argument list to pass to Console.WriteLine()
CodeExpression[] writeLineArgs = new CodeExpression[1];
CodePrimitiveExpression arg0 = new CodePrimitiveExpression(“Hello from Interview
Question series”);
writeLineArgs[0] = arg0;
// generate this statement: Console.WriteLine(message)
CodeMethodReferenceExpression writeLineRef = new
CodeMethodReferenceExpression(consoleType, “WriteLine”);
126
CodeMethodInvokeExpression writeLine = new
CodeMethodInvokeExpression(writeLineRef, writeLineArgs);
// generate this statement: Console.ReadLine()
CodeMethodReferenceExpression readLineRef = new
CodeMethodReferenceExpression(consoleType, “ReadLine”);
CodeMethodInvokeExpression readLine = new
CodeMethodInvokeExpression(readLineRef);
// Add Main() method to a class
CodeTypeDeclaration theClass = new CodeTypeDeclaration();
theClass.Members.Add(objMainMethod);
theClass.Name = “EntryPoint”;
// Add both the code of WriteLine and Readline
objMainMethod.Statements.Add(writeLine);
objMainMethod.Statements.Add(readLine);
// Add namespace and add class
CodeNamespace ns = new CodeNamespace(“InterviewQuestions”);
ns.Imports.Add(new CodeNamespaceImport(“System”));
ns.Types.Add(theClass);
// Generate the Compile Unit
CodeCompileUnit unit = new CodeCompileUnit();
unit.Namespaces.Add(ns);

DOTNET FAQ-1

Introduction
Dedication
This book is dedicated to my kids Sanjana and Simran, whose dad’s play time has been
stolen and given to this book. I am thankful to my wife for constantly encouraging me and
also to BPB Publication to give new comer a platform to perform. Finally on top of all
thanks to the two old eyes my mom and dad for always blessing me. I am blessed to have
Raju as my brother who always keeps my momentum moving on.
I am grateful to Bhavnesh Asar who initially conceptualized the idea I believe concept
thinking is more important than execution. Tons of thanks to my reviewers whose feedback
provided an essential tool to improve my writing capabilities.
Just wanted to point out Miss Kadambari . S. Kadam took all the pain to review for the
left outs with out which this book would have never seen the quality light.
About the author
Author works in a big multinational company and has over 8 years of experience in
software industry. He is working presently as project lead and in past has led projects in
banking, travel and financial sectors.
But on top of all, I am a simple developer like you all guys there doing an 8 hour job.
Writing is something I do extra and I love doing it. No one is perfect and same holds true
for me .So anything you want to comment, suggest, and point typo / grammar mistakes or
technical mistakes regarding the book you can mail me at shiv_koirala@yahoo.com. Believe
me guys your harsh words would be received with love and treated to the top most priority.
Without all you guys I am not an author.
Writing an interview question book is really a great deal of responsibility. I have tried to
cover maximum questions for the topic because I always think probably leaving one silly
question will cost someone’s job there. But huge natural variations in an interview are
something difficult to cover in this small book. So if you have come across such questions
during interview which is not addressed in this book do mail at shiv_koirala@yahoo.com
.Who knows probably that question can save some other guys job.
Features of the book
√ Around 400 plus interview questions from live .NET interviews.
“Cheers to the true fighting spirit of IT professionals”
86
√ Section wise .NET interview question coverage according to multinational
companies.
√ Short and to the point answers ( no hitting around the bush).
√ Every question is classified in to Basic,Intermediate and advanced category,
thus providing more focus to readers on specific category.
√ During interviews other than main technology (.NET, JAVA etc.) companies
expect other areas to be strong for example UML, Architecture, Database
etc. Other sections is the most strong point of the book, which makes
reader prepared for the unexpected questions.
√ Full range of interview questions right from junior .NET developers to senior
architects or project manager.
√ CD has sample resume, sample dummy project and sample code to understand
fundamentals..
√ Book covers important points like salary negotiations, resume making and
general points to be remembered during interview.
√ Recommended for .NET interviewers who are looking for what questions to
be asked to get better and decent .NET professionals
√ Recommended for Fresher and students who want to have a feel of what
.NET questions are asked in multinational companies.
√ Developers who are looking for Quick reference and FAQ.
I am sure after reading this book readers will have extra confidence and a better approach
for .NET interviews.
Introduction
When we look back at times of COBOL, PASCAL features provided by these languages
where minimal. More emphasis was on completing projects than on quality of code. As
features provided by languages where less, programmer had to code everything from
scratch. For example to write a simple sorting logic you have to write your own sorting
algorithm. As languages grew and started becoming mature, these logic where in-built
87
feature of language. As feature list of languages started growing programmer’s became
feature specialist rather than specialist of whole language.
If a developer who is working for past two to three years on remoting is a remoting
specialist, but probably in ADO.NET he has minimal knowledge. Now after working day
& night and becoming specialist he is looking for a job. But the bad part of IT industry
today is that they do not look for specialist rather they look for developers who have fair
knowledge of over all feature of the language. This remoting specialist stumbles with
simple ADO.NET and SQL questions during interview. But guys that’s ok when you are
working and concentrating on one particular aspect it’s but obvious that you will forget
these fundamentals.
Software clients no more look source code as the only one deliverable, but even other
documents like SRS (System Requirement documents), SDD (System Design Documents),
Test Plans (SITP and UTP) etc. as a integral part of project. IT multinationals are now
looking from both technical and process aspect of the project. So going with pure .NET
technical fundamentals will only take you to a programmer position, but know how of
documenting project, UML understanding, SDLC cycle etc will take you to a better position
(Project Manager, Program Manager, Senior architect etc).
This book covers the other aspect of .NET interview’s by providing chapter like
Architecture, UML, SQL SERVER, Project Management, General Interview questions
etc.
I hope this book takes you to a better height and gives you extra confidence boost during
int erview’s.Best of Luck and Happy Job-Hunting.............
How to read this book
If you can read English, you can read this book....kidding. There are some legends which
will make your reading more effective. Every question has simple tags which mark the
rating of the questions.
These rating are given by Author and can vary according to companies and individuals.
(B) Basic Questions
Basic Grade means according to the interviewer it’s a fundamental question and should
be answered. Example What is a CLR ? Guy’s stumbling on this question will rarely pass
interviews.
88
(I) Intermediate Questions
These are Mid-level questions and will be expected to be answered if you are looking for
a decent position in the company.
(A) Advanced Questions
These are advanced level question which are expected when they are looking for specialist
in the field.
(P) Psyche Questions
These level of questions do not judge anything for a candidate but see it as a attitude
problem of the interviewer.
* Marked Questions
These are general questions asked in IT world. Example “What’s your expectation ?” You
will see these question’s as you keep reading. There are no direct answers to these question
but they do affect a lot during job search. Be ready with some decent answers.
Note
While reading you can come across section marked as “Note”, which highlight special
points of that section.
89
Software Company hierarchy
Figure :- 0.1 IT Company hierarchy
Its very important during interview to be clear about what position you are targeting.
Depending on what positions you are targeting the interviewer shoots you questions.
Example if you are looking for a project manager position you will be asked around 20%
technical questions and 80% management.
90
Note:- In small scale software house and mid scale software companies there are chances
where they expect a PM to be very much technical. But in big software houses the situations
are very much different, interview are conducted according to positions.... Unless the
interviewer changes the rule.
Above is a figure of a general hierarchy across most IT companies.
Note:- There are many small and medium software companies which do not follow this
hierarchy and they have there own adhoc way of defining positions in the company.
So why is the need of hierarchy in a interview.
“Interview is a contract between the employer and candidate to achieve specific goals.”
So employer is looking for a suitable candidate and candidate looks for a better career.
Normally in interviews the employer is very clear about what type of candidate he is
looking for.But 90% times the candidate is not clear about the positions he is looking for.
How many times it has happened with you that you have given a whole interview and
when you mentioned the position you are looking for...pat comes the answer, “ we do not
have any requirements for this position”. So be clarified about the position right from
when you start the interview.
Following are the number of years of experience according to position.
√ Junior engineers are specially fresher and work under software engineers.
√ Software engineers have around 1 to 2 years of experience. Interviewer expects
software engineers to be technically at a medium level.
√ Senior Software Engineers have around 2 to 4 years of experience. Interviewer
expects them to technically be very strong.
√ Project leads should handle majority technical aspect of project and should
have around 4 to 8 years of experience. They are also indirect architect of the
project. Interviewer expects them to be technically strong and in terms of
architecture to be decent. Interviewer also expects them to have people
management skills.
√ Project Manager are expected to be around 40% technically strong and should
have experience above 10 years plus. But they are more interviewed from
aspect of project management, client interaction, people management, proposal
preparation etc.
91
So now judge where you stand, and where you want to go..........
Resume Preparation Guidelines
First impression the last impression
Note :- A sample resume is provided in “SampleResume” folder.
Before even the interviewer meets you he will first meet your resume. Interviewer looking
at your resume is almost a 20% interview happening with out you knowing it. I was
always a bad guy when it comes to resume preparation. But when I looked at my friends
resume they where gorgeous. Now that I am writing series of book on interviews I thought
this will be a good point to put in. You can happily skip it if you are confident about your
resume. There is no hard and fast rule that you have to follow the same pattern but just
see if these all check list are attended.
√ Use plain text when you are sending resumes through email. For instance you sent
your resume using Microsoft word and what if the interviewer is using Linux he will
never be able to read your resume. You can not be sure both wise, you sent your
resume in Word 2000 and the guy has Word 97…uuhhh.
√ Attach a covering letter it really impresses and makes you look traditionally formal.
Yes, even if you are sending your CV through email send a covering letter.
Check list of content you should have in your resume :-
√ Start with an objective or summary, for instance, “Working as a Senior Database
administrator for more than 4 years. Implemented quality web based application.
Follow the industry’s best practices and adhered and implemented processes,
which enhanced the quality of technical delivery. Pledge to deliver the best technical
solutions to the industry.”
√ Specify your Core strengths at the start of the resume by which the interviewer can
make a quick decision are you eligible for the position. For example :-
• Looked after data mining and data warehousing department independently. Played
a major role in query optimization.
• Worked extensively in database design and ER diagram implementation.
• Well versed with CMMI process and followed it extensively in projects.
• Looking forward to work on project manager or senior manager position.
92
This is also a good position to specify your objective or position which makes it clear to
the interviewer that should he call you for an interview. For instance, if you are looking
for senior position specify it explicitly ‘looking for this job profile’. Any kind of certification
like MCP, MCSD etc you can make it visible in this section.
√ Once you have specified briefly your goals and what you have done its time to
specify what type of technology you have worked with. For instance RDBMS,
TOOLS, Languages, Web servers, process (Six sigma, CMMI).
√ After that you can make a run through of your experience company wise that is
what company you have worked with, year / month joining and year / month left.
This will give an overview to the interviewer what type of companies you have
associated your self.
Now its time to mention all your projects you have worked till now. Best is to start in
descending order that is from your current project and go backwards. For every project try
to put these things :-
√ Project Name / Client name (It’s sometimes unethical to mention clients name; I
leave it to the readers).
√ Number of team members.
√ Time span of the project.
√ Tools, language, RDBMS and technology used to complete the project.
√ Brief summary of the project.
Senior people who have huge experience will tend to increase there CV with putting in
summary for all project. Best for them is to just put description of the first three projects
in descending manner and rest they can say verbally during interview. I have seen CV
above 15 pages… I doubt who can read it.
√ Finally comes your education and personal details.
√ Trying for onsite, do not forget to mention your passport number.
√ Some guys tend to make there CV large and huge. I think an optimal size should be
not more than 4 to 5 pages.
√ Do not mention your salary in CV. You can talk about it during interview with HR
or the interviewer.
93
√ When you are writing your summary for project make it effective by using verbs like
managed a team of 5 members, architected the project from start to finish etc. It
brings huge weight.
√ This is essential very essential take 4 to 5 Xerox copies of your resume you will need
it now and then.
√ Just in case take at least 2 passport photos with you. You can escape it but many
times you will need it.
√ Carry all your current office documents specially your salary slips and joining letter.
Salary Negotiation
Ok that’s what we all do it for money… not everyone is right. This is probably the weakest
area for techno savvy guys. They are not good negotiators. I have seen so many guys at the
first instance they will smile and say “NEGOTIABLE SIR”. So here are some points:-
√ Do a study of what is the salary trend? For instance have some kind of baseline. For
example what is the salary trend on number of year of experience? Discuss this
with your friends out.
√ Do not mention your expected salary on the resume?
√ Let the employer first make the salary offer. Try to delay the salary discussion till the
end.
√ If they say what you expect ?, come with a figure with a little higher end and
say negotiable. Remember never say negotiable on something which you have aimed,
HR guys will always bring it down. So negotiate on AIMED SALARY + some thing
extra.
√ The normal trend is that they look at your current salary and add a little it so that
they can pull you in. Do your home work my salary is this much and I expect this
much so whatever it is now I will not come below this.
√ Do not be harsh during salary negotiations.
√ It’s good to aim high. For instance I want 1 billion dollars / month but at the same
time be realistic.
√ Some companies have those hidden cost attached in salary clarify that rather to be
surprised at the first salary package.
94
√ Many of the companies add extra performance compensation in your basic which
can be surprising at times. So have a detail break down. Best is to discuss on hand
salary rather than NET.
√ Talk with the employer in what frequency does the hike happen.
√ Take everything in writing, go back to your house and have a look once with a cool
head is the offer worth it of what your current employer is giving.
√ Do not forget once you have job in hand you can come back to your current employer
for negotiation so keep that thing in mind.
√ Remember the worst part is cribbing after joining the company that your colleague is
getting more. So be careful while interview negotiations or be sportive to be a
good negotiator in the next interview.
√ One very important thing is that the best negotiation ground is not the new company
where you are going but the old company which you are leaving. So once you have
offer on hand get back to your old employee and show them the offer and then make
your next move. It’s my experience that negotiating with the old employer is easy
than with the new one….Frankly if approached properly rarely any one will say no.
Just do not be aggressive or egoistic that you have an offer on hand.
Top of all some time some things are worth above money :- JOB SATISFACTION. So
whatever you negotiate if you think you can get JOB SATISFACTION aspect on higher
grounds go for it. I think its worth more than money.
Figure :- 0.2 Salary Card for India
95
Figure :- 0.3 US Salary Card
Note: - The above US Salary card is based on my experience and some talk which I had
with my friends who are staying on longer term basis outside. In case you are finding
discrepancies please do mail me at shiv_koirala@yahoo.com probably we can standardize it
better for the community.
The score card shown above is completely derived from author’s experience and interaction
he had in his circle. It is not an approved score card by any authorized body as such and
should be taken only has bench mark to measure your success. Also note that these rates
are applicable for medium and large software companies. Small company rate cards are
very irregular and governed by a single owner of the company. So the above rate card is
not applicable for small company. Many people do get mind blowing salaries even with
small experience which again the score card does not reflect.
Points to remember
√ One of the first questions asked during interview is “Can you say something about
yourself ”?
√ Can you describe about your self and what you have achieved till now?
√ Why do you want to leave the current company?
√ Where do you see yourself after three years?
96
√ What are your positive and negative points?
√ How much do you rate yourself in .NET and SQL Server in one out of ten?
√ Are you looking for onsite opportunities? (Be careful do not show your desperation
of abroad journeys)
√ Why have you changed so many jobs? (Prepare a decent answer do not blame
companies and individuals for your frequent change).
√ Never talk for more than 1 minute straight during interview.
√ Have you worked with previous version of SQL Server?
√ Would you be interested in a full time Database administrator job?
√ Do not mention client names in resume. If asked say that it’s confidential which
brings ahead qualities like honesty
√ When you make your resume keep your recent projects at the top.
√ Find out what the employer is looking for by asking him questions at the start of
interview and best is before going to interview. Example if a company has projects
on server products employer will be looking for BizTalk, CS CMS experts.
√ Can you give brief about your family background?
√ As you are fresher do you think you can really do this job?
√ Have you heard about our company ? Say five points about our company? Just read
at least once what company you are going for?
√ Can you describe your best project you have worked with?
√ Do you work on Saturday and Sunday?
√ Which is the biggest team size you have worked with?
√ Can you describe your current project you have worked with?
√ How much time will you need to join our organization? What’s notice period for
your current company?
√ What certifications have you cleared?
√ Do you have pass port size photos, last year mark sheet, previous companies
employment letter, last months salary slip, pass port and other necessary documents.
97
√ What is the most important thing that motivates you?
√ Why you want to leave the previous organization?
√ Which type of job gives you greatest satisfaction?
√ What is the type of environment you are looking for?
√ Do you have experience in project management?
√ Do you like to work as a team or as individual?
√ Describe your best project manager you have worked with?
√ Why should I hire you?
√ Have you been ever fired or forced to resign?
√ Can you explain some important points that you have learnt from your past project
experiences?
√ Have you gone through some unsuccessful projects, if yes can you explain why did
the project fail?
√ Will you be comfortable with location shift? If you have personal problems say no
right at the first stage.... or else within two months you have to read my book again.
√ Do you work late nights? Best answer if there is project deadline yes. Do not
show that it’s your culture to work during nights.
√ Any special achievements in your life till now...tell your best project which you
have done best in your career.
√ Any plans of opening your own software company...Beware do not start pouring
your bill gate’s dream to him.....can create a wrong impression.