http://www.programmersheaven.

com/2/dotnet-faq-general

What is Microsoft.NET platform?

Microsoft .NET is a software development platform based on virtual machine based

architecture. Dot net is designed from the scratch to support programming language
independent application development. The entire .NET programs are independent of any
particular operating system and physical hardware machine. They can run on any physical
machine, running any operating system that contains the implementation of .NET
Framework. The core component of the .NET framework is its Common Language Runtime
(CLR), which provides the abstraction of execution environment (Physical machine and
Operating System) and manages the overall execution of any of the .NET based program.

With dot NET, Microsoft introduces a completely new architecture for Windows applications
(WinForm), Data Access (ADO.NET), Web Applications (ASP.NET), Windows components
(Assemblies), Distributed Applications (.NET remoting), and above all the XML based Web
Services. The famous figure for the representation of dot net is presented below:
What is the .NET framework?

The .NET framework is a collection of all the tools and utilities required to execute the .NET
managed applications on a particular platform. The MS.NET framework includes the
standard compilers (C#, VB.NET, J#, C++.NET, Jscript.NET), various utilities like (caspol,
ngen, installutil, tlbimp, sn, asmreg, ildasm, etc), runtime environment (CLR), garbage
collector, security manager, thread manager, assembly loader, just in time compilers, and
the standard framework or base class libraries. It is important to realize that while the
implementation of .Net applications is platform independent; the implementation of .NET
framework is platform specific. In fact, it is this particular specific implementation of the
.NET framework that makes the managed .NET applications platform independent.

What is the VB.NET and C# language comparisons?

VB.NET and C# both are integral part of the .NET framework. Both of the languages have a
lot of similarities in language constructs and language design with minor differences in the
syntax. C# is more like C++ and Java in its syntax while VB.NET lends its syntax from VB6
a great deal; although VB.NET can not be seen as the successor of Visual Basic at the level
of overall language design and the vision of its creators.

The general conception is that most of the VB6 developers will upgrade to VB.NET while
developers coming from Java or C++ to .NET are likely to go for C#. Since web developers
for Windows using ASP are familiar with VB and
development with ASP.NET at the start is likely
sometime C# will be able to attract at least half of
away, C++ and thus C# developers are generally
So, this might also be the factor for making C# the
VB Scripts, therefore, most of the web
to be dominated by VB.NET; but after
these developers. Keeping technical side
paid more than those of VB developers.
language of choice on .NET framework.

What is the difference between Console, Windows, Web applications and

Web services?

Console applications are light weight programs run inside the command prompt (DOS)
window. They are commonly used for test applications. Windows Applications are form
based standard Windows desktop applications for common day to day tasks. Microsoft word
is an example of a Windows application.

Web applications are programs that used to run inside some web server (e.g., IIS) to fulfill
the user requests over the http. A typical example of web application is Hotmail and Google.

Web services are web applications that provide services to other applications over the
internet. Google search engine’s web service, e.g., allows other applications to delegate the
task of searching over the internet to Google web service and use the result produced by it
in their own applications.

What is meant by language interoperability and language integration?

Prior to the introduction of .Net, the code written in one programming language is
considered to be usable only in the programs written with the same programming
languages. For example, an algorithm implemented in Perl programming language can not
be reused in the programs written in the C++. At Windows platform, Microsoft introduced
the standards for COM (Component Object Model) which allows components written in one
programming language to be used in other programming language. In Java, JNI (Java
Native Interface) is presented to use-up the code written in non-Java languages into Java
programs. But both the standards (COM and JNI) are too complex and have their own
limitations. They also don’t allow the language integration, which means that you can use
the components written in other programming languages but you can’t extend the
functionality of the components.

In Microsoft.Net, the code written in any programming language is compiled to the same
Intermediate Language (Microsoft Intermediate Language - MSIL or Common Intermediate
Language – CIL) and to same component standard (assembly). Hence, it is possible for
developers to employ the language interoperability by using and extending the solution
implemented by other developers which might be using different programming language
provided developers at both end are using.Net compliant programming languages.

What is a .Net Assembly?

The .NET assembly is the standard for components developed with the Microsoft.NET. Dot
NET assemblies may or may not be executable, i.e., they might exist as the executable
(.exe) file or dynamic link library (DLL) file. All the .NET assemblies contain the definition of
types, versioning information for the type, meta-data, and manifest. The designers of .NET
have worked a lot on the component (assembly) resolution.
There are two kind of assemblies in .NET; private and shared. Private assemblies are simple
and copied with each calling assemblies in the calling assemblies folder. Shared assemblies
(also called strong named assemblies) are copied to a single location (usually the Global
assembly cache). For all calling assemblies within the same application, the same copy of
the shared assembly is used from its original location. Hence, shared assemblies are not
copied in the private folders of each calling assembly. Each shared assembly has a four part
name including its face name, version, public key token and culture information. The public
key token and version information makes it almost impossible for two different assemblies
with the same name or for two similar assemblies with different version to mix with each
other.

An assembly can be a single file or it may consist of the multiple files. In case of multi-file,
there is one master module containing the manifest while other assemblies exist as non-
manifest modules. A module in .NET is a sub part of a multi-file .NET assembly. Assembly is
one of the most interesting and extremely useful areas of .NET architecture along with
reflections and attributes, but unfortunately very few people take interest in learning such
theoretical looking topics.

What are the differences between a .NET Assembly, a Windows DLL and a
COM Component?

A Windows DLL contains library code to be used by any program running on Windows. A DLL
may contain either structured or object oriented libraries.

COM (Component Object Model) is the component model based on the object oriented
design, which means that the components represented by the COM component exists in the
form of classes and objects implementing a standard specification defined by COM. COM
components can be used by any program running on Windows Operating System; be it is
written with VB, C++, Java or even some .NET compliant language like C# and VB.NET.

Dot NET assembly is the component standard specified by the .NET. Hence, dot net
assemblies are understandable to only Microsoft.NET and can be used only in .NET managed
applications.

What does one need to build or execute .NET applications?

To execute a standalone .NET application (Windows or Console application), one needs to

first compile all its constituent assemblies and modules including the executable assembly.
Once, the constituent assemblies are compiled, one needs to make sure that the target
system contains the .NET framework. The application can now be executed by running its
executable assembly (the .exe file). The executable assembly (.exe) is a Win32 executable
that hosts the .Net CLR (Common Language Runtime), which exists as a COM component, in
its process space and initializes it. Once the CLR is hosted and initialized, the starting point
of the .NET executable assembly is passed to the hosted CLR which starts the execution of
the program by translating and executing the parts of the program code.

What does it mean by managed code?

By managed code, it means that the complete life cycle and execution is managed by the
.NET Common Language Runtime (CLR). The .NET CLR manages the memory on behalf of
the managed code, performs garbage collection on the managed heap, perform assembly
validation and assembly (component) resolution on behalf of the program. The CLR also
maintains the security constraints applied to the managed code.

What is meant by un-safe code?

By un-safe code, it means that the managed program can access the memory address using
pointers. There are two points to remember here;

• Un-safe code is different from un-managed as it is still managed by the CLR

• You still can not perform pointer arithmetic in un-safe code.

What is the difference between Unmanaged and Unsafe code?

Un-managed code runs outside the Common Language Runtime (CLR) control while the
unsafe code runs inside the CLR’s control. Both un-safe and un-managed codes may use
pointers and direct memory addresses.

What about the MS.NET standardization?

Microsoft has secured certification for both C# and CLI from ECMA and ISO/IEC as Industry
standards. This is a very important step for Microsoft and .Net platform because this
enhances the credibility of the newer .Net platform and allures a larger portion of
technology industry into adopting .Net as their development platform. Several companies
and government organizations only utilize ISO certified technologies; for example, in
Australia anything ISO certified is also considered Australian standard according to the rules
of the Australian government. Several academic institutions will now be interested in
teaching standard C#. Another major outcome of having an open industry standard
specification is .Net platform could be getting ported to other platforms like Linux and UNIX;
best example is the Mono Project by Ximian- it is an open source implementation of .Net
platform for UNIX and Linux based on ECMA approved Public Domain Specification of C#
and CLI.

Microsoft submitted the specifications to ECMA, which in turn fast-tracked them through
ISO. In doing so, Microsoft released all intellectual property in the core C#/CLI platform to
the public domain. No one needs a license to implement C#/CLI. This will also help
everybody in better understanding the implementations of C# and CLI which are at the core
of .Net platform. However, the whole of .Net platform is not a Public domain standard-
Microsoft still owns complete Intellectual property rights to several class libraries and API
within the .Net platform. See

ECMA- http://www.ecma.org

ISO- http://www.iso.ch

Mono Project- http://www.mono-project.com/about/index.html

.Net programming languages

More on ECMA and why Microsoft cares-

The Bill Gates letter to developers and IT Professionals also reveals the Microsoft’s Vision of
.NET

What about the implementation of .NET other than Microsoft.Net on

Windows Operating System?

Microsoft has implemented .NET framework for all of its operating system suits (excluding
MS Windows 95 and earlier) on all supported hardware platforms. For handheld and small
devices, Microsoft has released a compact framework of .NET
(http://msdn.microsoft.com/vstudio/device/compact.aspx ). But, there are various other
implementations being developed on platforms other than Microsoft Windows. You can read
the discussion on the portability of .NET at (See http://zdnet.com.com/2100-1107-
960049.html)

The most popular implementation, after MS.NET, is the open source ‘Mono’ Project on Linux
(See www.go-mono.com)

Microsoft has released almost all the source code of their .NET framework for FreeBSD and
Mac OS under the title of Shared Source Common Language Infrastructure (SSCLI). Check
out the SSCLI 1.0 release - which already builds on WindowsXP, FreeBSD, and Mac OS X
10.2, released under Microsoft's Shared Source Initiative.
http://msdn.microsoft.com/net/sscli/
http://www.microsoft.com/resources/sharedsource/default.mspx

See also DotGNU Portable.NET http://www.southern-storm.com.au/portable_net.html

Also Microsoft has opened the .NET code to academics. See

http://archive.infoworld.com/articles/hn/xml/02/03/27/020327hnshare.xml

What is the difference between traditional development and .NET

development?

In traditional programming languages, the source code of a program is compiled to a

specific platform’s assembly language and then machine language code. Later the library
code required by the program is linked to it. Finally the operating system executes the
program when desired by the user. The complete process is depicted in the following figure:
In the presence of dot net framework, a program is not compiled to the native machine
executable code; rather it gets compiled to an intermediate language code called Microsoft
Intermediate Language (MSIL) or Common Intermediate Language (CIL). The Dot Net
Common Language Runtime (CLR) then converts this intermediate code at runtime to the
machine executable code. The optimization is carried out at runtime. A program also does
not call the operating system APIs directly; rather it delegates this task to the CLR which
performs the desired operations on behalf of the program and returns the results of the
operations back to the program. The CLR also performs the memory management, garbage
collection, security and thread management on behalf of the program. Dot NET framework is
shipped with the supporting object oriented framework of common code libraries, called the
.NET Framework Class Library (FCL), to facilitate the common operations. Hence the .Net
manages the overall execution of an application. This is the reason why the code running on
.Net framework is sometimes called the managed code. The complete process is depicted in
the following Figure. Note that only the CLR (and thus the .Net framework and not the user
application) is interacting and coupled with the platform and operating system.
What are the basic components of .NET platform?

The basic components of .NET platform (framework) are:

Common Language Runtime (CLR):

The most important part of the .NET Framework is the .Net Common Language Runtime
(CLR) also called .Net Runtime in short. It is a framework layer that resides above the
Operating System and handles/manages the execution of the .NET applications. Our .Net
programs don’t directly communicate with the Operating System but through CLR

MSIL (Microsoft Intermediate Language) Code:

When we compile our .Net Program using any .Net compliant language like (C#, VB.NET,
C++.NET) it does not get converted into the executable binary code but to an intermediate
code, called MSIL or IL in short, understandable by CLR. MSIL is an OS and H/w
independent code. When the program needs to be executed, this MSIL or intermediate code
is converted to binary executable code, called native code. The presence of IL makes it
possible the Cross Language Relationship as all the .Net compliant languages produce the
similar standard IL code.

Just In Time Compilers (JITers)

When our IL compiled code needs to be executed, CLR invokes JIT compilers which compile
the IL code to native executable code (.exe or .dll) for the specific machine and OS. JITers in
many ways are different from traditional compilers as they, as their name suggests, compile
the IL to native code only when desired e.g., when a function is called, IL of function’s body
is converted to native code; just in time of need. So, the part of code that is not used by
particular run is not converted to native code. If some IL code is converted to native code
then the next time when its needed to be used, the CLR uses the same copy without re-
compiling. So, if a program runs for sometime, then it won’t have any just in time
performance penalty. As JITers are aware of processor and OS exactly at runtime, they can
optimize the code extremely efficiently resulting in very robust applications. Also, since JITer
knows the exact current state of executable code, they can also optimize the code by in-
lining small function calls (like replacing body of small function when its called in a loop,
saving the function call time). Although, Microsoft stated that C# and .Net are not
competing with languages like C++ in efficiency, speed of execution, JITers can make your
code even faster than C++ code in some cases when program is run over extended period
of time (like web-servers).

Framework Class Library (FCL)

.NET Framework provides huge set of Framework (or Base) Class Library (FCL) for common,
usual tasks. FCL contains thousands of classes to provide the access to Windows API and
common functions like String Manipulation, Common Data Structures, IO, Streams,
Threads, Security, Network Programming, Windows Programming, Web Programming, Data
Access, etc. It is simply the largest standard library ever shipped with any development
environment or programming language. The best part of this library is they follow extremely
efficient OO design (design patterns) making their access and use very simple and
predictable. You can use the classes in FCL in your program just as you use any other class
and can even apply inheritance and polymorphism on these.

Common Language Specification (CLS)

Earlier we used the term ‘.NET Compliant Language’ and stated that all the .NET compliant
languages can make use of CLR and FCL. But what makes a language ‘.NET compliant
language’? The answer is Common Language Specification (CLS). Microsoft has released a
small set of specification that each language should meet to qualify as a .NET Compliant
Language. As IL is a very rich language, it is not necessary for a language to implement all
the IL functionality, rather it meets the small subset of it, CLS, to qualify as a .NET
compliant language, which is the reason why so many languages (procedural and OO) are
now running under .Net umbrella. CLS basically addresses to language design issues and
lays certain standards like there should be no global function declaration, no pointers, no
multiple inheritance and things like that. The important point to note here is that if you keep
your code within CLS boundary, your code is guaranteed to be usable in any other .Net
language.

Common Type System (CTS)

.NET also defines a Common Type System (CTS). Like CLS, CTS is also a set of standards.
CTS defines the basic data types that IL understands. Each .NET compliant language should
map its data types to these standard data types. This makes it possible for the 2 languages
to communicate with each other by passing/receiving parameters to/from each other. For
example, CTS defines a type Int32, an integral data type of 32 bits (4 bytes) which is
mapped by C# through int and VB.Net through its Integer data type.

Garbage Collector (GC)

CLR also contains Garbage Collector (GC) which runs in a low-priority thread and checks for
un-referenced dynamically allocated memory space. If it finds some data that is no more
referenced by any variable/reference, it re-claims it and returns the occupied memory back
to the Operating System; so that it can be used by other programs as necessary. The
presence of standard Garbage Collector frees the programmer from keeping track of
dangling data.

What is the software development and execution flow in Microsoft.NET?

With .NET development environment, a developer can write his/her code in any .NET
compliant programming language like C#, VB.NET, J#, C++.NET, etc. In fact, various
modules, components, projects of an application can be written and compiled in different
.Net based programming languages. All these components are compiled to the same
Intermediate language code (MSIL or CIL) understandable by the .NET CLR.
At runtime, the .NET assembly (compiled IL code) is translated to native machine code and
executed by the CLR.

How is MS.NET compared with Java based platforms (J2EE)?

At root level architecture and components, MS.NET and J2EE platforms are very similar.
Both are virtual machine based architecture having CLR and Java Virtual Machine (JVM) as
the underlying virtual machine for the management and execution of programs. Both
provide memory, security and thread management on behalf of the program and both try to
decouple the applications with the execution environment (OS and physical machine). Both,
basically, target the Web based applications and especially the XML based web services.
Both provide managed access to memory and no direct access to memory is allowed to their
managed applications.

However, there are few contrasts in the architecture and design of the two virtual machines.
Microsoft .NET framework’s architecture is more coupled to the Microsoft Windows Operating
System which makes it difficult to implement it on various operating systems and physical
machines. Java, on the other hand, is available on almost all major platforms. At the darker
side, J2EE architecture and JVM is more coupled to the Java programming language while
Microsoft.NET has been designed from the scratch to support language independence and
language integration. Microsoft.NET covers the component development and integration in
much more detail than Java. The versioning policy of .NET is simply the best implemented
versioning solution in the software development history. Java has got the support of
industry giants like Sun, IBM, Apache and Oracle while the Microsoft.NET is supported by
giants like Microsoft, Intel, and HP.
Why should one use MS.NET for software development?

Well, most of the software development all over the world is done on and for Microsoft
Windows Operating System. Dot Net is now the standard software development
environment for the Microsoft Windows operating system. It dramatically simplifies the
development of windows, web based, data access applications, components, controls and
web services. Dot net comes with amazing features like XML configuration, reflection, and
attributes to ease the overall software development life cycle. Finally, the dot net is
supported by the Microsoft Visual Studio Integrated Development Environment; the best
IDE available for any software development environment. Visual Studio .NET (VS.NET)
supports all the areas of software development from project creation to debugging and
installation.

What are the shortcomings of MS.NET platform?

The foremost short coming of .NET platform is that it is still the propriety of Microsoft. It is
more coupled with the Microsoft Windows operating system and is implemented only on
Microsoft Windows successfully. MS.NET desktop applications can run only on Microsoft
Windows, Web based applications and web services can only be deployed on Microsoft
Internet Information Server (IIS). Since, dot net framework contains a lot of utilities,
components, and framework class libraries, the size of downloadable framework is quite
large (25MB compared to 5MB size of JVM). Not all types of applications can be written in
.NET managed applications, for example, you can’t write CLR or Operating System in your
managed applications. The managed .Net applications are somewhat slower to start and run
than the traditional Win32 applications. The compiled code of .Net managed applications is
easier to de-compile back to the source code.

How true it is that .NET and Java programs are quite in-efficient when
compared to C++?

The startup of managed .NET and Java programs is definitely slower than the traditional
C++ programs as it involves the hosting of CLR into managed application process in .NET
and starting the JVM in a new process in case of Java. The execution also is a bit slower
during the initial period of program execution as the intermediate code is translated to the
machine code on the fly at runtime. But as the program runs various parts repeatedly, the
execution gets pace too. Since, the CLR and JVM optimizes the code more efficiently than
the static C++ compilers, the execution speed of the program may actually be faster after
sometime of the program startup when most of the code is translated. Hence, in the longer
run, the .Net and Java based programs should not be in-efficient when compared to C++.
We used ‘should’ here as the actual performance depends on the particular implementation
and implementation strategy.

What are XML Doc comments (comments start with three slashes ///)?

The XML Doc comments are special kind of comments that can be recognized by Document
utility to automatically generate the documentation of your methods, types and regions.

Using COM components in .NET and How to add a reference to a COM

component?
The .NET does not encourage the use of COM component directly inside the managed
application! Although, the .NET framework contains utilities that enable COM components to
be used inside the .Net applications seamlessly. How it is done? The .NET utilities like
TlbImp generates the wrapper .NET assembly for the COM component which provides the
same calling interface to the client as exposed by the COM component. Inside the wrapper
methods, it calls the actual methods of the COM component and returns the result back to
the caller. The generated wrapper .NET assembly is called the ‘Runtime Callable Wrapper’ or
RCW.

To use a COM component in your Visual Studio.NET project, you need to add a reference of
the COM component in the Reference node of the project node of the solution inside the
solution explorer window. The great thing about Visual Studio.Net is that it allows you to
add a reference to the COM component in exactly the similar way as you add the reference
to the .NET assembly. The Visual Studio.NET automatically creates the runtime callable
wrapper assembly for the referenced COM component.

To add a reference to a COM component, right click the ‘Reference’ node under the project
node inside the solution explorer and select the ‘Add Reference…’ option. It will show you a
user interface screen where you browse for the target COM component. When you have
selected the component, press the ‘Select’ button and then press OK. This will add a new
reference node in the Reference sub tree of the project. By selecting the added reference
node, you can edit its properties from the properties window.

Note: The process of importing a COM component into .NET is called ‘COM interoperability
with .NET’

What is .NET Framework and what are CLR, CTS and CLS?

. NET is a software platform. It's a language-neutral environment for developing .NET

applications that can easily and securely operate within it.

The .NET Framework has two main components: the Common Language Runtime (CLR) and
the .NET Framework class library.

The Runtime can be considered an agent that manages code at execution time. Thus
providing core services such as memory management, thread management, and remoting.
Also incorporating strict type safety, security and robustness.

The class library is a comprehensive collection of reusable types that you can use to develop
traditional command-line, WinForm (graphical user interface) applications, Web Forms and
XML Web services.

The .NET Framework provides a Runtime environment called the Common Language
Runtime or (CLR) that handles the execution of the code and provides useful services for the
implementation of the application. CLR takes care of code management upon program
execution and provides various services such as memory management, thread
management, security management and other system services. The managed code targets
CLR benefits by using useful features such as cross-language integration, cross-language
exception handling, versioning, enhanced security, deployment support, and debugging.
Common Type System (CTS) describes how types are declared, used and managed. CTS
facilitates cross-language integration, type safety, and high performance code execution.
The CLS is a specification that defines the rules to support language integration. This is
done in such a way, that programs written in any language (.NET compliant) can
interoperate with one another. This also can take full advantage of inheritance,
polymorphism, exceptions, and other features.

Written by Sandeep Mogulla, Webmaster at www.startvbdotnet.com

What is MSIL / IL? What is JIT (Just In Time)?

When compiling the source code to managed code, the compiler translates the source into
Microsoft intermediate language (MSIL). This is a CPU-independent set of instructions that
can efficiently be converted to native code. Microsoft intermediate language (MSIL) is a
translation used as the output of a number of compilers. It is the input to a just-in-time
(JIT) compiler. The Common Language Runtime includes a JIT compiler for the conversion of
MSIL to native code.

Before Microsoft Intermediate Language (MSIL) can be executed it, must be converted by
the .NET Framework just-in-time (JIT) compiler to native code. This is CPU-specific code
that runs on the same computer architecture as the JIT compiler. Rather than using time
and memory to convert all of the MSIL in a portable executable (PE) file to native code. It
converts the MSIL as needed whilst executing, then caches the resulting native code so its
accessible for any subsequent calls.

Written by Sandeep Mogulla, Webmaster at www.startvbdotnet.com

What is Code Access Security (CAS)? How does CAS work?

Who defines the CAS code groups?

Code Access Security (CAS) is part of the .NET security model. CAS determines whether or
not a piece of code is allowed to run and also what resources to use. For example, CAS will
prevent malicious code from entering your system and causing havoc.

The CAS security policy revolves around two key concepts - code groups and permissions.
Each .NET assembly is a member of a particular code group and each code group is granted
the permissions specified in a named permission set. An example: Using the default security
policy, a control downloaded from a web site belongs to the 'Zone - Internet' code group
which complies to the permissions defined by the 'Internet' named permission set.

Microsoft defines some default policies but you can modify these and even create your own.
To view the code groups defined on your system; Run 'caspol' from the command-line and
checkout the different options on display.

Written by Sandeep Mogulla, Webmaster at www.startvbdotnet.com

What is serialization in .NET and what are the ways to
control serialization?

Serialization is the process of converting an object into a stream of bytes. On the other
hand Deserialization is the process of creating an object from a stream of bytes.
Serialization/Deserialization is used to transport or to persist objects. Serialization can be
defined as the process of storing the state of an object to a storage medium. During this
process, the public and private fields of the object and the name of the class, including the
assembly are converted to a stream of bytes. Which is then written to a data stream. Upon
the object's subsequent deserialized, an exact clone of the original object is created.

Binary serialization preserves Type fidelity, which is useful for preserving the state of an
object between different invocations of an application. For example: An object can be
shared between different applications by serializing it to the clipboard.

You can serialize an object to a stream, disk, memory, over a network, and so forth.
Remoting uses serialization to pass objects "By Value" from one computer or application
domain to another. XML serialization serializes only public properties and fields and does not
preserve Type fidelity. This is useful when you want to provide or consume data without
restricting the application that uses the data.

As XML is an open standard, it is an attractive choice for sharing data across the Web. SOAP
is also an open standard, which makes it an attractive choice too. There are two separate
mechanisms provided by the .NET class library - XmlSerializer and
SoapFormatter/BinaryFormatter. Microsoft uses XmlSerializer for Web Services, and
uses SoapFormatter/BinaryFormatter for remoting. Both are available for use in your
own code.

Written by Sandeep Mogulla, Webmaster at www.startvbdotnet.com

What is Active Directory? What namespace should I use to

use Active Directories?

Active Directory Service Interfaces (ADSI) is a programmatic interface for the Microsoft
Windows Active Directory. It enables your applications to interact with different directories
on a network using a single interface.

Visual Studio .NET and the .NET Framework make it easy to add ADSI functionality with the
DirectoryEntry and DirectorySearcher components. Using ADSI you can create
applications that perform common administrative tasks, such as backing up databases,
accessing printers and managing user accounts. ADSI allows:

1) Log on once to work with diverse directories. The DirectoryEntry component class
provides username and password properties that can be entered at Runtime and are passed
to the Active Directory object you are bound to.

2) Use of an Application-Programming Interface (API) to perform tasks on multiple directory

systems. This includes multi protocol support. The DirectoryServices namespace provides
the classes to perform most administrative functions such as creating users.
3) Perform "Rich Querying" on directory systems. ADSI technology supports searching for
objects with two query dialects: SQL and LDAP.

4) Access and use a single or hierarchical tree structure for administering and maintaining a
diverse and complicated network.

5) Integrate directory information with databases such as ?SQL Server. The

DirectoryEntry path may be used as an ADO.NET connection string.

Name space to be imported when working with Active Directories:

System.DirectoryServices

Written by Sandeep Mogulla, Webmaster at www.startvbdotnet.com

Can I use the Win32 API from a .NET Framework program?

Using platform invoke it's possible. .NET Framework programs can access native code
libraries by means of static DLL entry points.

Here is an example of C# calling the Win32 MessageBox function:

using System;
using System.Runtime.InteropServices;

class MainApp
{
[DllImport("user32.dll", EntryPoint="MessageBox")]
public static extern int MessageBox(int hWnd, String

strMessage, String strCaption, uint uiType);

public static void Main()

MessageBox(0, "This is PInvoke in operation!",

".NET", 0 );

Written by Sandeep Mogulla, Webmaster at www.startvbdotnet.com

How do I send an attachment in an email?

The following code shows how to add an attachment to an email.

Using System.IO;
Using System.Web.Mail;

MailAttachment ma=new MailAttachment("c:\sample.txt");

MailMessage mm=new MailMessage();
mm.To ="xyz@programmersheaven.com";
mm.From="abc@yahoo.com";
mm.Body ="Attachment";
mm.Subject="Check out the attached text file";

mm.Attachments.Add(ma);

SmtpMail.SmtpServer="mail.programmersheaven.com";
SmtpMail.Send(mm);

Written by Sandeep Mogulla, Webmaster at www.startvbdotnet.com