Csharp Outing

Create TextBox Control with Watermark in C# Winform

2012-05-18T14:35:00.001-07:00

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.ComponentModel;
using System.Drawing;

namespace IFY.Controls
{
    [ToolboxItem(true)]
    [ToolboxBitmap(typeof(TextBox), "TextBox")]
    public class HtTextBox : TextBox
    {
        #region Fields
        private string m_waterMark;
        private InputType m_inputType;
        private InputStyle m_textStyle;
        private bool m_isWaterMarkMode;
        private Font m_currentFont;
        private Font m_waterMarkFont;
        private Color m_currentForeColor;
        private Color m_waterMarkForeColor;
        public MethodInvoker OnEnterPress;
        private bool m_isSystemKeys;
        private bool m_isNumberKeys;
        private bool  m_isAlphaKeys;
        private bool m_isSymbolKeys;
        #endregion

        #region Constructor
        public HtTextBox()
        {
            m_waterMark = string.Empty;
            m_isWaterMarkMode = false;
            m_inputType = IFY.Controls.InputType.None;
            m_textStyle = InputStyle.None;
            m_currentFont = base.Font;
            m_waterMarkFont = new Font(base.Font, FontStyle.Italic);
            m_currentForeColor = base.ForeColor;
            m_waterMarkForeColor = Color.DarkGray;
        }
        #endregion

        #region Properties
        [EditorBrowsable(EditorBrowsableState.Always)]
        [Browsable(true), Description("WaterMark Text")]
        public string WaterMark
        {
            get { return m_waterMark; }
            set { m_waterMark = value; }
        }

        [EditorBrowsable(EditorBrowsableState.Advanced)]
        [Browsable(true), Description("WaterMark Text Color")]
        public Color WaterMarkForeColor
        {
            get { return m_waterMarkForeColor; }
            set { m_waterMarkForeColor = value; }
        }

        [EditorBrowsable(EditorBrowsableState.Always)]
        [Browsable(true), Description("Type that can be enter in TextBox Control")]
        public InputType InputType
        {
            get { return m_inputType; }
            set { m_inputType = value; }
        }

        [EditorBrowsable(EditorBrowsableState.Always)]
        [Browsable(true), Description("UperCase or LowerCase")]
        public InputStyle TextStyle
        {
            get { return m_textStyle; }
            set { m_textStyle = value; }
        }
        #endregion

        #region Methods
        protected override void OnCreateControl()
        {
            base.OnCreateControl();
            m_isWaterMarkMode = (m_waterMark != string.Empty);
            this.SetWaterMarkMode();
            if (m_isWaterMarkMode)
            {
                this.Text = m_waterMark;
            }
        }
        protected override void OnKeyPress(KeyPressEventArgs e)
        {
            base.OnKeyPress(e);
            if ((int)e.KeyChar == 13)
            {
                if (this.OnEnterPress != null)
                {
                    this.OnEnterPress();
                }
                return;
            }
            m_isSystemKeys = ((int)e.KeyChar == 8 || (int)e.KeyChar == 46

                          || (int)e.KeyChar == 9 || (int)e.KeyChar == 32);
            if (m_isSystemKeys) return;
            m_isNumberKeys = ((int)e.KeyChar >= 48 && (int)e.KeyChar <= 57);
            m_isAlphaKeys = (((int)e.KeyChar >= 65 && (int)e.KeyChar <= 90)

                          || ((int)e.KeyChar >= 97 && (int)e.KeyChar <= 122));
            m_isSymbolKeys = ((int)e.KeyChar >= 33 && (int)e.KeyChar <= 47);
            if (m_inputType == IFY.Controls.InputType.Number)
            {
                if (!m_isNumberKeys)
                {
                    e.Handled = true;
                    return;
                }
            }
            else if (m_inputType == IFY.Controls.InputType.Alphabetics)
            {
                if (!m_isAlphaKeys)
                {
                    e.Handled = true;
                    return;
                }
            }
            else if (m_inputType == IFY.Controls.InputType.AlphaSymbol)
            {
                if (!m_isAlphaKeys && !m_isSystemKeys)
                {
                    e.Handled = true;
                    return;
                }
            }
            else if (m_inputType == IFY.Controls.InputType.AlphaNumeric)
            {
                if (!m_isAlphaKeys && !m_isNumberKeys)
                {
                    e.Handled = true;
                    return;
                }
            }
            else if (m_inputType == IFY.Controls.InputType.AlphaNumericSymbol)
            {
                if (!m_isAlphaKeys && !m_isNumberKeys && !m_isSymbolKeys)
                {
                    e.Handled = true;
                    return;
                }
            }
            if ((m_textStyle != InputStyle.None))
            {
                if (m_textStyle == InputStyle.LowerCase)
                {
                    e.KeyChar = char.ToLower(e.KeyChar);
                }
                else if (m_textStyle == InputStyle.UpperCase)
                {
                    e.KeyChar = char.ToUpper(e.KeyChar);
                }
            }
        }
        protected override void OnKeyDown(KeyEventArgs e)
        {
            base.OnKeyDown(e);
            if (m_waterMark.Length > 0)
            {
                if (this.Text == m_waterMark)
                {
                    this.Text = string.Empty;
                }
            }
        }
        protected override void OnKeyUp(KeyEventArgs e)
        {
            base.OnKeyUp(e);
            if (m_waterMark.Length > 0)
            {
                if (this.Text == string.Empty || this.Text == m_waterMark) 
                {
                    if (!m_isWaterMarkMode)
                    {
                        m_isWaterMarkMode = true;
                        this.SetWaterMarkMode();
                    }
                    if (this.Text != m_waterMark)
                    {
                        base.Text = m_waterMark;
                    }
                }
                else
                {
                    if (m_isWaterMarkMode)
                    {
                        m_isWaterMarkMode = false;
                        this.SetWaterMarkMode();
                    }
                    if (this.Text.Contains(m_waterMark))
                    {
                        this.Text = this.Text.Replace(m_waterMark, string.Empty);
                    }
                }
            }
        }
        protected override void OnEnter(EventArgs e)
        {
            base.OnEnter(e);
            if (m_isWaterMarkMode)
            {
                if (this.Text == m_waterMark)
                {
                    this.Text = string.Empty;
                }
            }
        }
        protected override void OnLeave(EventArgs e)
        {
            base.OnLeave(e);
            if (m_isWaterMarkMode)
            {
                if (this.Text.Trim() == string.Empty)
                {
                    this.Text = m_waterMark;
                }
            }
        }
        #endregion

        #region Private Methods
        private void SetWaterMarkMode()
        {
            if (m_isWaterMarkMode && this.Font != m_waterMarkFont)
            {
                this.Font = m_waterMarkFont;
                this.ForeColor = m_waterMarkForeColor;
            }
            else if(this.Font != m_currentFont)
            {
                this.Font = m_currentFont;
                this.ForeColor = m_currentForeColor;
            }
        }
        #endregion
    }

    public enum InputType
    {
        None = 0,
        Number = 1,
        Alphabetics = 2,
        AlphaSymbol = 3,
        AlphaNumeric = 4,
        AlphaNumericSymbol = 5,
        Custom = 6
    }

    public enum InputStyle
    {
        None = 0,
        UpperCase = 1,
        LowerCase = 2
    }
}

CTS - CLS - BCL

2011-05-25T21:54:00.000-07:00

CTS

The .Net is platform independent by the means of CLS and CTS. Common Type System is the system which enables the all languages to work with each other by the way of data type. All language has a different structure to declare a data type, for example in c++ integer variable occupied 2 bytes where as in Java its occupied 4 byte. This dependency of data type is removed by the .Net, if you working with the .Net than you don’t worry about the how a data type declared in one language needs to be declared in another, the .net managed this all thing with some specific type that declared in .Net Framework. Any .NET type has the same attributes regardless of the language it is used in. In short all .NET data types are objects, derived from Object class which is reside in System namespace. There are two type of data type in .Net Framework, Predefined data type and reference type data type. Predefined data types are available in IL, so that all languages that target the .NET Framework will produce compiled code that is ultimately based on these types.

CLS

The Common Language Specification (CLS) is one important part of .Net Framework. The CLS is an open specification developed by Microsoft that describes the executable code and runtime environment. As you know the CLR will first compile any set of code in IL. Here, the use of IL not only enables platform independence; it also facilitates language interoperability. The .Net Runtime will compile source code to IL from one language and this compiled code should then be interoperable with the code that has been compiled to IL from another language.

BCL

The .Net provides BCL, which is the group of Types that provide development environment for work. The framework's Base Class Library provides user interface, data access, database connectivity, web application development, numeric algorithms, network communications and the other number of classes that used by programmers, who combine it with their own code to produce applications. With more than 4,000 classes the BCL provides an environment for developing desktop Application (Win Forms), client-server and web based application (ASP.Net) and it also provide in built support for any database (ADO.Net) to connect with user applications. The classes of web and windows allow us to develop application by using drag and drop mechanism.

Garbase Collection

2011-05-15T10:11:00.001-07:00

Garbage Collection

The application code is responsible for allocating and de-allocating memory at runtime. This type of technique is used by lower - level, high - performance languages such as C++. It has the advantage that resources are never occupied for longer than necessary. The big disadvantage is the Code that requests memory also should explicitly inform the system when it no longer requires that memory.

The .NET runtime has a garbage collector instead. The purpose of this program is to clean up memory. The idea is that all dynamically requested memory is allocated on the heap or stack will be cleared by this program. When .NET detects that the managed heap for a given process is becoming full, the CLR calls the garbage collector. One can also call it manually by the code. Basically it clears two type of memory, first it clear heap memory, means it clear reference variables that are not longer referred to any object on stack and second it clears object on stack which is not longer referred by any reference variable.

JIT (Just-In-Time)

2011-05-15T08:49:00.000-07:00

JIT (Just In Time Compilation)

The .NET CLR utilizes Just-In-Time (JIT) compilation technology to convert the IL code back to a platform/device–specific code. There are three types of JIT compilers in .Net which are as follow.

Pre-JIT :- This JIT compiles an assembly’s entire code into native code at one stretch. You would normally use this at installation time.
Econo-JIT :- You would use this JIT on devices with limited resources. It compiles the IL code bit-by-bit, freeing resources used by the cached native code when required.
Normal JIT :- The default JIT compiles code only as it is called and places the resulting native code in the cache.

In essence, the purpose of a JIT compiler is to bring higher performance to interpreted code by placing the compiled native code in a cache, so that when the next call is made to the same member, the cached code is executed, resulting in an increase in application speed.

Metadata, Manifest

2011-05-15T08:41:00.000-07:00

Metadata

Metadata is the feature that lets the CLR know the details about a particular component. The metadata for any object is stored at compile time and then requested at runtime so that the CLR knows how that object(s), call their methods, and access their properties. The .NET metadata is stored within the assembly. The metadata contains a declaration of class members (methods, fields, properties, and events). For every method implemented by the component, the metadata contains information that the loader uses to locate the method body.

Manifest

An important part of an assembly is a manifest, which has metadata. It describes the assembly with all the information that’s needed to reference it and lists all its dependencies. An assembly manifest is a text file containing metadata about .NET. Metadata contain the information about all the components that is used in your program, while Manifest in stores the information about the assembly. A Manifest stores the following information: Identity - Name, version, culture, and public key and a list of files that belonging to this assembly. A single assembly must have at least one file but may contain a number of files. A list of referenced all assemblies used from the assembly are documented inside the manifest. This reference information includes the version number and the public key, which is used to uniquely identify assemblies.

Managed & Unmanged Code

2011-05-15T08:07:00.000-07:00

Managed Code

The source codes that compiled and executed under CLR, are managed code. This simply means that the execution of the code and its behavior is managed by the CLR. The metadata available with managed code contains the information required to allow the CLR to manage its safe execution. By safe execution we mean memory and security management, type safety, and language interoperability. All the languages that can be compiled by the CLR will produced the managed code and the other languages will produce unmanaged code.

Unmanged Code

Unmanaged code can be write to areas of memory it does not have own execution instructions, and it has number of other bad behaviors that cannot be managed or prevented by the CLR. Most of the applications running on Windows today are unmanaged. Not every company is going to rush to deliver a .NET component version of their products, so if you need to interface with other components then you have to include that functionality by giving a reference to a DLL file. There is a lot of functionality locked inside DLLs today. So doing that you’ll be calling unmanaged code. Unmanaged code is the code that is not managed by the CLR. However, this code is still run by the CLR, it just doesn’t get the advantages that it offers, such as the Common Type System and Automatic Memory Management.

Assemblies

2011-05-15T07:44:00.000-07:00

8) What is Assemblies? Explain Types of Assemblies.

An assembly is the logical unit that contains compiled code. An assembly is completely self - describing and is a logical rather than a physical unit, which means that it can be stored across more than one file. If an assembly is stored in more than one file, there must be one main file that contains the entry point and describes the other files in the assembly. Like an executable assembly contains a main program entry point, whereas a library file (dll) assembly does not. An important characteristic of assemblies is that they contain metadata that describes the types and methods defined in the corresponding code. An assembly can have also self-metadata which described itself, this assembly metadata, contained in an area known as the manifest.

The assembly contains program metadata means those applications don’t need to depend on registries; it is possible only by the version facility given by the .Net. When you store precious information in registry then there is a question arise for the security where as here is no risk of this happening, because all the metadata is stored with the program executable instructions. Assemblies come in two types: private and shared assemblies.

Private Assemblies

Private assemblies are the simplest type. They normally intended to be used only with that software. The private assemblies are supplied to an application in the form of an executable and a number of libraries, where the libraries contain code that should be used only with that application. The Private assemblies will not be used by other software because an application may load only private assemblies that are located in the same folder. Private assemblies intended for the package that they are intended for; it’s providing more security than the other third party software provide.

Shared Assemblies

Assemblies are the means of packaging and deploying applications and components in .NET. Assemblies can be made up of either single or multiple files. Shared assemblies are intended to be common libraries that any other application can use. In windows file system you are not allowed to place a two file with the same name (with same extension) but .Net makes it possible by the concept of version. The shared assembly stores in global assembly cache (GAC) within your windows directory (c:\Windows\assembly). The shared assembly can’t be copied as private assembly can, but one need to install it on the machine and this process can be performed by a number of .NET utilities and requires certain checks on the assembly. To prevent name collisions, shared assemblies are given a name based on private key cryptography. This name is known as a strong name; it is guaranteed to be unique and must be quoted by applications that reference a shared assembly. Specifying version information, it is possible to install the shared assembly side - by – side even the file name is same.

CLR (.Net Runtime)

2011-05-15T07:23:00.000-07:00

7) What is CLR? Explain MSIL in details.

The heart of the .NET Framework is its runtime execution environment, known as the Common Language Runtime (CLR) or the .NET runtime. The code running under the control of the CLR is often termed managed code. Before any program executed by the CLR, needs to be compiled. Compilation occurs in two steps in .NET:

Compilation of source code to MSIL.
Compilation of MSIL to platform - specific code by the CLR.

This two - stage compilation process is very important, because the existence of the IL is the key to providing many of the benefits of .NET. Microsoft Intermediate Language shares with Java byte code the idea that it is a low - level language with a simple syntax, which can be very quickly translated into native machine code. Having this well - defined universal syntax for code has significant advantages: platform independence, performance improvement, and language interoperability.

Microsoft Intermediate Language plays a fundamental role in the .NET Framework. It’s defined in the Common Language Specification. As we know C# code will be compiled into IL before it is executed, but before that the .NET will logically need to support the main characteristics of IL.

Here are the important features of IL:

❑ Object orientation and use of interfaces

❑ Strong distinction between value and reference types

❑ Strong data typing

❑ Error handling using exceptions

You can write applications directly in MSIL, much as you can write directly in assembly language.

Object orientation and use of interfaces :

The Microsoft implements Object Oriented programming in .Net Framework. The particular route that Microsoft has chosen to follow for IL is that of classic object - oriented programming, with single implementation inheritance of classes and of course multiple implementation of interface. The .Net support interpretability between more than one languages, What it really means is that classes written in one language should be able to talk directly to classes written in another language. In particular:

A class written in one language can inherit from a class written in another language.
A class can contain an instance of another class, no matter what the languages of the two classes are.
An object can directly call methods against another object written in another language.
Objects (or references to objects) can be passed around between methods.

Strong distinction between value and reference types

As with any programming language, IL provides a number of predefined primitive data types. One characteristic of IL, however, is that it makes a strong distinction between value and reference types. Value types are those for which a variable directly stores its data, whereas reference types are those for which a variable simply stores the address at which the corresponding data can be found. IL also lays down specifications about data storage: instances of reference types are always stored in an area of memory known as the managed heap, whereas value types are normally stored on the stack.

Strong data typing

One very important aspect of IL is that it is based on exceptionally strong data typing. That means that all variables are clearly marked as being of a particular, specific data type. IL does not normally permit any operations that result in ambiguous data types. For instance, Visual Basic 6 developers are used to being able to pass variables around without worrying too much about their types, because Visual Basic 6 automatically performs type conversion. C++ developers are used to routinely casting pointers between different types, but it breaks type safety. Hence, it is permitted only under certain circumstances in some of the languages that compile to managed code.

Error handling using exceptions

The .NET Framework is providing the facility to handling an error using the same mechanism that is employed by Java and C++. C++ developers should note that because of IL’s stronger typing system, there is no performance penalty associated with the use of exceptions with IL in the way that there is in C++. The .Net provide try, catch and finally block to handle any kind of runtime error.

Components of .Net

2011-05-15T06:37:00.000-07:00

6) What are the components of .Net Framework? Explain in brief.

The .Net is powerful framework technology which provides lots of functionality.

Following are the component of .Net Framework.

CLR (.NET Runtime)

The heart of the .NET Framework is the CLR. Similar in concept to the Java Virtual Machine, it is a runtime environment that executes MSIL code unlike JVM interpreted the byte code while CLR produce the CPU dependent code in form of exe, dll or in some other form. CLR has mainly two works to compiling code. First is to compile source code to MSIL code and the second is to compile MSIL code to Native Code.

Managed/Unmanaged Code

Unmanaged code is the code that is not handled by the CLR. Unmanaged code can be write to areas of memory it does not have own execution instructions, and it has number of other bad behaviors that cannot be managed or prevented by the CLR. Most of the applications running on Windows today are unmanaged.

Intermediate Language

Microsoft Intermediate Language obviously plays a fundamental role in the .NET Framework. It’s defined in the Common Language Specification. As we know C# code will be compiled into IL before it is executed, but before that the .NET will logically need to support the main characteristics of IL.

Here are the important features of IL:

❑ Object orientation and use of interfaces

❑ Strong distinction between value and reference types

❑ Strong data typing

❑ Error handling using exceptions

You can write applications directly in MSIL, much as you can write directly in assembly language.

Common Type System

The .Net is plateform independent by the means of CLS and CTS. Common Type System is the system which enables the all languages to work with each other by the way of data type. All language has a different structure to declare a data type, for example in c++ integer variable occupied 2 bytes where as in Java its occupied 4 byte. This dependency of data type is removed by the .Net, if you working with the .Net than you don’t worry about the how a data type declared in one language needs to be declared in another, the .net managed this all thing with some specific type that declared in .Net Framework. Any .NET type has the same attributes regardless of the language it is used in. In short all .NET data types are objects, derived from Object class which is reside in System namespace. There are two type of data type in .Net Framework, Predefined data type and reference type data type. Predefined data types are available in IL, so that all languages that target the .NET Framework will produce compiled code that is ultimately based on these types.

Just In Time Compiler

The .NET CLR utilizes Just in Time (JIT) compilation technology to convert the IL code to a platform–specific code. In .NET, there are three types of JIT compilers:

Pre JIT à This JIT compiles an assembly’s entire code into native code at one stretch. You would normally use this at installation time.
Econo JIT à you would use this JIT on devices with limited resources. It compiles the IL code bit-by-bit, freeing resources used by the cached native code when required.
Normal JIT à The default JIT compiles code only as it is called and places the resulting native code in the cache.

In essence, the purpose of a JIT compiler is to bring higher performance to interpreted code by placing the compiled native code in a cache, so that when the next call is made to the same method/procedure, the cached code is executed, resulting in an increase in application speed.

Garbage Collection

Windows DNA

2011-05-15T06:28:00.000-07:00

5) Write a Short Note on Windows DNA.

Windows DNA is short for Windows Distributed interNet Applications Architecture. Some of the technologies comprising DNA include ActiveX, Dynamic HTML (DHTML) and COM while Windows DNA has been largely superseded by the Microsoft .NET Framework excluding web based application because developing a web based application using COM based windows DNA is quite complex. Windows DNA was a technical specification that focused on building software based on Microsoft server products, utilizing numerous technologies and languages like ASP, HTML, JavaScript, MTS, COM, and other languages and technologies. The servers and languages introducing the Microsoft .NET Platform involved all have varying APIs and type systems, making interoperability a challenge at best. Herein lies the big difference: .NET is much more than a specification. A product in its own right, it includes the tools and languages required to make developing these types of n-tiered applications easier, neatly packaged as a single coherent and comprehensive API.

The .Net Advantage

2011-05-15T06:26:00.000-07:00

4) Explain the Advantages of .Net Framework.

The core of the .NET platform is found in the Common Language Runtime, Base Class Library and the Common Language Specification. Following are the advantages of .Net Framework.

1) Object Oriented Programming System (OOPS)

Visual studio.Net provides a fully object oriented environment It support different object oriented concept like class, object, inheritance, polymorphism etc. Basically the idea of .Net programming is derived from C++. So it inherits several functionality of C++.

2) Platform and Processor Independence

When we compile any application in .Net platform first it converted into MSIL code. This MSIL code is CPU independent code and this code can be run on any platform and processor which support CLR. So, programmer can develop application which can be run on any platform.

3) Rich Set of Classes

In c and c++, programmer use header files like and same as in .Net Framework, There are thousands of classes and namespace available which provides variety of functionality to use in our application?

4) Inbuilt Memory Management

The programmers always worry about system resources like memory. In c language, we are using different memory allocation function like malloc, calloc. To allocate memory, .Net used garbage collection to allocate memory and to make free unused memory of different object at regular interval.

5) Multilanguage Development

With .NET, all of the languages (which are supported by .Net) - compile to a common Intermediate Language. The CLR provides a framework in which it is easy to work on different language. The .Net framework also allows the integration of different language using MSIL code. The .Net framework supports language like VB.NET, C#.NET, J#.NET, Jscript, VBScript, COBOL, FORTRAN, PROLOG, PERL, PAYTHON and many more.

6) Code sharing

.NET code can be shared across multiple applications, with the use of assembly. Assemblies have formal facilities for versioning, and different versions of assemblies can exist side by side (within one folder).

7) Distributed Architecture

Today many applications uses three tier or N-tier Architecture which are presented to the user from deferent resources like web server located at different location and database server located at different location and the clients who is request for particular data access are located on different location. This type of architecture is known as distributed architecture. This type of application is very complex to build and maintain. The .Net provide architecture for developing this type of complex application using concepts like XML,SOAP,PARSER,UDDI etc…

8) Performance & Scalability

There is no magic stick available which allow poorly design application to sale and perform well the .Net framework gives you a tools using which we can easily design better performing software. For e.g. for web development .Net provide ASP.NET which separate application code data and presentation.

9) Better support for dynamic Web pages

Though ASP offered a lot of flexibility, it was also inefficient because of its use of interpreted scripting languages. The .NET offers an integrated support for Web pages, using a new technology - ASP.NET. With ASP.NET, code in your pages is compiled and execute on the server side.

10) Easy Deployment

After developing any type of application, programmers always worry about how they can deploy (install) their application. Most of the programmer use third party software to build installation. This installation process is time consuming and also complex sometime. The deployment in.Net does not require any extra activity like third party software. In .Net There are two types of assemblies: shared and private. Shared assemblies are common libraries available to all software, whereas private assemblies are intended only for use with particular software application. A private assembly is entirely self - contained, so the process of installing it is simple. There are no registry entries; the appropriate files are simply placed in the appropriate folder in the file system and uninstalling an application is easy as deleting files.

MS .Net Platform

2011-05-15T00:01:00.000-07:00

3) Write a short note on MS .Net Platform.

Microsoft visual studio.Net is a complete of development tools for developing web application, dynamic library, mobile application etc. Microsoft.Net platform is very broad and deep. First it wraps the windows operating System via class library with largest functionality. It provides a development environment with rich functionality and customization. It also provides the environment for working with multiple programming languages. The Architecture of .net consists of three primary components as follows:

The .Net Framework - It provides completely new application development platform.
Sever .Net products - The most of applications from Microsoft are based on .Net framework including version of exchange and sql server which is based on XML.
Server .Net services - Different services included in .Net for developing application running under the .Net framework.

The .Net framework is divided into three parts:-

1. CLR (Common Language Runtime):-

CLR is a managed execution environment that handles memory allocation, error trapping, and interacting with the operating-system services.

2. BCL (Base Class Library):-

BCL is an extensive collection of programming components and application program interface (API).

3. Top Level Development Target:-

It provide development environment for web application (ASP.NET) and regular windows application.

The advantages offered by the .NET Framework include shorter development cycles (code reuse, fewer programming surprises, support for multiple programming languages), easier deployment, fewer data type–related bugs due to integral type safety, reduced memory leaks thanks to the garbage collector, and, in general more scalable, reliable applications.

The .Net Architecture

2011-05-14T23:26:00.000-07:00

2) Explain .Net Architecture.

The .NET Framework is a software framework for Microsoft Windows operating systems and it is intended to be used by most new applications created for the Windows platform. It includes a large library, and it supports several programming languages which allow language interoperability. The .NET library is available to all the programming languages that .NET supports.

The .NET Framework introduces a Common Type System, which defines all possible datatypes and programming constructs supported by the CLR. The .NET Framework supports the exchange of types and object instances between applications written using any languages which is supported by .Net Framework.

Microsoft .Net support language integration which means we work on different language on same project. The .Net framework makes it possible with CLS. The purpose of the CLS is to provide a language-neutral platform for application development and execution. The CLS works with the CTS to ensure language interoperability. In .Net, the functionality will not be tied to a single language but will be available across the many languages like VB.Net, C#.Net, J#, C++, Perl, Paython and the other Languages. The .Net supports more than 30 languages to be interacting with Framework.

Figure: .Net Framework Architecture

The framework's Base Class Library provides a good user interface with more than 4000 classes. The class library is used by programmers, who combine it with their own code to produce applications. BCL provides an environment for developing desktop Application (Win Forms), client-server and web based application (ASP.Net) and it also provide in built support for any database (ADO.Net) to connect with user applications.

All Programs written for the .NET Framework execute in a software environment, called Common Language Runtime (CLR). The CLR is an application virtual machine, which provides other important services such as security, memory management, and exception handling. CLR convert the source code to Microsoft Intermediate Language. The MSIL code is resides in .NET assemblies in Portable Executable (PE) format, which is common on the Windows platform for all DLL and EXE files.

The .Net Framework

2011-05-14T22:02:00.000-07:00

1) Write a short note on .Net Framework.

.NET Framework is the most important new technology provided by Microsoft Corporation, which is designed to provide a new environment within which you can develop almost any application to run on Windows. In other words .NET is a framework - an API for programming on the Windows platform. .NET Framework is the first Microsoft development environment designed from the ground up for Internet development. Microsoft has started one project in late of 1990 named Next Generation Windows Services, later on called .Net Framework.

Microsoft .Net support language integration which means we work on different language on same project. The .Net framework makes it possible with CLS, which provides a series of basic rules that are required for language integration. The .Net framework work on top of the operating system and it provides following basic functionality.

1. Different language like VB.NET, C#, J#, JScript, VBScript

2. Common language runtime CLR an object oriented environment for windows and web
application.

3. Base class library BCL a no of related classes.

The most important component of .Net framework is CLR, which provides an environment in which programs are executed. The layer on top of the CLR is a set of base following by an additional layer of data and XML classes plus another layer which define classes for windows form and web form or web service. These classes are known as base class library.

The .Net provides BCL, which is the group of Types that provide development environment for work. The framework's Base Class Library provides user interface, data access, database connectivity, web application development, numeric algorithms, network communications and the other number of classes that used by programmers, who combine it with their own code to produce applications. With more than 4,000 classes the BCL provides an environment for developing desktop, client-server and web based application. The classes of web and windows allow us to develop application by using drag and drop mechanism.