Visual Studio .NET

Michael A. Hartmann

Visual Studio .NET

visual_studio
Date:
Revision: 1

Abstract

Microsoft Visual Studio .NET is an Integrated Development Environment (IDE) software package that allows programmers to develop software under the Microsoft .NET Framework. This programming platform allows developers to build software rapidly with very little difficulty. Although .NET technology is still in its juvenile stages, the platform has proven to be extremely effective and promises an absolute solution for programmers in the future using any Operation System or microprocessor. Visual Studio.NET has many features to empower programmers to achieve virtually any task and has been heavily marketed by Microsoft in recent years. .NET currently only has one rival with a similar technology, Sun Microsystems’, Java 2 Enterprise Edition (J2EE) technology. Independent tests and studies have demonstrated that .NET is outperforming J2EE in every testable category. The .NET platform continues to be refined to become more efficient, simple, and powerful to keep up with the demands of changing technologies

Visual Studio .NET

Introduction

Until recent times, developers had to create their programs using separate interpreters or compilers for each programming language to render software on a system. Furthermore, despite using the same programming language on one microprocessor, compiled code would rarely work on a different processor. This required programmers to recompile their code on the new target processor or must totally rewrite the code to maintain compatibility. Microsoft developed the .NET Framework to bridge the gap between microprocessor dissimilarities and enabling the programmer to concurrently use an assortment of programming languages. Microsoft Visual Studio .NET is Microsoft’s Integrated Development Environment (IDE) software designed to permit developers to take full advantage of the technology. A discussion of the details of Visual Studio .NET will be presented.

Microsoft Corporation History

Microsoft was founded in 1975 when Paul Allen and Bill Gates completed and sold a BASIC (Beginner’s All-Purpose Symbolic Instruction Code) interpreter to Micro Instrumentation and Telemetry Systems (MITS). Microsoft soon sold their version of BASIC to other companies and subsequently developed two additional programming languages, FORTRAN (Formula Translation/Translator) and COBOL (Common Business-Oriented Language). Sales of these three languages generated an annual income of one million dollars by 1978 (Grote & Nichols, 2000).

Steve Ballmer joined the company in 1980 as the company expanded sales throughout Europe and Asia. Microsoft is incorporated as a privately held corporation in 1981. Pascal, another popular programming language was added to Microsoft’s catalog and their first operating system, MS-DOS 1.0 was introduced as well (Grote & Nichols, 2000).

1983 was a landmark year for Microsoft as the company introduced Microsoft Word 1.0, Microsoft Mouse, and the first version of Microsoft Windows. After three years of substantial growth, the company became a public corporation by selling an initial 61 million dollars in stock. 15 years after the company was founded, the company was already achieving sales of 1 billion dollars annually. Through the years, Microsoft continued to innovate and developed fresh concepts to market to customers. Microsoft introduced the .NET concept in 2000, promising a technology that would bind all application and web developers together with a single platform (Grote & Nichols, 2000).

Microsoft.NET

Overview

The .NET Framework is Microsoft’s latest offering in the world of cross-platform development. The Microsoft .NET Framework introduces many new concepts, technologies, and terms. .NET is designed to be as trouble-free as possible. .NET contains functionality that a developer can effortlessly access. This same functionality operates within the boundaries of standardized data types and naming conventions. This internal functionality also includes the establishment of special data within an assembly file that is vital for interoperability, .NET’s built-in security, and .NET’s automatic resource management (Balena, 2002).

The .NET Framework is comprised of two elements: The Common Language Runtime (CLR) and the Framework Class Library (FCL). The .NET Framework is the part of the plan that makes developing services and applications truly simple. Microsoft made the CLR and FCL available in the various versions of Windows and the Windows.NET Server Family. A miniature version of the .NET Framework, identified as the.NET Compact Framework, is also available for PDA’s and appliances (Balena, 2002).

The CLR is the runtime environment for .NET. It manages code execution and the services that .NET offers. The CLR discerns what to do through unique data that is referred to as metadata that is enclosed within the applications. The metadata inside the applications deposit a map of where to find classes, when to load classes, and when to set up runtime environment boundaries, produce native code, implement security, establish which classes use which methods, and load classes when required. Since the CLR is privy to this information, it can also decide when an object is used and when it is released. This is known as managed code. Managed code is what sets apart .NET from previous endeavors by companies (Microsoft, 2004c).

For a user to run applications in the .NET framework, .NET framework runtime must be previously installed on the computer. This can be downloaded freely from Microsoft on their web site. The .NET Framework is already included in Windows XP starting with Service Pack 1 as well as all Windows Server 2003 systems. The company intends to include the runtime in all future releases of Microsoft Windows. .NET offers many advantages over legacy development platforms (Microsoft, 2004c).

Consistent programming model

Contrasting other platforms, where some operating system services are retrieved using Dynamic-Link Library (DLL) functions and other services are accessed passing through COM objects, all application services are obtainable through a common object-oriented programming model (Balena, 2002).

Simplified programming model

The CLR attempts to significantly simplify the confusing and mysterious structure required by Win32 and COM. Explicitly, the CLR now liberates the developer from struggling to comprehend many difficult concepts that were previously barriers to development. The CLR does not just eliminate these concepts away from the developer; these concepts just do not exist, in any manner, in the CLR (Balena, 2002).

Run once, run always concept

Every single Windows developer is accustomed with “DLL hell” versioning problems. This state transpires when components being installed for a new application overwrite components of an old application, triggering the old application to exhibit bizarre behavior or discontinue functioning altogether. The architecture of the .NET Framework now separates application components so that an application consistently loads the components that it was compiled and tested with. In theory, if the application runs after installation, then the application should always run (Balena, 2002).

Simplified deployment

Outside of .Net, Windows applications are unbelievably difficult to set up and deploy. Numerous files, registry settings, and shortcuts frequently need to be produced. Additionally, completely uninstalling an application is virtually unattainable. The .NET Framework attempts to eliminate these issues in Windows (Microsoft, 2004c).

This is accomplished by not referencing the .NET Framework components in the registry. Essentially, installing the majority of .NET Framework applications necessitate no more than copying the files to a directory and adding a shortcut to the Start menu, desktop, or Quick Launch bar. Uninstalling the application is as effortless as deleting the files. Therefore, a special installation package for an application is no longer required (Balena, 2002).

Wide platform reach

When compiling source code for the .NET Framework, the compilers produce common intermediate language (CIL) as an alternative to the more traditional CPU instructions. At run time, the CLR translates the CIL into native CPU instructions. Since the translation to native CPU instructions is done at run time, the translation is done for the host CPU. This allows the deployment of any .NET Framework application on any machine that has an ECMA-compliant version of the CLR and FCL running on it. These machines can be x86, IA64, Alpha, PowerPC, and so on. Users will instantly be pleased about the significance of this broad execution if they ever change their computing hardware or operating system (Balena, 2002).

Programming language integration

COM permits different programming languages to interoperate with each another. The .NET Framework allows languages to be incorporated with one another so that a programmer can utilize types of another language as if the languages are the same. For example, the CLR makes it possible to create a class in C++ that stems from a class implemented in Visual Basic. The CLR permits this because it defines and provides a Common Type System (CTS) that all programming languages that reference the CLR must draw on. The Common Language Specification (CLS) controls what compiler implementers be required to do for their languages to integrate well with other languages (Microsoft, 2004c).

Microsoft is itself providing several compilers that produce code using the runtime: C++ with Managed Extensions, C#, Visual Basic .NET, ASP.NET, J#, and an intermediate language (IL) assembler. Moreover, companies other than Microsoft and academic establishments are developing compilers for other languages that also use the CLR. Some of these include compilers for Alice, APL, COBOL, Component Pascal, Eiffel, FORTRAN, Haskell, Mercury, ML, Mondrian, Oberon, Perl, Python, RPG, Scheme, F#, and Smalltalk (Balena, 2002).

Simplified code reuse capabilities

Using the components described above, developers can generate their own classes that offer services to third-party applications. This makes it tremendously simple to reuse code and generates a large market for component vendors. These custom classes can be built on existing classes or codes included in .Net (Balena, 2002).

Automatic memory and management

Programming involves great expertise and discipline, particularly when it comes to managing the use of resources such as files, memory, screen space, network connections, database resources, etc. One of the most frequent bugs is the neglect to free one of these resources; eventually causing the application to perform improperly at some irregular point in time The CLR automatically tracks resource handling, assuring that an application on no account leaks resources. This is also referred to as the garbage collection (Microsoft, 2004c).

Type-safe verification

The CLR can verify that all a developer’s code is type-safe. Type safety makes certain that allocated objects are constantly accessed in compatible ways. Consequently, if a method input parameter is declared as accommodating a 4-byte value, the CLR will detect and lock out endeavors to access the parameter as an 8-byte value. Likewise, if an object uses 10 bytes in memory, the application cannot force the object into a form that will permit more than 10 bytes to be read. Type safety also means that execution flow will transfer only to recognized locations. There is no way to create an arbitrary reference to a memory location and cause code at that location to initiate execution. Collectively, these actions ensure type safety eradicating many common programming errors and classic system attacks like exploiting buffer overruns (Microsoft, 2004a).

Rich debugging support

Because the CLR is used for numerous programming languages, it is now much simpler to employ segments of an application using the language best fitting to a specific task. The CLR completely supports debugging applications that traverse language boundaries. This is a feature that has been new to programming concepts (Microsoft, 2004a).

Consistent method failure archetype

One of the most frustrating characteristics of Windows programming is the unpredictable style that functions use to convey errors. Various functions report Win32 status codes, some functions return HRESULTs, and other functions throw exceptions. Inside the CLR, every failure is reported using exceptions only. Exceptions permit the developer to isolate the failure from the code then allow clean-up code to finish. This departure from previous error handling significantly simplifies writing, reading, and maintaining code. Additionally, exceptions work across module and programming language boundaries. And, dissimilar status codes and HRESULTs, exceptions cannot be disregarded. The CLR also supplies built-in stack-walking facilities, allowing it much easier to trace any bugs and failures (Balena, 2002).

Security

Conventional operating system security offers isolation and access control centered on Windows user accounts. This method has demonstrated usefulness; however, at its core, it assumes that all code is uniformly trustworthy. This assumption was acceptable when all code was installed from physical media or trusted organizational servers. However, with the growing dependence on portable code such as Web scripts, applications downloaded over the Internet, and e-mail attachments, programmers need ways to manage the activities of applications in a more code-centric way. Code access security provides a means to accomplish this (Balena, 2002).

Interoperability

Microsoft understands that developers already have a massive quantity of existing code and components. Revising all this code to take full benefits of the .NET Framework platform would be a colossal task and would thwart the rapid implementation of this platform. In response to this, the .NET Framework fully supports the capability for the developer to access their existing COM components as well as call Win32 functions in existing DLLs (Balena, 2002).

End users will not directly understand the CLR and its abilities, but they will surely become attentive of the value and features of applications that make use of the CLR. Additionally, users and organizations bottom line will welcome how the CLR permits applications to be developed and deployed more quickly and with less management than Windows has ever permitted previously (Balena, 2002).

Visual Studio.NET

Overview

The Microsoft .NET Framework Software Development Kit (SDK) incorporates everything developers need to write, build, test, and deploy .NET Framework applications and provides to documentation, samples, and command-line tools and compilers. This SDK is free of charge and available on Microsoft’s website. Command-line compilers are difficult to use even for advanced programmers. Many third-party software companies have developed front-end Graphical User Interfaces (GUI) to make development a lot easier for programmers. GUIs are Window driven interfaces that provide simple point, “drag and click” methods to perform functions. Microsoft sells their own GUI dubbed Visual Studio.NET to developers for them to enjoy the full benefits of the framework (Microsoft, 2004d).

Microsoft initially released Visual Studio.NET in 2001 under the name Visual Studio.NET 2002. The development package was shipped with .NET Framework 1.0. The package supplied great functionality, however, being an initial product for a new technology; changes were needed to address developers concerns and more flexibility was needed. Microsoft responded by updating many classes in the framework and released .NET Framework 1.1 in 2003. Visual Studio was revised to match these improvements and released the current version, Visual Studio.NET 2003. By doing this, end users must update to .NET runtime 1.1 to be completely compatible with the changes (Microsoft, 2004d).

Visual Studio.NET 2003 offers many functions to assist the developer. These functions aid programmers to build applications speedily inside the platform. This is known as Rapid Application Development (RAD) (Oancea & Donald, 2002). Some of the GUI driven functions included in the package will be discussed.

 Design Window

The design window is used when a developer is graphically constructing an application by means of the Toolbox to drag and drop objects onto the window. Like the code window and browser, the design window cannot be docked or set to Auto Hide. The design view can be split or have tab groups added to it. Splitting the window helps when programmers need to evaluate the code from two separate files. The design view can be described as the graphical output of what the user will see. User controls can be placed or drawn in this window from the toolbox much like a newspaper layout (Oancea & Donald, 2002).

Code Window

The code window is much like the design window. However, there is no toolbox functionality within the code view and users cannot drag and drop objects from the toolbox and into the code view. When an object is placed into the design window, the code is automatically placed into the code window to support the object. Object methods, events, and properties are accessible through the code window. Code can be typed in this window to build the application or text can be cut and pasted from another source much like is done in Microsoft Word or other word processing software packages. Errors in programming syntax will be highlighted as a mistake make be made or upon an attempt to compile the code (Oancea & Donald, 2002).

Server Explorer

The Server Explorer has been named one of the best features in VS.NET. From this window, programmers can connect to a server on the network and have full access to that server. Developers can also link to any database servers that may be on the network. Overall, programmers can connect to database connections, IIS servers Crystal Reports, event logs, message queues, performance counters or any Window service that may be active (Oancea & Donald, 2002).

Toolbox

The Toolbox includes Data, Components, Web Forms, and Window Forms objects that can be dragged and dropped into the Design View window. Each object in the toolbox appears as icons much like many users are familiar on the Windows Desktop. Additionally, programmers can customize the Toolbox by adding their own code fragments and renaming them to something to their liking. Third party objects or controls that are available for .Net will appear in the toolbox as well. The toolbox allows programmers to build the Design Window at a rapid pace, where manual insertions would take extended time (Oancea & Donald, 2002).

Docking Windows

One of the features for VS.NET that was not available to previously released programming GUIs is docking windows. These can allow programmers to dock or expand or collapse all the windows within the view of the IDE. To add windows to the IDE, programmers can maneuver to the standard toolbar and select view; here they can select all the windows that are desired to have immediately available in the IDE environment. The auto-hide feature of each window makes them glide off the display and affix in the side when they are not needed. This allows developers to have maximum code view but have all windows at hand (Oancea & Donald, 2002).

Properties Explorer

The Properties Explorer is a table that contains existing attributes for a selected object. The right-hand column displays the property names, and the left-hand column stores the attribute’s value. The Properties Explorer can be organized by either categories or alphabetically. Some properties are editable and some are not. Any changes made in this window will be transferred to the design view and code view windows, correspondingly (Oancea & Donald, 2002).

Solution Explorer

The Solution Explorer is a list at all the files in a project solution. The Properties option lets developers view and edit all the solutions’ properties, as well as debug parameters options. The .NET GUI has two different types of containers offered for retaining objects, solutions, and projects. The main difference between the two is that multiple projects exist within a solution, while the project container retains merely files and items within files (Oancea & Donald, 2002).

Object Browser

The Object Browser will give the entire list of all classes’ methods and properties in a solution. The whole solution is listed, and it is rather profoundly detailed. If developers want, they can look up parents of classes that they are utilizing and list out the methods and properties at their choosing. Using the Object Browser allows developers to navigate within the entire solution quickly (Oancea & Donald, 2002).

Dynamic Help

The Visual Studio .NET Dynamic Help Window provides real-time, contextually pertinent information about an assortment of essentials and topics throughout the software creation progression. This information is shown within the Dynamic Help Window, available by selecting the dynamic help option from the help menu. There are three chief components to the default Dynamic Help Window, the contents button, the index button, and the search button. Anyone of these buttons will launch the full Visual Studio .NET Help File Collection in the proper mode. The Dynamic Help Window can be described as a sequence of quick links to direct the developer where to find more detailed information about their chosen topic (Oancea & Donald, 2002).

Task List Explorer

The Task List allows developers to add tasks that need to be completed and to categorize them in several different ways and with priority. An additional element of the Task List is that it will generate tasks on-the-fly as programmers’ debug applications by marking down any errors (Oancea & Donald, 2002).

IntelliSense

IntelliSense is a method of code completion that has been part of most Microsoft developer tools for several years. Code completion technology assists when users start to type a tag, attribute, or property by presenting the resulting ending so that users will not have to type out the complete item. This feature assists greatly in rapidly entering source code (Oancea & Donald, 2002).

Visual Studio.NET Pricing

There are currently four editions of Visual Studio.NET 2003 that can be purchased from Microsoft. The least expensive version is the Academic Version. This is a basic version that is suited fit for students and instructors. This package sells for $99 USD and is available through Microsoft or at various schools and universities. There is a small collection of visual tools that comes with the package for the student to gain some familiarity with the programming environment (Microsoft, 2004b).

Users that would like to purchase a more robust version of the package can purchase the Professional Special Edition. This version has an estimated retail price of $799 US. The Professional Special Edition makes it possible for developers to rapidly generate data-driven Web applications using well-known Visual Basic methods and dozens of reusables, browser-independent Web controls. Web applications assembled using Visual Studio .NET gain from superior performance, dependability, security, and scalability (Microsoft, 2004b).

Development teams can purchase the Enterprise Developer version of Visual Studio.NET for $1,799 US. This includes the features in the Professional Special Edition and includes bonus resources for enterprise development teams constructing mission-critical applications that are directed at any device and incorporate with any platform (Microsoft, 2004b).

The Enterprise Architect version also sells for $1,799 US. Visual Studio .NET 2003 Enterprise Architect builds on the strength of the Enterprise Developer version by adding extra capabilities for designing, specifying, and communicating application architecture, development best practices, and application functionality (Microsoft, 2004b).

.NET vs. J2EE

Microsoft’s Visual Studio .NET and the .NET Framework has just one rival technology in the market. Sun Microsystems launched Java 2 Platform, Enterprise Edition (J2EE), a Java based cross platform endeavor. The J2EE platform makes things easier for developers to create applications by centering them on standardized, modular components, by supplying an absolute set of services to those components, and by managing countless of application performance automatically, without complicated programming (Sun Microsystems, 2004).

Although both technologies have similar objectives, there are some advantages that each has over the other. Unlike .NET, J2EE already runs on any operating system that can use java technology. J2EE has a proven track record and is further along in the maturity process then .NET. J2EE has more enterprise features for session management, fail-over, load balancing and application integration and is preferential by experienced enterprise retailers such as IBM, BEA, SAP, and Oracle (Computerworld, 2004).

On the downside, J2EE has a complex application development environment that makes it difficult for a user to master. Additionally, the tools within the J2EE GUI are difficult to employ. J2EE is also reported to be costly to build, deploy and manage applications. J2EE also lacks built-in support for Web services standards that makes it awkward to deploy web applications (Computerworld, 2004).

The advantages of .NET are that is has Easy-to-use tools within its GUI to increase programmer efficiency. Unlike J2EE, .NET can use multiple programming languages. .NET also has excellent support for Web services. Companies will find that the cost of developing projects will be much less expensive than J2EE (Computerworld, 2004).

The disadvantages of .NET are that it is a fairly new technology that lacks maturity. Users of previous Microsoft programming language tools and technology face a potentially steep learning curve since so many changes have been incorporated in .NET. This also makes conversions from legacy languages to .NET timely. Furthermore, the .NET runtime is not available on every operating system yet (Computerworld, 2004).

Doculabs is an independent research and consulting firm that improves the way companies plan for, select, and optimize emerging technologies through project-based services. The firm measured the performance of J2EE and .NET to determine which platform ran Web service applications more efficiently. After extensive testing, the company concluded that Microsoft .NET offered the best performance among the two products evaluated in all tests performed. The firm attributed the superior performance results for .NET were due to that Web Services were an integrated component of the core .NET framework from the start, and not supplementary features on top of an existing framework as with J2EE (Doculabs, 2003).

Conclusion

As corporations are looking for diverse programmers that can use multiple languages, the demand for a single programming platform has never been higher. Visual Studio .NET provides flexibility and rapid development functionality to Microsoft’s .NET Framework. As the demands by developers increase, Microsoft will continue to advance Micsrosoft.NET to meet and exceed these needs.
References
Balena, F. (2002). Programming visual basic.net. Redmond, Washington: Microsoft Press.
Computerworld. (2004). Pros & cons: .Net vs. j2ee. Retrieved October 3, 2004, from http://www.computerworld.com/developmenttopics/development/story/
Doculabs. (2003). @Bench web services performance benchmark. Retrieved October 19, 2004, from http://www.doculabs.com/docs/reg/
Grote, D. & Nichols T. (2000). Microsoft: Through the years. Retrieved October 4, 2004, from http://wwwshs1.bham.wednet.edu/curric/socst/wa/Micro.htm
Microsoft. (2004a). Common language runtime overview. Retrieved October 3, 2004, from http://msdn.microsoft.com/library/en-us/cpguide/html/cpconcommonlanguageruntimeoverview/
Microsoft. (2004b). How to buy Microsoft developer products. Retrieved October 18, 2004, from http://msdn.microsoft.com/howtobuy/vstudio/
Microsoft. (2004c). Overview of the .net framework. Retrieved October 3, 2004, from http://msdn.microsoft.com/library/en-us/cpguide/html/cpovrintroductiontonetframeworks/
Microsoft. (2004d). Using Visual Studio .NET. Retrieved October 26, 2004, from http://msdn.microsoft.com/vstudio/using/default.aspx
Oancea, G. & Donald B. (2002). Visual basic.net: By example. Indianapolis, Indiana: Que.
Sun Microsystems. (2004). J2ee Overview. Retrieved October 25, 2004, from http://java.sun.com/j2ee/overview.html

CC

©2018 Michael A. Hartmann

This work is licensed under a Creative Commons Attribution 4.0 International License. Usage permitted with proper citing with author and source location.