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
public class monitorThreads
{
const int SLEEP_TIME = 2000;
const int MAX_PRODUCED = 5;
private static int threadGlobalDS = 0;
private static int bufferCount = 1;
private static bool producing = true;
private static bool consuming = true;
public void
monitorMethod1()
{
// Producer...
while(producing)
{
// Synch using
monitor
/* Attempt to
get an exclusive lock on this object
* Block otherwise */
Monitor.Enter(this);
if(bufferCount == 1)
{
/* Release the
lock on this object and block
* the current thread until it reacquires
the lock. */
Monitor.Wait(this);
}
threadGlobalDS +=1;
++bufferCount;
if (threadGlobalDS == MAX_PRODUCED)
{
producing
= false;
}
/* Notify a thread in the waiting
* queue of a change
in the locked object's state (this object). */
Monitor.Pulse(this);
// Releases the exclusive
lock on this object.
Monitor.Exit(this);
System.Console.WriteLine("-->
Producer sleeping");
Thread.Sleep(SLEEP_TIME);
}
}
public void
monitorMethod2()
{
while(consuming)
{
// Consumer...
// Synch using
monitor
Monitor.Enter(this);
if(bufferCount == 0)
{
Monitor.Wait(this);
}
--bufferCount;
System.Console.WriteLine("-->
Consumed " + threadGlobalDS.ToString());
Monitor.Pulse(this);
Monitor.Exit(this);
if
(!producing)
{
consuming
= false;
}
}
}
}
// Class to be remoted
public class RemotingLoader : System.MarshalByRefObject
{
public RemotingLoader()
{
System.Console.WriteLine("New
Client Added");
}
public SomeMetadata GetSomeMetadata(decimal userID)
{
// Create
objects to thread
allThreads threadObj1 = new allThreads(1);
allThreads threadObj2 = new allThreads(2);
allThreads threadObj3 = new allThreads(3);
// Instanciate
and spin off some of threads
Thread thread1 = new Thread(new ThreadStart(threadObj1.threadMethod));
Thread thread2 = new Thread(new ThreadStart(threadObj2.threadMethod));
Thread thread3 = new Thread(new ThreadStart(threadObj3.threadMethod));
thread1.Start();
thread2.Start();
thread3.Start();
// Show that thread1 is alive
if
(thread1.IsAlive)
{
System.Console.WriteLine("*->
Thread 1 is alive");
}
// Abort thread1 and check again
thread1.Abort();
if
(!thread1.IsAlive)
{
System.Console.WriteLine("*->
Thread 1 is dead");
}
// Monitor example
monitorThreads monitorObj =
new monitorThreads();
// Instanciate
and spin off some of threads
Thread monitorThread1 = new Thread(new ThreadStart(monitorObj.monitorMethod1));
Thread monitorThread2 = new Thread(new ThreadStart(monitorObj.monitorMethod2));
monitorThread1.Start();
monitorThread2.Start();
monitorThread1.Join();
monitorThread2.Join();
thread1.Join();
thread2.Join();
thread3.Join();
System.Console.WriteLine("*->
Finished");
return new SomeMetadata(1);
}
}
// Class to be serialized
[Serializable]
public class SomeMetadata
{
public Type objectType;
public ConstructorInfo [] info;
public MethodInfo [] methods;
private string objectName;
decimal remoteObjectID;
public SomeMetadata(decimal remoteObjectID)
{
objectType = this.GetType();
info
= objectType.GetConstructors();
methods
= objectType.GetMethods();
this.remoteObjectID = remoteObjectID;
}
public String
Name
{
get { return objectName; }
set
{ this.objectName = value; }
}
}
}
Server
using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
namespace Example
{
public class RemotingServer
{
public static void
{
// Register Channel
TcpServerChannel
channel = new TcpServerChannel(9000);
ChannelServices.RegisterChannel(channel);
// Register Service Type
RemotingConfiguration.RegisterWellKnownServiceType(typeof(RemotingLoader),
"RemotingLoader", WellKnownObjectMode.SingleCall);
// Wait
System.Console.WriteLine("Press
Any Key To Kill The Server");
System.Console.ReadLine();
}
}
}
Client
using System;
using System.Reflection;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
namespace Example
{
public class RemotingClient
{
public static void
{
// Register channel and point to
remote object
ChannelServices.RegisterChannel(new TcpClientChannel());
RemotingLoader
loader = (RemotingLoader)Activator.GetObject(
typeof(RemotingLoader),
"tcp://chillers.webhost4lifemysql.com:9000/RemotingLoader");
// Get a reference to the remote
object
SomeMetadata
objReference = loader.GetSomeMetadata(1);
// Display data from object
Console.WriteLine("");
Console.WriteLine("*---
Object Type ---*");
Console.WriteLine("");
Console.WriteLine(objReference.objectType);
Console.WriteLine("");
Console.WriteLine("*---
Constructor Info. ---*");
Console.WriteLine("");
foreach(ConstructorInfo consInfo
in objReference.info)
{
Console.WriteLine(consInfo);
}
Console.WriteLine("");
Console.WriteLine("*---
Method Info. ---*");
Console.WriteLine("");
foreach(MethodInfo methodInfo
in objReference.methods)
{
Console.WriteLine(methodInfo);
}
Console.WriteLine("");
Console.WriteLine("*---
Setting and getting a Remote Variable. ---*");
Console.WriteLine("");
objReference.Name
= "Test Name";
Console.WriteLine(objReference.Name);
// Wait...
Console.ReadLine();
}
}
}
These next questions and
answers are taken from:
http://blog.daveranck.com/archive/2005/01/20/355.aspx
Misc
1. Can you prevent your
class from being inherited by another class?
Yes. The keyword
“sealed” will prevent the class from being inherited.
2. Explain the three tier or n-Tier model.
Presentation (UI),
business (logic and underlying code) and data (from storage or other sources).
3. What is SOA?
Service Oriented
Architecture. In SOA you create an abstract layer that your applications use to
access various "services" and can aggregate the services. These
services could be databases, web services, message queues or other sources. The
Service Layer provides a way to access these services that the applications do
not need to know how the access is done. For example, to get a full customer
record, I might need to get data from a SGL Server database, a web service and
a message queue. The Service layer hides this from the calling application. All
the application knows is that it asked for a full customer record. It doesn't
know what system or systems it came from or how it was retrieved.
4. Is XML case-sensitive?
Yes
5. Can you explain some
differences between an ADO.NET Dataset and an
A DataSet
can represent an entire relational database in memory, complete with tables,
relations, and views. A DataSet is designed to
work without any continuing connection to the original data source. Data
in a DataSet is bulk-loaded, rather than being loaded
on demand. There's no concept of cursor types in a DataSet.
DataSets have no current record pointer You can use For Each loops to move through the data.
You can store many edits in a DataSet, and write them
to the original data source in a single operation. Though the DataSet is universal, other objects in ADO.NET come in
different versions for different data sources.
ASP.NET
1. Explain the differences
between Server-side and Client-side code?
Server-side
code executes on the server. Client-side code executes in the context of the
clients' browser.
2. What does the "EnableViewState" property do? Why would I want it on
or off?
It allows
page objects to save their state in a Base64 encoded string in the page HTML.
One should only have it enabled when needed because it adds to the page size
and can get fairly large for complex pages with many controls. (It takes longer
to download the page).
3. What is the difference
between Server.Transfer and Response.Redirect?
Why would I choose one over the other?
Server.Transfer transfers excution directly to another page. Response.Redirect sends a response to the client and
directs the client (the browser) to load the new page (it causes a roundtrip).
If you don't need to execute code on the client, Transfer is more efficient.
4. What base class do all
Web Forms inherit from?
The Page
class (System.Web.UI.Page).
5. What does WSDL stand for?
What does it do?
(Web Services Description Language). It describes the interfaces and
other information of a web service.
6. Which WebForm
Validator control would you use if you needed to make
sure the values in two different WebForm controls
matched?
CompareValidator Control.
7. What property must you
set, and what method must you call in your code, in order to bind the data from
some data source to the Repeater control?
You must set the DataSource property and call the DataBind
method.
These next questions and
answers are taken from:
http://www.techinterviews.com/?p=153
1. What is a satellite
Assembly?
An assembly containing localized resources for another assembly.
2. In Object Oriented
Programming, how would you describe encapsulation?
The
separation of interface and implementation.
* Encapsulation describes the ability of an object to
hide its data and methods from the rest of the world. (Google
web definitions).
These
next questions and answers are taken from:
http://blogs.wwwcoder.com/tsvmadhav/archive/2005/04/08/2882.aspx
1. Can you store multiple
data types in System.Array?
No.
2. What’s the difference
between the System.Array.CopyTo() and System.Array.Clone()?
The first
one performs a deep copy of the array, the second one is shallow. A
shallow copy of an Array
copies only the elements of the Array, whether they are reference types
or value types, but it does not copy the objects that the references refer
to. The references in the new Array point to the same objects that
the references in the original Array point to. In contrast, a deep
copy of an Array copies the elements and everything directly or
indirectly referenced by the elements.
3. How can you sort the
elements of the array in descending order?
By calling Sort() and then Reverse() methods.
4. What’s the .NET
collection class that allows an element to be accessed using a unique key?
HashTable.
5. What class is underneath
the SortedList class?
A sorted HashTable.
6. Will the finally block
get executed if an exception has not occurred?
Yes
7. Can you prevent your
class from being inherited by another class?
Yes.
The keyword “sealed” will prevent the class from being inherited
8. If a base class has a
number of overloaded constructors, and an inheriting class has a number of
overloaded constructors; can you enforce a call from an inherited constructor
to a specific base constructor?
Yes, just place
a colon, and then keyword base (parameter list to invoke the appropriate
constructor) in the overloaded constructor definition inside the inherited
class.
9. What’s a multicast
delegate?
(See the first set of answers)
10. What’s the difference
between // comments, /* */ comments and /// comments?
Single-line
comments, multi-line comments, and XML documentation comments.
11. How do you generate
documentation from the C# file commented properly with a command-line compiler?
Compile it
with the /doc switch.
12. What debugging tools come
with the .NET SDK?
.CorDBG – command-line debugger. To use CorDbg,
you must compile the original C# file using the /debug switch. DbgCLR – graphic
debugger. Visual Studio .NET uses the DbgCLR.
13. What does assert() method do?
In debug
compilation, assert takes in a Boolean condition as a parameter, and shows the
error dialog if the condition is false. The program proceeds without any
interruption if the condition is true.
14. What’s the difference
between the Debug class and Trace class?
Use Debug
class for debug builds, use Trace class for both debug and release
builds.
15. Why are there five
tracing levels in System.Diagnostics.TraceSwitcher?
The tracing
dumps can be quite verbose. For applications that are constantly running
you run the risk of overloading the machine and the hard drive. Five
levels range from None to Verbose, allowing you to
fine-tune the tracing activities.
16. Where is the output of TextWriterTraceListener redirected?
To the
Console or a text file depending on the parameter passed to the
constructor.
17. How do you debug an
ASP.NET Web application?
Attach the
aspnet_wp.exe process to the DbgClr debugger.
18. What are three test cases
you should go through in unit testing?
1.
Positive test cases (correct data, correct output).
2. Negative test cases (broken or missing
data, proper handling).
3. Exception test cases (exceptions are
thrown and caught properly).
19. Can you change the value
of a variable while debugging a C# application?
Yes.
If you are debugging via Visual Studio.NET, just go to Immediate
window.
20. What are advantages and
disadvantages of Microsoft-provided data provider classes in ADO.NET?
SQLServer.NET
data provider is high-speed and robust, but requires SQL Server license
purchased from Microsoft. OLE-DB.NET is universal for accessing other sources,
like Oracle, DB2, Microsoft Access and Informix. OLE-DB.NET is a .NET
layer on top of the OLE layer, so it’s not as fastest and efficient as
SqlServer.NET.
21. What is the wildcard
character in SQL?
Let’s say
you want to query database with LIKE for all employees whose name starts with
22. Explain ACID rule of
thumb for transactions.
A transaction must be:
1. Atomic - it is one unit of work and does
not dependent on previous and following transactions.
2. Consistent - data is either committed or
roll back, no “in-between” case where something has been updated and something
hasn’t.
3. Isolated - no transaction sees the
intermediate results of the current transaction).
4. Durable - the values persist if the data
had been committed even if the system crashes right after.
23. Between Windows
Authentication and SQL Server Authentication, which one is trusted and which
one is untrusted?
Windows
Authentication is trusted because the username and password are checked with
the Active Directory, the SQL Server authentication is
untrusted, since SQL Server is the only verifier
participating in the transaction.
24. What are the ways to
deploy an assembly?
An MSI
installer, a CAB archive, and XCOPY command.
25. What namespaces are
necessary to create a localized application?
System.Globalization and System.Resources.
26. What is the smallest unit
of execution in .NET?
An Assembly.