Its April 1 st, April fools day

Last Month was a learning series of dot net framework , Next ill be publishing all the Dot Net directives each one with specific example with precise explanation. Even I am also exited about it.

Well because i am telling this on April fools day it doesn’t mean that i am making you all fool  but a kind of keep checking till than take care !!!

Reference : Dilip Kumar Jena ( https://mstechexplore.wordpress.com )

DotNet FrameWork Series Completion – Successful

Last Month we have seen most of  the basic Questions that can sometime come in our mind when we are new to Dot Net. I was also one amongst them so thought to learn and put it here so that not even me all our community can take advantage of it.

I will be more than Happy to hear any news, updates or Questions on My Framework Basic series.

you can get the complete series topic here Dotnet Framework series.

Reference : Dilip Kumar Jena ( https://mstechexplore.wordpress.com )

DotNet FrameWork – Dot Net Basics Complete Series Reference – Day 0 of 30

30 March 30, 2011 DotNet FrameWork – What actually happens when you add something to an arraylistcollection – How Boxing and unboxing occures in memory – Why only boxed types can be unboxed – Day 30 of 30
29 March 29, 2011 DotNet FrameWork – What is the purpose of XML Namespaces – difference between MetaData and Manifest – What is the use of Internal keyword – Day 29 of 30
28 March 28, 2011 DotNet FrameWork – What is the difference between typeof(foo) and myFoo.GetType() – Day 28 of 30
27 March 27, 2011 DotNet FrameWork – difference between Finalize() and Dispose() – How is the using() pattern useful – What is Program Database (PDB) – Day 27 of 30
26 March 26, 2011 DotNet FrameWork – ASP.NET Web Services vs. .NET Remoting – Security – Asssembly Qualified Name – Day 26 of 30
25 March 25, 2011 DotNet FrameWork – what an Interface is and how it’s different from a Class – difference between XML Web Services using ASMX and .NET Remoting using SOAP – Serialization and Metadata – Day 25 of 30
24 March 24, 2011 DotNet FrameWork – What is PID – What is GAC – Day 24 of 30
23 March 23, 2011 DotNet FrameWork – Managed and Unmanaged Code – multicast delegates – Describe the difference between a Thread and a Process – Day 23 of 30
22 March 22, 2011 DotNet FrameWork – Resource Files – Dispose and Finallize method – encapsulation – What is inline schema, how does it work – Day 22 of 30
21 March 21, 2011 DotNet FrameWork – Check Posting of Page – system.xml Namesapce – Multiple Inheritance – Managed and Unmanaged Code – Globalization and Localization – Day 21 of 30
20 March 20, 2011 DotNet FrameWork – JIT Compilers – Tracing Methods – Debuggind Mode – Day 20 of 30
19 March 19, 2011 DotNet FrameWork – Shared Assemblies – Global Assembly – MSIL – Day 19 of 30
18 March 18, 2011 DotNet FrameWork – What is the difference between structures and enumeration, What is a namespace – Day 18 of 30
17 March 17, 2011 DotNet FrameWork – What Is Boxing And Unboxing,Value Type and Reference Type – Day 17 of 30
16 March 16, 2011 DotNet FrameWork – What is Manifest,Metadata,Delegates,Virtual Keyword,class access modifiers – Day 16 of 30
15 March 15, 2011 DotNet FrameWork – What are the types of assemblies – Day 15 of 30
14 March 14, 2011 DotNet FrameWork – What is an Assembly – Day 14 of 30
13 March 13, 2011 DotNet FrameWork – What is GUID(Globally Unique Identifier) , why we use it and where – Day 13 of 30
12 March 12, 2011 DotNet FrameWork – What are the Main Features of .NET platform – Day 12 of 30
11 March 11, 2011 DotNet FrameWork – Client device independence and basics – Day 11 of 30
10 March 10, 2011 DotNet FrameWork – What is a Formatter – Vendor Neuteality – Interoperability and Web Services – Day 10 of 30
9 March 9, 2011 DotNet FrameWork – Can Private class-level variables be inherited – Protected Internal – Can you write a class without specifying namespace – Day 9 of 30
8 March 8, 2011 DotNet FrameWork– Difference between Overriding and Overloading – Virtual Meaning – Can we Inherit Multiple Interfaces – Difference between Interface and Abstract Class – Day 8 of 30
7 March 7, 2011 DotNet FrameWork– What is DLL Hell –Deploy Assembly – Satellite Assembly – assert() – multiple Inheritance – Day 7 of 30
6 March 6, 2011 DotNet FrameWork– Dot Net Basics – Day 6 of 30
5 March 5, 2011 DotNet FrameWork– What is JIT How it works –Portable Execute – Strong Name – Global Assembly Cache – Difference B/W constants,ReadOnly and Static– Shared and Public Assembly – Types of Authentication –Difference Between Struct and Class – Day 5 of 30
4 March 4, 2011 DotNet FrameWork– difference between Finalize and Dispose (Garbage collection) – Partial Assembly References– Reflection – Basics Day 4 of 30
3 March 3, 2011 DotNet FrameWork–Managed Means–Managed Data– Reflection – Basics Day 3 of 30
2 March 2, 2011 DotNet FrameWork – Basics Day 2 of 30
1 March 1,2011 DotNet FrameWork – Basics Day 1 of 30

Reference : Dilip Kumar Jena ( https://mstechexplore.wordpress.com )

DotNet FrameWork – What is the difference between structures and enumeration, What is a namespace – Day 18 of 30

What is the difference between structures and enumeration?

Unlike classes, structs are value types and do not require heap allocation. A variable of a struct type directly contains the data of the struct, whereas a variable of a class type contains a reference to the data. They are derived from System.ValueType class.

Enum->An enum type is a distinct type that declares a set of named constants.They  are strongly typed constants. They are unique types that allow to declare symbolic names to integral values. Enums are value types, which means they contain their own value, can’t inherit or be inherited from and assignment copies the value of one enum to another.

public enum Grade

{

A,

B,

C

}

What is a namespace?

Namespace is a logical naming scheme for group related types.Some class types that logically belong together they can be put into a common namespace. They prevent namespace collisions and they provide scoping. They are imported as “using” in C# or “Imports” in Visual Basic. It seems as if these directives specify a particular assembly, but they don’t. A namespace can span multiple assemblies, and an assembly can define multiple namespaces. When the compiler needs the definition for a class type, it tracks  through each of the different imported namespaces to the type name and searches each referenced assembly until it is found.

Namespaces can be nested. This is very similar to packages in Java as far as scoping is concerned.

Please read all the post in the Dotnet Framework series.

Reference : Dilip Kumar Jena ( https://mstechexplore.wordpress.com )

ASP- If a Browser Does NOT Support Cookies

If your application deals with browsers that do not support cookies, you will have to use other methods to pass information from one page to another in your application. There are two ways of doing this:

1. Add parameters to a URL

You can add parameters to a URL:

fname=John&lname=Smith”>

Go to Welcome Page</a>

And retrieve the values in the “welcome.asp” file like this:

<%

fname=Request.querystring(“fname”)

lname=Request.querystring(“lname”)

response.write(“Hello ” & fname & ” ” & lname & “!

“)

response.write(“<p>Welcome to my Web site!</p>”)

%>

2. Use a form

You can use a form. The form passes the user input to “welcome.asp” when the user clicks on the Submit button:

<form method=”post” action=”welcome.asp”>

First Name:  <input type=”text” name=”fname” value=””>

Last Name: <input type=”text” name=”lname” value=””>

<input type=”submit” value=”Submit”>

</form>

Retrieve the values in the “welcome.asp” file like this:

<%

fname=Request.form(“fname”)

lname=Request.form(“lname”)

response.write(“Hello ” & fname & ” ” & lname & “!

“)

response.write(“<p>Welcome to my Web site!</p>”)

%>

The Session object is used to store information about, or change settings for a user session. Variables stored in the Session object hold information about one single user, and are available to all pages in one application.

The Session Object

When you are working with an application, you open it, do some changes and then you close it. This is much like a Session. The computer knows who you are. It knows when you start the application and when you end. But on the internet there is one problem: the web server does not know who you are and what you do because the HTTP address doesn’t maintain state.

ASP solves this problem by creating a unique cookie for each user. The cookie is sent to the client and it contains information that identifies the user. This interface is called the Session object.

The Session object is used to store information about, or change settings for a user session. Variables stored in the Session object hold information about one single user, and are available to all pages in one application. Common information stored in session variables are name, id, and preferences. The server creates a new Session object for each new user, and destroys the Session object when the session expires.

When does a Session Start?

A session starts when:

  • A new user requests an ASP file, and the Global.asa file includes a Session_OnStart procedure
  • A value is stored in a Session variable
  • A user requests an ASP file, and the Global.asa file uses the <object> tag to instantiate an object with session scope

When does a Session End?

A session ends if a user has not requested or refreshed a page in the application for a specified period. By default, this is 20 minutes.

If you want to set a timeout interval that is shorter or longer than the default, you can set the Timeout property.

The example below sets a timeout interval of 5 minutes:

<%

Session.Timeout=5

%>

To end a session immediately, you may use the Abandon method:

<%

Session.Abandon

%>

Note: The main problem with sessions is WHEN they should end. We do not know if the user’s last request was the final one or not. So we do not know how long we should keep the session “alive”. Waiting too long uses up resources on the server. But if the session is deleted too fast you risk that the user is coming back and the server has deleted all the information, so the user has to start all over again. Finding the right timeout interval can be difficult.

Tip: If you are using session variables, store SMALL amounts of data in them.

Store and Retrieve Session Variables

The most important thing about the Session object is that you can store variables in it.

The example below will set the Session variable username to “Donald Duck” and the Session variable age to “50”:

<%

Session(“username”)=”Donald Duck”

Session(“age”)=50

%>

When the value is stored in a session variable it can be reached from ANY page in the ASP application:

Welcome <%Response.Write(Session(“username”))%>

The line above returns: “Welcome Donald Duck”.

You can also store user preferences in the Session object, and then access that preference to choose what page to return to the user.

The example below specifies a text-only version of the page if the user has a low screen resolution:

 

This is the text version of the page

<%Else%>

This is the multimedia version of the page

<%End If%>

Remove Session Variables

The Contents collection contains all session variables.

It is possible to remove a session variable with the Remove method.

The example below removes the session variable “sale” if the value of the session variable “age” is lower than 18:

<%

If Session.Contents(“age”)<18 then

Session.Contents.Remove(“sale”)

End If

%>

To remove all variables in a session, use the RemoveAll method:

<%

Session.Contents.RemoveAll()

%>

Loop Through the Contents Collection

The Contents collection contains all session variables. You can loop through the Contents collection, to see what’s stored in it:

<%

Session(“username”)=”Donald Duck”

Session(“age”)=50

dim i

For Each i in Session.Contents

Response.Write(i & ”
“)

Next

%>

Result:

username

age

If you do not know the number of items in the Contents collection, you can use the Count property:

<%

dim i

dim j

j=Session.Contents.Count

Response.Write(“Session variables: ” & j)

For i=1 to j

Response.Write(Session.Contents(i) & ”
“)

Next

%>

Result:

Session variables: 2

Donald Duck

50

Loop Through the StaticObjects Collection

You can loop through the StaticObjects collection, to see the values of all objects stored in the Session object:

<%

dim i

For Each i in Session.StaticObjects

Response.Write(i & “<br />”)

Next

%>

A group of ASP files that work together to perform some purpose is called an application. The Application object in ASP is used to tie these files together.

Reference : Dilip Kumar Jena ( https://mstechexplore.wordpress.com )

ASP – What is a Cookie?

A cookie is often used to identify a user. A cookie is a small file that the server embeds on the user’s computer. Each time the same computer requests for a page with a browser, it will send the cookie too. With ASP, you can both create and retrieve cookie values.

How to Create a Cookie

The “Response.Cookies” command is used to create cookies.

Note: The Response.Cookies command must appear BEFORE the <html> tag.

In the example below, we will create a cookie named “firstname” and assign the value “Alex” to it:

<%

Response.Cookies(“firstname”)=”Alex”

%>

It is also possible to assign properties to a cookie, like setting a date when the cookie should expire:

<%

Response.Cookies(“firstname”)=”Alex”

Response.Cookies(“firstname”).Expires=#May 10,2002#

%>

How to Retrieve a Cookie Value

The “Request.Cookies” command is used to retrieve a cookie value.

In the example below, we retrieve the value of the cookie named “firstname” and display it on a page:

<%

fname=Request.Cookies(“firstname”)

response.write(“Firstname=” & fname)

%>

Output:

Firstname=Alex

A Cookie with Keys

If a cookie contains a collection of multiple values, we say that the cookie has Keys.

In the example below, we will create a cookie collection named “user”. The “user” cookie has Keys that contains information about a user:

<%

Response.Cookies(“user”)(“firstname”)=”John”

Response.Cookies(“user”)(“lastname”)=”Smith”

Response.Cookies(“user”)(“country”)=”Norway”

Response.Cookies(“user”)(“age”)=”25″

%>

Read all Cookies

Look at the following code:

<%

Response.Cookies(“firstname”)=”Alex”

Response.Cookies(“user”)(“firstname”)=”John”

Response.Cookies(“user”)(“lastname”)=”Smith”

Response.Cookies(“user”)(“country”)=”Norway”

Response.Cookies(“user”)(“age”)=”25″

%>

Assume that your server has sent all the cookies above to a user.

Now we want to read all the cookies sent to a user. The example below shows how to do it (note that the code below checks if a cookie has Keys with the HasKeys property):

<html>

<body>

<%

dim x,y

for each x in Request.Cookies

response.write(“<p>”)

if Request.Cookies(x).HasKeys then

for each y in Request.Cookies(x)

response.write(x & “:” & y & “=” & Request.Cookies(x)(y))

response.write(“<br />”)

next

else

Response.Write(x & “=” & Request.Cookies(x) & “<br />”)

end if

response.write “</p>”

next

%>

</body>

</html>

Output:

firstname=Alex

user:firstname=John
user:lastname=Smith
user: country=Norway
user: age=25

Reference : Dilip Kumar Jena ( https://mstechexplore.wordpress.com )

Reference : Dilip Kumar Jena ( https://mstechexplore.wordpress.com )

What DOT NET Means for IT Professionals

Developers have long understood the benefits of Microsoft® .NET technologies. The wide variety of .NET tools, services, clients, and servers empowered developers to build powerful software and systems through XML Web services. But what is the value of Microsoft .NET for IT professionals?

These technologies offer IT professionals far-reaching benefits. From accelerating and improving daily operations to providing advanced capabilities for deploying next-generation technologies, .NET can help IT professionals connect their companies more broadly than ever before.
This article describes how .NET-connected software from Microsoft helps solve common IT problems related to deploying numerous applications across multiple systems. In addition, this article discusses how you can use .NET to manage, help protect, and connect systems to an array of mobile devices. You’ll also learn how specific Microsoft customers and industry partners are using .NET to connect diverse operating systems, devices, businesses, and individual users.

Understanding the .NET Framework
The .NET Framework is the programming model underlying .NET for developing, deploying, and running XML Web services and applications.
XML Web services are units of code that allow programs written in different programming languages and on different platforms to communicate and share data through standard Internet protocols such as, XML, SOAP, Web Services Description Language (WSDL), and Universal Description, Discovery, and Integration (UDDI).
The common language runtime and class libraries are at the center of the .NET Framework. The common language runtime manages memory, security, and language integration. It also and helps simplify code development and application deployment while improving application reliability. The bulk of this work is handled transparently, simplifying the work of IT administrators. In addition, features of the common language runtime—strong type naming, cross-language exception handling, lifetime management, and dynamic binding—dramatically reduce the amount of code a developer must write.
Class libraries supply the resources needed to build applications with XML support, networking, and data-access features. Because the classes are unified, developers can build both Microsoft Windows®-based and Web-based applications, enhancing their productivity and code reuse in the process.

Microsoft .NET and Deployment
One of the toughest deployment issues developers and IT professionals face involves dynamic-link libraries (DLLs). It starts when multiple applications attempt to share a common component like a DLL or a Component Object Model (COM) class. When a new application is installed, the components for the new application may overwrite components of an existing application, causing the existing application to function incorrectly or stop functioning completely.
Typically, one application will install a new version of the shared component that is not backward-compatible with the version already on the computer. Although the newly introduced application will work fine, existing applications that depended on a previous version of the shared component may no longer work.
Through the use of side-by-side deployment, the .NET Framework solves the problem of overwriting. Side-by-side deployment allows multiple versions of an assembly to be installed and to run simultaneously on the same computer. Authors aren’t restricted to maintaining backward compatibility because different applications can use different versions of a shared component. Each application can request to use a specific version of that assembly. Version information is recorded through the common language runtime between pieces of an application. At run time, the common language runtime refers to the recorded information to ensure the proper version of a dependency is loaded.
By isolating application assemblies, applications always load the components with which they were built and tested. An assembly can be accessed by only one application; it is not shared by multiple applications on the same computer. Therefore, it cannot be affected by changes made to the system by other applications.
.NET-enabled applications are self-contained and can be installed easily using XCOPY. This makes it possible to install desktop applications on client computers using a remote Web server. Actual deployment involves packaging developer code and distributing the packages to the clients and servers on which the application will run. The .NET Framework eliminates any dependency on the registry, which makes installation, removal, and replication much easier. You can deploy many applications by just copying file sets to disk and running them. To remove or replicate the applications, you can simply delete the files or copy over them.

Continental Airlines Streamlines Deployment with .NET
.NET also makes it possible for businesses to streamline the deployment time of applications they create. Application developers at Continental Airlines employed the .NET Framework and Microsoft Visual Studio® .NET to build and deploy mobile applications that use a single code base and run on multiple platforms. The applications allow customers to receive essential flight information on the device of their choice.
The .NET Framework helped developers cut deployment time from weeks to mere hours through “XCOPY deployment“—meaning they could design, code, and debug on the development platform, and then simply copy their code to a staging server. The code is then ready to run without worrying about dependencies such as DLL registration or building COM or export packages.
How does this benefit IT professionals? According to Ferdy Khater, director of application development at Continental, “With XCOPY deployment, adding a server is easy because we don’t have to bring down the whole site to do it.” So during peak usage periods, Khater says, “we can throttle the system by adding hardware and, once the peak has passed, redeploy it to where it’s needed more.”
In addition, Continental developers conducted a system stress test that simulated 200 concurrent connections generating 80,000 simultaneous hits. The connection success rate was more than 98 percent and the CPU utilization was less than 50 percent under a maximum load. The common language runtime ensured these favorable numbers by employing managed code and sidestepping memory leaks.

Interoperability and Management
One of the most significant advantages of the .NET Framework is its level of interoperability with other languages, applications, and systems. At the heart of .NET is the ability to help businesses integrate and manage their Web-based solutions through XML Web services, which are quickly becoming an industry standard.
.NET enables modern software applications to communicate through standard Internet protocols such as XML and SOAP, creating a channel through which internal and remote systems can easily interact. Applications hosted in-house—in addition to external systems—can be “stitched together,” allowing businesses to quickly meet their unique business needs through specialized yet economical solutions.
The common language runtime comes into play by allowing individual components of specific applications within a company to communicate. Through its standard set of types—self-describing type information (meta data) and common execution environment—the common language runtime integrates all programming languages and allows objects created in one language to be read with equal weight by code written in a different language. For example, a new scheduling function written in COBOL can be used with an existing human resources application that was written in Microsoft Visual Basic® .NET.
The advantages of multiple language support are obvious. Not only does it improve productivity by giving developers the choice to use the programming language that’s best suited to the job, it decreases time to market by increasing code reuse through cross-language inheritance.

Dollar Rent A Car: Interoperability in Action
A major airline contacted Dollar Rent A Car about providing a direct link from its Web site into Dollar’s reservation system. The Dollar IT staff realized that by integrating with travel partners, they could significantly drive incremental reservations. Dollar chose Microsoft .NET to extend its existing mainframe-based reservation system.
Dollar’s reservation system is a VMS-based application called Quick Keys. The airline’s systems are based on UNIX. To ensure effective integration, Dollar needed to:
• Create a real-time, direct connection between the two distinct platforms.
• Deliver the solution quickly with minimal difficulty,
• Ascertain the technology’s long-term viability.
Dollar already had two Quick Keys interfaces in place:
• An internally developed electronic data interchange (EDI) interface running on a Compaq Alpha server, which parsed flat files that were uploaded to Dollar via FTP on a daily basis by several tour operators.
• A Web site (www.dollar.com) built using Microsoft Windows NT® Server, CGI, Perl, and an Oracle database
The Web site relied on a custom COM component and Compaq’s TP-Web Connector to communicate with the mainframe. After considering several connecting technologies—including CORBA/IIOP, Java RMI, DCOM and socket programming—Dollar realized that XML Web services was the only solution that could enable any system written in any programming language to access the mainframe for reservations.
By using .NET, Dollar implemented a hybrid solution that capitalized on the benefits of XML Web services without requiring the airline to implement a SOAP interface. Essentially, the solution allows the airline’s UNIX-based system to send reservation requests to Dollar via sockets and a text-based format commonly used in the travel industry. A translator receives the message at Dollar, interprets it, and makes a SOAP call to a second system that exposes the preexisting COM-based interface into Quick Keys as an XML Web service.
By exposing Quick Keys as an XML Web service, Dollar was able to extend the Web site’s functionality to accommodate all mobile devices. The site now has a standard interface that can be used by a variety of internal and external applications. The solution also delivers tremendous strategic value, giving Dollar the capacity to easily expand its reach to other travel partners and individual users through next-generation technologies.

Security
Software applications, especially those that are Internet-based, have developed from static channels designed to alter and orchestrate data into increasingly dynamic exchange systems that form the foundation of e-business. As the complexity and functionality of modern software applications have increased, threats to software from both inside and outside organizations have risen.
The managed code architecture of the .NET Framework dramatically reduces the intrinsic risks associated with both client-side and server-side applications by transparently controlling the behavior of code. In a private study conducted by Foundstone, Inc., it was determined that a Microsoft Windows server running the .NET Framework can provide organizations with greater assurance that their applications can resist known security attacks today and in the future. It eliminates many of the major security risks facing applications today due to flawed code (such as buffer overruns); and shifts the burden from having to make critical security decisions—such as whether or not to run a particular application or what resources that application should be able to access—from end users to developers and administrators.
The comprehensive nature of the .NET Framework security architecture makes .NET both reliable and trustworthy. Key elements include:
• Evidence-based security
• Code access security
• The verification process
• Role-based security
• Cryptography
• Application domains
These elements help developers and IT administrators control security over applications and resources on a granular level. Developers get an easy-to-use tool set to implement powerful authentication, authorization, and cryptographic routines. This helps IT professionals by eliminating flawed code—one of the biggest threats to application security—so they can focus on critical security issues involving running other applications and accessing specific resources.

INSCOM and the Importance of Data Integrity
Another security concern is ensuring data integrity. While ultimately not an IT administrator’s responsibility, maintaining data integrity can help protect an organization’s internal records and communications, which makes security easier to maintain.
An example of data integrity–enhancing security is the use of .NET to help manage contractor personnel files at the Contractor Support Element (CSE) of the U.S. Army Intelligence and Security Command (INSCOM). The CSE worked with Microsoft Consulting Services to create a Web client that accesses a Microsoft SQL Server™ 2000 database storing information about contractor security clearances. The CSE was adapting a paper-based system to the Web, so retaining data integrity was a big concern. Simplifying the workflow became crucial.
“There were huge data integrity concerns when we started converting the existing system,” says INSCOM CIO Bob Fecteau. “We had to make sure the data appeared in the formats and structures we wanted to best do our business. The Web forms created using the ASP.NET component of Visual Studio .NET allow us to enforce integrity of all data entered, which was very important when we transferred the previous databases.”
Data integrity is also protected by a “capturing keystrokes” feature that remembers the first time data is entered into the system and eliminates the need to input the same data continually.

Device Support
One of the biggest advantages of .NET technology for consumers is its ability to connect and support a wide variety of stationary and mobile devices. IT professionals will appreciate the ease with which they can facilitate and maintain these connections over time.
XML Web services play an important role in device support. As mentioned previously, XML Web services allow various applications to share information over the Internet, regardless of the operating system or back-end software that the application is using. They also enable users to interact with a broad range of smart devices through the Web while ensuring that the user—not the application—controls the interaction.
Powerful client software such as the .NET Compact Framework, Windows CE .NET, and Windows XP enable a multitude of smart devices to operate and communicate through .NET and XML Web services. This collection of software empowers smart devices to access the Internet easily, providing a positive user experience while giving developers and IT administrators more control over their information.

Flexibility Proves Key for Scandinavian Airlines
Scandinavian Airlines System (SAS) recently implemented .NET technology to solve several problems associated with device support. The SAS IT group needed a technology that would be flexible enough to support a variety of popular phones and mobile devices used by customers accessing a single Web site (www.scandinavian.net) to check flight status and rebook flights.
Using the Microsoft Mobile Internet Toolkit in Visual Studio .NET, the SAS mobility and IT groups created the mobile presentation layer, adding mobile device access to their existing applications. They reused their existing back-end logic using the same application functionality.
Developers saved time by devising presentation logic for a number of different devices, including HTML Pocket PCs, WML (WAP) cell phones, cHTML cell phones, and HTML Palm devices. The SAS IT group used the mobile Web Forms controls (part of the Mobile Internet Toolkit) to create applications that work intelligently with each device.
In addition, the Mobile Internet Toolkit gave the SAS IT group the flexibility to add support for new devices, as well as to customize the markup for a specific device. The SAS Web site ultimately could support an unlimited range of devices. With the capacity for anytime, anywhere connectivity and system-to-user interconnection through .NET technology, SAS is strategically poised to further expand its client base and drive the way the travel industry communicates in the coming years.

Conclusion
Microsoft .NET is already shifting the focus from individual Web sites and devices connected to the Internet to constellations of computers, devices, and services that work together to deliver more comprehensive solutions. For IT professionals, this that means a wider scope of vision is required to manage advanced connectivity issues. But even as the field of vision expands, the possibility for error diminishes. .NET reduces the guesswork of many IT management tasks by:
• Helping to streamline deployment.
• Enabling interoperability with diverse systems, including legacy systems.
• Helping to enhance security.
• Reliably connecting and supporting both stationary and mobile devices.
For IT pros, the value of .NET lies in interoperability and the seamless connectivity of multiple systems and sources of data. Coupled with anytime, anywhere connectivity and system-to-user interconnection, .NET-connected software helps businesses deliver unprecedented levels of value to customers, partners and employees. By embracing .NET technology, IT professionals can empower their businesses to realize this vision.

Reference : Dilip Kumar Jena ( https://mstechexplore.wordpress.com )