|
Pro C# 2005 and the .NET 2.0 Platform PDF Download
An Overview of This e-book
Pro C# 2005 and the .NET 2.0 Platform, Third Edition is logically divided into five distinct sections, each of which contains some number of chapters that somehow “belong together.” If you read the earlier editions of this text, you will notice some similarities in chapter names, but be aware that just about every page has been updated with new content and expanded examples. You will also notice that some topics in the first and second editions (such as object serialization and the .NET garbage collector) have been moved into a chapter of their very own.
Of course, as you would hope, the third edition contains several brand-new chapters (including a chapter devoted to the syntax and semantics of CIL) and detailed coverage of 2.0-specific features.
These things being said, here is a part-by-part and chapter-by-chapter breakdown of the text.
Part 1: Introducing C# and the .NET Platform
The purpose of Part 1 is to acclimate you to the core aspects of the .NET platform, the .NET type system, and various development tools (many of which are open source) used during the construction of .NET applications. Along the way, you will also check out some basic details of the C#
programming language.
Chapter 1: The Philosophy of .NET
This first chapter functions as the backbone for the remainder of the text. We begin by examining the world of traditional Windows development and uncover the shortcomings with the previous state of affairs. The primary goal of this chapter, however, is to acquaint you with a number of .NET-centric building blocks, such as the common language runtime (CLR), Common Type System (CTS), Common Language Specification (CLS), and base class libraries. Also, you will also take an initial look at the C# programming language and .NET assembly format, and you’ll examine the platform-independent nature of the .NET platform and the role of the Common Language Infrastructure (CLI).
Chapter 2: Building C# Applications
The goal of this chapter is to introduce you to the process of compiling and debugging C# source code files using various tools and techniques. First, you will learn how to make use of the commandline compiler (csc.exe) and C# response files. Over the remainder of the chapter, you will examine numerous IDEs, including TextPad, SharpDevelop, Visual C# 2005 Express, and (of course) Visual Studio 2005. As well, you will be exposed to a number of open source tools (Vil, NAnt, NDoc, etc.), which any .NET developer should have in their back pocket.
INTRODUCTION
Part 2: The C# Programming Language
This part explores all the gory details of the C# programming language, including the new syntactical constructs introduced with .NET 2.0. As well, Part 2 exposes you to each member of the CTS (classes, interfaces, structures, enumerations, and delegates) and the construction of generic types.
Chapter 3: C# Language Fundamentals
This chapter examines the core constructs of the C# programming language. Here you will come to understand basic class construction techniques, the distinction between value types and reference types, boxing and unboxing, and the role of everybody’s favorite base class, System.Object. Also,
Chapter 3 illustrates how the .NET platform puts a spin on various commonplace programming constructs, such as enumerations, arrays, and string processing. Finally, this chapter examines a number of 2.0-specific topics including “nullable data types.”
Chapter 4: Object-Oriented Programming with C#
The role of Chapter 4 is to examine the details of how C# accounts for each “pillar” of OOP: encapsulation, inheritance, and polymorphism. Once you have examined the keywords and the syntax used to build class hierarchies, you will then look at the role of XML code comments.
Chapter 5: Understanding Object Lifetime
This chapter examines how the CLR manages memory using the .NET garbage collector. Here you will come to understand the role of application roots, object generations, and the System.GC type. Once you understand the basics, the remainder of this chapter covers the topics of “disposable objects” (via the IDisposable interface) and the finalization process (via the
System.Object.Finalize() method).
Chapter 6: Understanding Structured Exception Handling
The point of this chapter is to discuss how to handle runtime anomalies in your code base through the use of structured exception handling. Not only will you learn about the C# keywords that allow you to handle such problems (try, catch, throw, and finally), but you will also come to understand
the distinction between application-level and system-level exceptions. In addition, this chapter
examines various tools within Visual Studio 2005 that allow you to debug the exceptions that have escaped your view.
Chapter 7: Interfaces and Collections
The material in this chapter builds upon your understanding of object-based development by
covering the topic of interface-based programming. Here you will learn how to define types that support multiple behaviors, how to discover these behaviors at runtime, and how to selectively hide particular behaviors using explicit interface implementation. To showcase the usefulness of interface types, the remainder of this chapter examines the System.Collections namespace.
Chapter 8: Callback Interfaces, Delegates, and Events
The purpose of Chapter 8 is to demystify the delegate type. Simply put, a .NET delegate is an object that “points” to other methods in your application. Using this pattern, you are able to build systems that allow multiple objects to engage in a two-way conversation. After you have examined the use of .NET delegates (including numerous 2.0-specific features such as anonymous methods), you will then be introduced to the C# event keyword, which is used to simplify the manipulation of raw delegate programming.
Chapter 9: Advanced C# Type Construction Techniques
This chapter deepens your understanding of the C# programming language by introducing a number of advanced programming techniques. For example, you will learn how to overload operators and create custom conversion routines (both implicit and explicit), build type indexers, and manipulate C-style pointers within a *.cs code file.
Chapter 10: Understanding Generics
As of .NET 2.0, the C# programming language has been enhanced to support a new feature of the CTS termed generics. As you will see, generic programming greatly enhances application performance and type safety. Not only will you explore various generic types within the System.Collections.Generic namespace, but you will also learn how to build your own generic methods and types (with and without constraints).
Part 3: Programming with .NET Assemblies
Part 3 dives into the details of the .NET assembly format. Not only will you learn how to deploy and configure .NET code libraries, but you will also come to understand the internal composition of a .NET binary image. This part also explains the role of .NET attributes and the construction of mutilthreaded applications. Later chapters examine some fairly low-level details (such as object context) and the syntax and semantics of CIL.
Chapter 11: Introducing .NET Assemblies
Froma very high level, assembly is the term used to describe a managed *.dll or *.exe file. However, the true story of .NET assemblies is far richer than that. Here you will learn the distinction between single-file and multifile assemblies, and how to build and deploy each entity. You’ll examine how private and shared assemblies may be configured using XML-based *.config files and publisher policy assemblies. Along the way, you will investigate the internal structure of the global assembly cache (GAC) and the role of the .NET Framework 2.0 configuration utility.
Chapter 12: Type Reflection, Late Binding, and Attribute-Based Programming
Chapter 12 continues our examination of .NET assemblies by checking out the process of runtime type discovery via the System.Reflection namespace. Using these types, you are able to build applications that can read an assembly’s metadata on the fly. You will learn how to dynamically activate and manipulate types at runtime using late binding. The final topic of this chapter explores the role of .NET attributes (both standard and custom). To illustrate the usefulness of each of these topics, the chapter concludes with the construction of an extendable Windows Forms application.
Chapter 13: Processes, AppDomains, Contexts, and CLR Hosts
Now that you have a solid understanding of assemblies, this chapter dives much deeper into the composition of a loaded .NET executable. The first goal is to illustrate the relationship between processes, application domains, and contextual boundaries. Once these terms have been qualified, you will then understand exactly how the CLR itself is hosted by the Windows operating system and deepen your understanding of mscoree.dll. The information presented here is a perfect lead-in to
Chapter 14.
Chapter 14: Building Multithreaded Applications
This chapter examines how to build multithreaded applications and illustrates a number of techniques you can use to author thread-safe code. The chapter opens by revisiting the .NET delegate type in order to understand a delegate’s intrinsic support for asynchronous method invocations. Next, you will investigate the types within the System.Threading namespace. You will look at numerous types (Thread, ThreadStart, etc.) that allow you to easily create additional threads of execution.
Chapter 15: Understanding CIL and the Role of Dynamic Assemblies
The goal of this chapter is twofold. In the first half (more or less), you will examine the syntax and semantics of CIL in much greater detail than in previous chapters. The remainder of this chapter covers the role of the System.Reflection.Emit namespace. Using these types, you are able to build software that is capable of generating .NET assemblies in memory at runtime. Formally speaking, assemblies defined and executed in memory are termed dynamic assemblies.
Part 4: Programming with the .NET Libraries
By this point in the text, you have a solid handle on the C# language and the details of the .NET assembly format. Part 4 leverages your newfound knowledge by exploring a number of namespaces within the base class libraries, including file I/O, the .NET remoting layer, Windows Forms development, and database access using ADO.NET.
Chapter 16: The System.IO Namespace
As you can gather from its name, the System.IO namespace allows you to interact with a machine’s file and directory structure. Over the course of this chapter, you will learn how to programmatically create (and destroy) a directory system as well as move data into and out of various streams (file-based, string-based, memory-based, etc.).
Chapter 17: Understanding Object Serialization
This chapter examines the object serialization services of the .NET platform. Simply put, serialization allows you to persist the state of an object (or a set of related objects) into a stream for later use.
Deserialization (as you might expect) is the process of plucking an object from the stream into memory for consumption by your application. Once you understand the basics, you will then learn how to customize the serialization process via the ISerializable interface and a set of new attributes introduced with .NET 2.0.
Chapter 18: The .NET Remoting Layer
Contrary to popular belief, XML web services are not the only way to build distributed applications under the .NET platform. Here you will learn about the .NET remoting layer. As you will see, the CLR supports the ability to easily pass objects between application and machine boundaries using marshal-by-value (MBV) and marshal-by-reference (MBR) semantics. Along the way, you will learn how to alter the runtime behavior of a distributed .NET application in a declarative manner using XML configuration files.
Chapter 19: Building a Better Window with System.Windows.Forms
This chapter begins your examination of the System.Windows.Forms namespace. Here you will learn the details of building traditional desktop GUI applications that support menu systems, toolbars, and status bars. As you would hope, various design-time aspects of Visual Studio 2005 will be examined, as well as a number of .NET 2.0 Windows Forms types (MenuStrip, ToolStrip, etc.).
Chapter 20: Rendering Graphical Data with GDI+
This chapter covers how to dynamically render graphical data in the Windows Forms environment.
In addition to discussing how to manipulate fonts, colors, geometric images, and image files, this chapter examines hit testing and GUI-based drag-and-drop techniques. You will learn about the new.NET resource format, which as you may suspect by this point in the text is based on XML data representation.
Chapter 21: Programming with Windows Forms Controls
This final Windows-centric chapter will examine numerous GUI widgets that ship with the .NET Framework 2.0. Not only will you learn how to program against various Windows Forms controls, but you will also learn about dialog box development and Form inheritance. As well, this chapter examines how to build custom Windows Forms controls that integrate into the IDE.
Chapter 22: Database Access with ADO.NET
ADO.NET is the data access API of the .NET platform. As you will see, you are able to interact with the types of ADO.NET using a connected and disconnected layer. Over the course of this chapter, you will have the chance to work with both modes of ADO.NET, and you’ll learn about several new .NET 2.0 ADO.NET topics, including the data provider factory model, connection string builders, and asynchronous database access.
Part 5:Web Applications and XML Web Services
Part 5 is devoted to the construction of ASP.NET web applications and XML web services. As you will see in the first two chapters of this section, ASP.NET 2.0 is a major upgrade from ASP.NET 1.x and includes numerous new bells and whistles.
Chapter 23: ASP.NET 2.0 Web Pages and Web Controls
This chapter begins your study of web technologies supported under the .NET platform using
ASP.NET. As you will see, server-side scripting code is now replaced with “real” object-oriented languages (such as C#, VB .NET, and the like). This chapter will introduce you to key ASP.NET topics such as working with (or without) code-behind files, the role of ASP.NET web controls, validations controls, and interacting with the new “master page” model provided by ASP.NET 2.0.
Chapter 24: ASP.NET 2.0 Web Applications
This chapter extends your current understanding of ASP.NET by examining various ways to handle state management under .NET. Like classic ASP, ASP.NET allows you to easily create cookies, as well as application-level and session-level variables. However, ASP.NET also introduces a new state management technique: the application cache. Once you have looked at the numerous ways to handle state with ASP.NET, you will then come to learn the role of the System.HttpApplication base class (lurking within the Global.asax file) and how to dynamically alter the runtime behavior of your web application using the Web.config file.
Chapter 25: Understanding XML Web Services
In this final chapter of this e-book, you will examine the role of .NET XML web services. Simply put, a web service is an assembly that is activated using standard HTTP requests. The beauty of this approach is the fact that HTTP is the one wire protocol almost universal in its acceptance, and it is therefore an excellent choice for building platform- and language-neutral distributed systems. You will also check out numerous surrounding technologies (WSDL, SOAP, and UDDI) that enable a web service and external client to communicate in harmony.
 |
Available Options: for Pro C# 2005 and the .NET 2.0 Platform PDF Download |
 |
Click the images to enlarge |
| CDR Media: |
|
| Download File: |
|
|
|
Main Categories
