Gives students all the information and insight they need to begin building enterprise-class .NET applications as rapidly as possible.
Helps students play any role on a .NET development team, while also understanding the big picture.
Enables students to learn from real code—the most effective way for most students to learn programming.
Helps students leverage the full power of the .NET platform.
Helps students integrate new .NET software into existing IT environments.
Helps students build the types of applications that are increasingly demanded by the marketplace.
Gives students practical tools for securing .NET distributed applications against malicious code or unauthorized intrusions.
Helps students build more responsive applications.
Gives students practical solutions for maintaining the integrity of data across multiple applications and machines in distributed computing environments.
Helps students build applications that can grow smoothly to meet increasing demands.
Gives students an in-depth understanding of one of .NET's most sophisticated tools for building powerful, flexible applications.
Enterprise-class .NET programming in C#from a developer's perspective.
.NET developers need more than buzzwords to get the job done. To tackle enterprise-class projects, they need both a real understanding of the .NET architecture and a working knowledge of how to put its services to work. In .NET Programming: A Practical Guide Using C#, .NET authority Pradeep Tapadiya takes a straightforward, hands-on approach to explain everything you need to know from development to deployment and maintenance for this platformall from a developer's perspective. Using C# as the primary language, and with plenty of code examples throughout, this book is an excellent way to learn:
Appropriate for experienced developers, .NET Programming will help you get the most from the .NET architecturetoday.
I.1. What Is.NET?
Introduction. The Vision. The Platform. The.NET Framework. Development Tools. Foundation Services. What Does It All Mean? References.2. From C++ to C#.
A Simple “Hello User” Program. C# for C++ Programmers. Common Programming Paradigms. Deployment. Diagnostics and Support. Summary. References.3. Assemblies.
Assemblies. Assembly Identification. Anatomy of an Assembly. Shared Assemblies. Configuration Files. Assembly Binding. Attribute-Based Programming. Advanced Topics. Summary. References.4. Essentials of the .NET Framework.
.NET Framework Overview. Configuration. Common Language Runtime. Microsoft Intermediate Language. Managed Code Execution. Automatic Memory Management. Hosting the Runtime. Summary. References.5. Programming with the Base Class Library.
Enumeration. Collection. Cloning. Streams. Serialization. Strings. Summary. Reference.
II.6. Distributed Computing.
Application Domains. Contexts. Marshaling. Remoting Architecture. ASP.NET Web Services. Remoting Internals. Summary. References.7. Interoperability.
Introduction. Managed Code to Native DLLs. Accessing COM Components from .NET. Accessing .NET Components from COM. Summary. References.8. Concurrency.
Multithread Programming. Multithreading Issues. Asynchronous Programming. Summary.9. Security.
Introduction. Code Access Security. Role-Based Security. ASP.NET Web Services Security. Summary. References.10. Enterprise Services.
Enterprise Systems: .NET and COM+. Developing.NET Serviced Components. JIT Activation. Object Pooling. Role-Based Security. Queued Components. Transactions. Summary. References.Index.
Computing lifestyles and development needs change with time. Over the years, a number of paradigms and programming methodologies have been offered to support the needs of the developers and software vendors.
In the mid 1990s we saw monolithic applications being broken into smaller applications that communicated with each other. To facilitate code reusability and application communication across compiler boundaries and programming language boundaries, Microsoft introduced a framework called Component Object Model (COM). To further facilitate the communication across machine boundaries, Microsoft extended the model to Distributed COM (DCOM).
The late 1990s witnessed an incredible explosion of the Internet that caused a revolution in the way information was made available to the users. In developing enterprise systems, the traditional client/server model was replaced by a three-tier programming model, enhanced for Internet applications. Developing such enterprise systems was a time- and resource-consuming affair, as the systems had to meet extra enterprise-level requirements such as scalability, robustness, security, transaction support, and so on. To help developers meet these challenges, Microsoft introduced COM+, an advanced runtime environment that ran on Microsoft Windows 2000. Developers could now leverage the services provided by COM+ instead of building the services themselves.
In the new millennium, the Internet is evolving from a collection of isolated Web sites and applications into a general "communication bus" for distributed applications that can run on various hardware and operation system (OS) platforms.
Microsoft's .NET platform is based around this vision.
As part of the .NET initiative, Microsoft has provided a framework and some tools that developers can use to build applications targeting .NET platform.
Although .NET achieves many of the same goals that COM does, make no mistake.NET is a radically new platform. The programming model has been an evolution over COM, but the framework implementation is completely different. However, the enterprise system needs (e.g., scalability, transaction support, etc.) haven't changed much. Therefore, many COM+ services have found their way into .NET.
This book focuses on understanding .NET architecture from a developer's perspective and building .NET applications primarily using C#, a new programming language that offers the flexibility of C++ and the simplicity of Visual Basic.
The purpose of writing this book is twofold:
To achieve the first goal, a hands-on approach is employed in this book. As we progress through unfolding .NET technology, I present a key concept, accompanied by code samples as necessary.
The second goal is to use .NET productively in building enterprise-level applications. Enterprise-level requirements include security, transaction support, scalability, dealing with concurrency, distributed three-tier computing, dealing with legacy code, and so on. This book seeks to do the following:
I have tried to present the material such that it makes interesting reading for developers. Not only can developers gain an in-depth knowledge of .NET platform, but they can also get familiar with programming in other related technologies such as SOAP, XML, ADO.NET, and ASP.NET.
The book starts with an overview of .NET platform from a nontechnical perspective. Then I progress through unfolding the .NET architecture and services. Wherever applicable, code samples are provided to illustrate and explain the concepts. This book provides enough sample code to enable readers to be more productive and to carry out further research.
The intended audience includes the following groups:
A vast majority of the .NET programming community will be using C# for developing .NET applications. As a matter of fact, a large part of the .NET Framework has been developed in C#. Hence, I chose C# to present samples in most cases. However, in some instances I have used Visual Basic.NET or another language that is appropriate for the given situation.
The most important prerequisite for this book is a willingness to learn.
The book is written for intermediate to advanced developers. It is assumed that readers have a working knowledge of the following:
Note that knowledge of C# is helpful but not mandatory, as long as you are familiar with C++ or Java. As we go through developing sample code, I am confident readers will automatically pick up adequate information about the language.
All the examples provided in the book are concise and complete. For brevity, I sometimes show only the relevant code sample in the book. However, complete source code is available on the companion Web site (www.phptr.com/tapadiya/dotnet/). All the examples and tools have been compiled with Microsoft Visual C# 1.0 and the .NET Framework Software Development Kit (SDK), and have been tested on Windows 2000 SP2 and Windows XP.
The samples are organized by chapters. Each sample is built as a separate project. A project can be compiled either from Visual Studio .NET or from the command-line makefile. The makefile can be found in the bin directory under each project, except for Chapter 2. In order to illustrate some key compiler concepts, Chapter 2 contains the makefile in the same directory as the project.
Note that Visual Studio .NET requires that a project belongs to a solution. The project file has an extension .csproj and the solution file has an extension .sln.
In order to build the projects from the command line, you need to set up proper paths in the environment. If you have installed Visual Studio .NET, then you can use the command-line link that is provides called the "Visual Studio .NET Command Prompt." This link initializes the environment for the command window such that the .NET Framework SDK tools can be accessed from the command line.
This book frequently refers to other books, Microsoft's Knowledge Base articles, articles from various journals, and Microsoft's Developers Network (MSDN) Library. All the references for a particular chapter are listed at the end of that chapter. Each reference entry is indexed by a keyword that uses a combination of author's last name and year the reference was published. For example, Don Box's book Essential COM, which was published in 1998, is indexed as Box-98. In the book, each time I cite a reference, I use the relevant keyword.
The book is divided into two parts. The first part, Chapters 1-5, focuses on the fundamentals of .NET Programming Model and shows how to develop .NET-based applications.
The second part, Chapters 6-10, focuses on the services provided by .NET. Each chapter focuses on a specific aspect of .NET. These chapters are largely independent of each other.
.NET is Microsoft's new initiative for building applications regardless of the platforms or languages in use. The .NET label applies to three distinct but related items: a vision for how information technology (IT) will evolve, a software platform to build .NET applications, and an application-hosting business designed to support the vision and market the platform. In this chapter, we inspect each of these items from a fairly nontechnical perspective. By the end of the chapter, the readers will have a good idea of where Microsoft is going with the .NET initiative and will understand the terminology, features, and services offered by the .NET Framework, the software platform for .NET applications.
This chapter focuses on various stages of building .NET applications-from development to debugging and deploying. You will write simple C# programs to explore common programming paradigms under the .NET Framework. In the process, you will learn the differences and similarities between C++ and C#. By the end of the chapter, readers will understand many key concepts of the .NET Framework and will be fairly comfortable developing simple .NET applications using C#.
Under .NET, assemblies form the fundamental building block of program components. In defining the format for the assembly, .NET had many goals. These goals included interoperability among different programming languages, side-by-side execution of multiple versions of the same assembly, performance enhancements, and so on. In this chapter, we take an in-depth look at the assemblies and examine how these goals were achieved. By the end of the chapter, you will have a good knowledge of the assembly internals and the packaging and deployment model under .NET.
In this chapter, we examine the facilities that the .NET Framework provides to load and execute the code and provide services to the executing code. We start with an overview of various components that constitute the .NET Framework. Then we look at the overall process of managed code execution. We will see how .NET applications can be administratively controlled using external configuration files and how the configuration mechanism can be extended to store custom settings. We then look at the type system used by the common language runtime and examine the memory and performance considerations of using reference types versus value types. We examine how the CLS provides for cross-language interoperability. We look at how the execution engine validates the metadata, verifies the MSIL code for type-safety, and performs JIT compilation on the MSIL code. Finally, we look at the automatic memory management features of the runtime and how it simplifies or complicates programming under .NET. By the end of the chapter, you will have a good understanding of .NET architecture and how it helps in producing robust applications that can potentially be reused by any programming language under .NET. You will also learn the strategies of generating efficient code.
The .NET BCL includes hundreds of classes that provide a number of useful services to help developers boost their productivity. In this chapter, we look at how to solve many common programming tasks using these classes. By the end of the chapter, you will become familiar with many important classes under the .NET Framework.
In this chapter, we look at how to develop distributed applications under .NET that can communicate within intranets as well as over the Internet. We will see how .NET remoting offers seamless remote activation and remote method calls, among other things. We examine how to develop intranet applications using this support. Over the Internet, Web services have become the building blocks for distributed Web-based applications. We will look at the support offered by ASP.NET to create and deploy Web services. By the end of this chapter, readers will be comfortable developing applications using the common language runtime object-remoting and will be fairly conversant with ASP.NET Web services development.
The .NET Framework provides support for managed code to interoperate with unmanaged code. The unmanaged code could either be COM-based or be in native DLLs. The .NET Framework has been designed to provide smooth interoperability. In this chapter, we examine the support for interoperability provided by the .NET Framework. By the end of the chapter, readers will be comfortable making calls from managed code into unmanaged code and vice versa.
Under Windows, and most other modern OSs, a process can execute multiple threads concurrently, each of which carry out a specific task. The .NET Framework supports developing multithreaded applications in two ways-by supporting the creation and use of threads and by providing a mechanism to make asynchronous calls. In this chapter, we examine both these techniques in detail. We also look at various issues involved with multithread programming and the support provided by the .NET Framework in developing classes that are safe from concurrent access.
The .NET Framework offers two security mechanisms-code access security and role-based security. Both security mechanisms are built on top of the security provided by the underlying OS. Code access security keeps track of where the assemblies come from and what security permissions should be granted to them. Role-based security enables the code to make security decisions based on the role of the user executing the code.
In this chapter, we look at the concepts underlying code access security and role-based security. We also examine the classes and services provided by the .NET Framework to facilitate the use of these security mechanisms.
Security is also an important consideration for ASP.NET applications. ASP.NET applications need to authenticate clients and provide restricted access to any sensitive data, based on the client credentials. In addition, the ASP.NET applications may also have to act on behalf of the client in some cases to access OS secured resources such as NTFS files. In this chapter, we also examine various security features that ASP.NET provides to deal with authentication, authorization, and impersonation.
Enterprise system development has historically been a very time- and resource-consuming process. The development complexity arises from the extra enterprise-level requirements such as scalability, robustness, security, automatic transaction processing, and so on.
The .NET Framework provides many infrastructural services to meet the needs of enterprise systems. This allows businesses to focus on their core competencies instead of building the plumbing themselves.
In this chapter, we examine in detail some important requirements for enterprise systems and the services provided by .NET to meet these requirements.
The companion Web site (
www.phptr.com/tapadiya/dotnet/) contains the source code for all the examples in the book, arranged by chapters. For the most up-to-date information, see the read-me file at the Web site.
Pradeep Tapadiya is a lead software architect at the OpenView R&D Division of Hewlett-Packard in Roseville, CA and has been working with Microsoft enterprise development technologies since 1996. He holds a doctoral degree in Computer Science from Texas A&M University. Tapadiya is also the author of COM+ Programming: A Practical Guide Using Visual C++ and ATL. Tapadiya can be reached at