1. What is MSIL?
From
(Google web definitions)
Microsoft
Intermediate Language (MSIL) is the CPU-independent instruction set generated
by .NET compilers from .NET languages such as J#, C# or Visual Basic. MSIL is
compiled before or during execution of the program by a Virtual Execution
System (VES), which is part of the Common Language Runtime module (CLR).
2. What is the CLR and how
is it different from a JVM?
From
http://www.itwriting.com/dotnet4.php
The JVM can
either interpret or just-in-time compile the byte
code. The CLR always compiles to native code. Another is that the CLR supports
unmanaged code, known as “unsafe”, where the programmer assumes the
responsibility for managing memory and can do pointer arithmetic and so forth.
3. What is WinFX?
From
(Google web definitions)
The new
Windows API that will be released with the Microsoft Longhorn Operating System.
This will include features for Avalon, Indigo, and WinFS
as well as a number of fundamental routines.
4. What is Indigo?
From
(Google web definitions)
The code name for the communications portion of Longhorn that is built
around Web services. This communications technology focuses on providing spanning
transports, security, messaging patterns, encoding, networking and hosting, and
more.
5. Explain the Remoting architecture.
From
http://www.kippsoftware.com/san200405.htm
·
The
developer first instantiates locally a proxy interface to the remote
assembly. Local code calls a method of the proxy
·
The
.NET platform calls the corresponding method on the remote server and returns
the results (see figure).
·
Developers can use TCP or
HTTP remoting.
·
Remoting makes use of Leases
and allocations to improve efficiency.
6. How would you write an
asynchronous webservice?
Use a callback and call BeginSubmit yourself.
7. What is the Microsoft
Enterprise Library?
A set of functions that adhere to Microsoft’s
Patterns and Practices guidelines. These functions include:
Caching Application Block, Configuration
Application Block, Data Access Application Block, Cryptography Application
Block, Exception Handling Application Block, Logging and Instrumentation
Application Block and the Security Application Block.
8. Discuss System.Collections
8 – 24 From http://msdn.microsoft.com/
The System.Collections namespace contains interfaces and
classes that define various collections of objects, such as lists, queues, bit
arrays, hashtables and dictionaries.
9. Discuss System.Configuration
The System.Configuration
namespace provides classes and interfaces that allow you to programmatically
access .NET Framework configuration settings and handle errors in configuration
files (.config files).
10. Discuss System.Data
The System.Data namespace consists mostly of the classes
that constitute the ADO.NET architecture.
11. Discuss System.Diagnostics
The System.Diagnostics namespace
provides classes that allow you to interact with system processes, event logs,
and performance counters.
12. Discuss System.DirectoryServcies
The System.DirectoryServices namespace provides easy
access to Active Directory from managed code.
13. Discuss System.Drawing
The System.Drawing namespace provides access to GDI+
basic graphics functionality.
14. Discuss System.EnterpriseServices
The System.EnterpriseServices namespace
provides an important infrastructure for enterprise applications. COM+ provides
a services architecture for component programming models deployed in an enterprise
environment. This namespace provides .NET objects with access to COM+ services
making the .NET Framework objects more practical for enterprise applications.
15. Discuss System.Globalization
The System.Globalization namespace contains classes that
define culture-related information, including the language, the country/region,
the calendars in use, the format patterns for dates, currency, and numbers, and
the sort order for strings.
16. Discuss System.IO
The System.IO namespace contains types that
allow reading and writing to files and data streams,
and types that provide basic file and directory support.
17. Discuss System.Net
The System.Net
namespace provides a simple programming interface for many of the protocols
used on networks today.
18. System.Runtime contains System.Runtime.CompilerServcies, what else?
CompilerServices, InteropServices,
Remoting, Serialization.
19. Discuss System.Security
The System.Security namespace provides
the underlying structure of the common language runtime security system,
including base classes for permissions.
20. Discuss System.Text
The System.Text namespace contains
classes representing ASCII, Unicode, UTF-7, and UTF-8 character encodings;
abstract base classes for converting blocks of characters to and from blocks of
bytes; and a helper class that manipulates and formats String
objects without creating intermediate instances of String.
21. Discuss System.Threading
The System.Threading namespace provides classes and
interfaces that enable multithreaded programming.
22. Discuss System.Web
The System.Web namespace supplies classes and interfaces
that enable browser-server communication.
23. Discuss System.Windows.Forms
The System.Windows.Forms namespace contains classes for
creating Windows-based applications.
24. Discuss System.XML
The System.Xml namespace provides standards-based support for
processing XML.
25. Does VS.NET 2003 have a
web browser (think about it)?
Yes
26. How are VB.NET and C#
different?
Different syntax, no unsafe VB.NET code,
VB.NET is case insensitive, etc.
27. Contrast .NET with J2EE.
Overview
|
|
J2EE is
a set of non-vendor specific standards for developing “fat” and “thin”
applications and services, J2EE is mainly directed
at “thin” clients. These standards are the collaborative effort of
more than 400 companies. |
|
|
.net is
a tangible set of software and services designed to run on the Windows
platform. The .net software and services also allow the design and
implementation of enterprise and non-enterprise applications. Equal emphasis
has been given to “fat” and “thin” clients. .net was developed
exclusively by Microsoft. |
Virtual
Machines
Both .net
and J2EE use a Virtual Machine to interpret intermediate code. With J2EE
this intermediate code is called “Byte Code”. With .net the code is
called the “Intermediate Language”. When Java or .net code is written
and compiled it compiles to intermediate code.
|
|
With
J2EE the JVM (Java Virtual Machine) interprets its byte code line by
line into the machine’s native language. J2EE byte code can be compiled
directly to native machine code or JIT (Just In Time) compiled, but
the vast majority of J2EE applications are interpreted. |
|
|
The .NET
virtual machine, the CLR (Common Language Runtime) uses a JIT compiler
to compile blocks of IL code into native machine code at run time. Visual
Studio.net can also compile directly to native code. |
Programming
Languages
Both
platforms have the option of using multiple programming languages for an
enterprise application, although this is a much easier task to achieve with the
.net platform.
|
|
The J2EE
standard is based on Java, so applications are mainly developed in Java.
Interoperability is possible through JNI (Java Native interface) and CORBA
(Common Object Request Broker Architecture). The latter is almost never done
as the APIs are complicated and time consuming. |
|
|
.net
supports the seamless integration of over 20 languages,
this is done via strong typing, common interfaces and a concept called “managed
code”. On the down side, the language differences are largely semantic (VB.NET
vs. C#). Also, languages like C++ require extra imports
(managed extensions). |
Operating Systems
Both .NET
and J2EE have pretensions to having portable source code.
|
|
J2EE is
by far the best for portability, the whole specification is designed as to be
non-vendor specific. In practice though, Java source is often not
portable without modifications. |
|
|
.net has
promised that the CLR and core languages like C# will eventually be portable.
At present .net only runs on Windows. |
J2EE versus .net at Each Tier
An
enterprise application can be logically separated into 3 tiers - Presentation,
Business Logic, and the Data tier.
Presentation Tier
Both .net and J2EE use a scripting language at
the presentation tier for “thin” clients or “Web Applications”.
They also have similar ways of generating this tier for “fat” client
applications.
|
|
For “thin”
client applications J2EE uses Java Servlets
and a derivative of ASP (Active Server Pages) called JSP (Java
Server Pages), which intermingles HTML with Java
based script. Calls to Business logic components (EJB - Enterprise
Java Beans) are made from these JSP pages. Coding the page to render on a
number of different “thin” clients must be done manually. For “fat”
clients there is the Java Swing API, with a set of standard java beans
and a number of different GUIs to build applications with. |
|
|
.net
uses Visual Studio.net for both “thin” and “fat” clients. .net “thin”
client applications use the ASP.NET scripting language. ASP.NET can be
used in the traditional script based way, but Microsoft encourages the use of
a “Code Behind Page”. One simply drags and drops various “Web
Controls” onto an ASP.NET (.aspx) page
and then uses the code behind page to adjust those controls programmatically.
When an .aspx page is requested by a “thin”
client the page is rendered automatically by the .net runtime which checks
the type of “thin” client and adjusts each control accordingly. The result is
that an .aspx page can render on any supported
“thin” client without any extra work. This has a down side, that being that
the look n’ feel of each page is limited by the controls offered. Microsoft’s
IIS server also has legacy support for ASP, so ASP.NET and ASP can be used in
conjunction with each other. For “fat” clients the process is the same
except that there is a different set of controls for a “Windows Form”
(as opposed to a “Web Form”). |
Business Logic Tier
The two
technologies are very similar on this level with each borrowing concepts from
the other.
|
|
Java Beans
are the basic components (defined properties, event handling and
persistence). EJB are the distributed equivalents that have extra functions
for application level security, distributed transactions, life cycle
management and resource pooling. The java runtime handles the life cycle of
each component, deciding when to destroy a component (garbage collection)
and what memory it can access (sandbox security). |
|
|
.net
uses an enriched version of COM+ (assemblies) which gives its
components all of the above functions with the addition of newer concepts
like extensible meta-data for each assembly. Like J2EE the “registration” of
components is much easier with a new deployment model and .net projects also
support traditional COM and COM+ components. Perhaps the biggest
difference is the ability to go into “unmanaged mode” which allows the
application to access areas of memory normally inaccessible via the CLR
Sandbox. |
Data Tier
|
|
For
relational database access J2EE uses JDBC (Java Database Connection) –
which is based on Microsoft’s ODBC (Open Database Connectivity). At a
higher level it is conceptually the same as |
|
|
.net
uses ADO.NET , it has all the |
XML, Web Services, and Remoting
Web services
and remoting are web and
TCP/IP based remotely callable functions that sit on top of a predetermined protocol.
|
|
J2EE’s
web services run with a host of different protocols. They run with HTTP,
RMI/JRMP (Remote Method Invocation / Java Remote Method Protocol) or IIOP
(Internet InterORB Protocol). |
|
|
.net web
services run exclusively on HTTP with a SOAP (Simple Object Access
Protocol) wrapper. All data interchange is done with XML. Web services in
.net are all standardised with XML interfaces. Remoting
uses either SOAP or TCP/IP directly. The entire .net framework is very XML
centric. |
Performance
In an
enterprise environment .net outperforms J2EE. Benchmarks show that it is more
scalable, efficient, faster to run and develop, easier to use and cheaper -
sometimes by a factor of five. .net is designed to work just as well in a
non-enterprise environment (pointers, unmanaged code, etc.). J2EE is rarely
used in a non-enterprise environment to write graphically or numerically
intensive code for executables.
28. What benefit do you have
by implementing IDisposable interface in .NET?
You can use Dispose to clean up unmanaged
resources.
29. Explain the difference
between the Application object and Session object in ASP.NET.
The Application object affects all users of
the application whereas a session only affects one (the session holder).
30. Explain the difference
between User controls and Custom controls in ASP.NET.
|
Web
user controls |
Web
custom controls |
|
Easier
to create |
Harder
to create |
|
Limited
support for consumers who use a visual design tool |
Full
visual design tool support for consumers |
|
A
separate copy of the control is required in each application |
Only
a single copy of the control is required, in the global assembly cache |
|
Cannot
be added to the Toolbox in Visual Studio |
Can
be added to the Toolbox in Visual Studio |
|
Good
for static layout |
Good
for dynamic layout |
31. Write code for transaction
control in ADO.NET.
string connectionString = ".........";
SqlConnection myConnection = new SqlConnection(connectionString);
myConnection.Open();
// Start transaction.
SqlTransaction myTransaction = myConnection.BeginTransaction();
// Assign command in the
current transaction.
SqlCommand myCommand = new SqlCommand();
myCommand.Transaction = myTransaction;
try
{
//db ops here.
myTransaction.Commit();
Console.WriteLine("Records
are modified in the database.");
}
catch(Exception e)
{
myTransaction.Rollback();
Console.WriteLine(e.ToString());
Console.WriteLine("Neither
record was written to database.");
}
finally
{
myConnection.Close();
}
32. Write code for
transaction control in SQL Server.
BEGIN TRAN A
UPDATE mytable
BEGIN TRAN B
WITH MARK
UPDATE
mytable2
SELECT * frommytable
COMMIT TRAN
B
UPDATE mytable3 ...
33. In .NET, what is an
application domain?
From
(Google Web Definitions)
A secure
unit of processing that the Common Language Runtime uses to provide isolation
between applications.
34. In SQL Server, what is an
index?
From
http://www.faqts.com/knowledge_base/view.phtml/aid/8188/fid/87
An index is a list of sorted record pointers based on a column. Having indexes on your database tables will speed up SELECT queries if it is properly applied. Indexes will take up some disk space and will slow down INSERT and UPDATE queries.
35. What is optimistic vs.
pessimistic locking?
From
http://blogs.msdn.com/ricom/archive/2004/06/24/165063.aspx
Optimistic locking
-- that's where you assume things will go well and design your locks so that
they handle conflicts as the exceptional case
Pessimistic locking
-- the converse where you assume conflicts are likely and create some kind of
reservation system where sections are locked while they are edited
36. What is the difference
between a clustered and non-clustered index.
From
http://www.dotnetspider.com/technology/kbpages/1140.aspx
- The
difference is that, Clustered index is unique for any given table and we can
have only one clustered index on a table. The leaf level of a clustered index
is the actual data and the data is resorted in case of clustered index.
Whereas in case of non-clustered index the leaf level is actually a
pointer to the data in rows so we can have as many non-clustered indexes as we
can on the db.
37. In terms of remoting what is CAO and SAO?
Server Activated Objects : Stateless
- Singlecall
This object type is the most prevalent and is recommended by Microsoft for use
as the primary remoting type. Server activated Singlecall objects hold no state, which makes them ideal
for use with clustered web servers, object pooling, and all other sorts of
useful things. Since there is no state held in the object, you have to
pass all the data that the object needs to do its work on every call.
Server Activated Objects : Stateful
- Singleton
These objects are used when you need both a stateful
object AND you need that objects data to persist over time and multiple
instantiation. If 3 computers instance an SAO Singleton on a server, they
will all get a reference to that same object. Singletons are commonly
used to direct access to scarce resources and should generally be avoided when
possible.
Client Activated Objects : Stateful
CAO Objects are used when you need an object to be stateful
throughout its lifetime to its caller. CAO Objects persist
data to their caller, however they are different from SAO Singletons in that
multiple instantiations of a CAO will get brand new instances of that CAO each
time.
38. Remoting uses MarshallByRefObject,
what does this mean?
A reference
is returned to the remote object.
39. Write some code to
use reflection, remoting, threading, and thread
synchronization.
Threads and remoteable object:
using System;
using System.Reflection;
using System.Threading;
namespace Example
{
public class allThreads
{
const int NUMBER_OF_OPS = 10;
const int SLEEP_TIME = 2000;
private int threadNumber;
static int threadGlobalDS;
static object lockVariable = "dummy";
public allThreads(int threadNumber)
{
this.threadNumber = threadNumber;
}
// Thread with critical data access
section using lock and global object
public void threadMethod()
{
System.Console.WriteLine("Thread
" + threadNumber.ToString() + " starting
with Hashcode: " + Thread.CurrentThread.GetHashCode());
System.Console.WriteLine("------------------");
for (int i=1;i<=NUMBER_OF_OPS;i++)
{
System.Console.WriteLine("-->
Thread " + threadNumber.ToString() + "
performing operation " + i.ToString());
}
System.Console.WriteLine("-->
Thread " + threadNumber.ToString() + "
sleeping");
Thread.Sleep(SLEEP_TIME);
// Locking
using a global variable
lock(lockVariable)
{
System.Console.WriteLine("-->
Thread " + threadNumber.ToString() + " has
a lock");
// Access
critical data
threadGlobalDS = threadNumber;
System.Console.WriteLine("-->
Thread " + threadNumber.ToString() + "
sleeping");
Thread.Sleep(SLEEP_TIME);
}
System.Console.WriteLine("-->
Thread " + threadNumber.ToString() + "
sleeping");
Thread.Sleep(SLEEP_TIME);
}
}
// Producer and consumer example using
Monitor