Hi Dear friend i sent some DotNet Interview questions and
answers to ur mail id

The event-delegation model has two advantages over the 
event-inheritance model. First, it enables event handling 
to be handled by objects other than the ones that generate 
the events (or their containers). This allows a clean 
separation between a component's design and its use. The 
other advantage of the event-delegation model is that it 
performs much better in applications where many events are 
generated. This performance improvement is due to the fact 
that the event-delegation model does not have to repeatedly 
process unhandled events, as is the case of the event-
inheritance
model.

catch(SQLQueryException e)
{
 \\SQL Query
}
 would throw exception as a try can have more than one catch
block that the related exception can be handled individually

I tried I got the following ...

Error	1	A previous catch clause already catches all exceptions of this or of a super type ('System.Exception')	E:\dotnet\ConsoleApplication1\ConsoleApplication1\Program.cs	58	20	ConsoleApplication1

Web Control will have .ascx and its codebehind file. Custom 
control will have only codebehind (.cs) file.

In summary, custom control may not have any UI interface.

Usercontrol:
1) User control can be used for the Reusable purpose only.
2) Once you create User control that can be access in 
current project.
3) User control extenction is .ascx file.
4) It can be visible in Solution explorer.
5) It is Locally used.If you want used this control in any 
page just drag and drop from Solution or Register that 
particular page like 
<%@ Register TagPrefix="scott" TagName="header" 
Src="Controls/Header.ascx" %>
<%
Custom Control:
1) Custom control can used for Globale purpose like Tollbox 
controls.
2) custom control can created extenction file is .dll .
3) It can Add to Toolbox like 
Right click on toolbox add->choose itemes->select path of 
file.
4) custom control If you want used in any forms just you 
can drag and drop like normal control.

(1) Interface have no concrete methods implemented while 
abstract class can have. 

(2) Interface can come into the chain of inheritance while 
Abstract class can't.

a)for Future, we can provide extra services in Abstract 
Class ,these futures can able to access   all of its  
Clients. And also it supports reusability.
  suppose the implementer need not provide implementation 
for all the methods.
 
Where as in Interface we don’t have this future(reusability 
and extra servicess).
               each implementer need to provide 
implementation for all the methods and 
also                  we cont provide extra services in 
future.The interface should be constant.


b)Interface can support multiple  inheritance where as 
abstract class does not.

the main reason to use polymorphism is generalization, as 
you can see in case of overloading. say if i have add 
function which just add two intergers. and i have one more 
similar kind of functionality then in that case i will do 
the overloading as only my internal implemantation will 
vary.

second thing is consistency in code.

and in case of overriding main advantage is you can invoke 
child class function dynamically(means by creating the 
object of base class as normally we do). 

suppose one of my function expects my base class type 
object and i want functionality of overrided function then 
in that case i can simply write (parent obj = new child();)

Generics are used to have Typed Arrays.

Ex: if we have define that an array is confined to products.
if we push objects of product into array it accepts.
if we push employee objects into this array it will show
error . since the type of the array is product.

Generics was introduced in Framework 2.0
With generics we can have typed classes. While defining 
class we simply give placeholders and when we create 
objects of that class we declare the placeholder to be of 
some type(like int, double, string, etc.) and from that 
point on our object gets bind to that type only.