Professional C# 2005, 3rd Edition by Allen Jones, Karli Watson, Jay Glynn, Christian Nagel, Morgan Skinner

From Barnes & Noble

The Barnes & Noble Review
Professional C# 2005 will help you master the one language best suited to contemporary .NET development: the Microsoft language that best reflects recent innovations in software development. Yes, that’s C# 2005, a.k.a. Whidbey.

Professional C# 2005 doesn’t just cover the core language: It places C# in the broader context of .NET and shows C# at work supporting database access, dynamic web pages, advanced graphics, access to directory services, and much more.

The authors begin with C# syntax and language elements: variables, data types, flow control, enumerations, arrays, namespaces, classes, structs, inheritance, operators, casts, type safety, operator overloading, delegates, events, memory management, strings, regular expressions, collections, and more. They thoroughly explain (and fully reflect) Whidbey’s major improvements: generics, anonymous methods, iterators, and partial and nullable types, among others. As you've come to expect from Wrox books, there are barrels of code examples.

Next, you'll turn to the .NET environment, including assemblies, Framework security, localization, and deployment. A full section on data access covers ADO.NET, XML, Active Directory, and SQL Server 2005. (The latter, of course, comes with the .NET CLR baked right in, so you can use C# to create stored procedures, functions, and data types.)

The authors walk through creating both Windows and web applications, highlight some key .NET platform improvements, such as ASP.NET master pages. Finally, you’ll find strong coverage of Web services, .NET remoting, and interoperability between .NET and pre-.NET applications: not just backward compatibility with COM, but the use of .NET components within COM applications. Bill Camarda, from the January 2006 Read Only

From the Publisher

Professional C# 2005 prepares you to program in C#, and it provides the necessary background information on how the .NET architecture works. It provides examples of applications that use a variety of related technologies, including database access, dynamic web pages, advanced graphics, and directory access. The only requirement is that you are familiar with at least one other high-level language used on Windows—either C++, VB, or J++.

It starts with a tutorial on C# and the .NET framework. This introduction assumes no prior knowledge of .NET, but it does move rapidly, on the assumption that the reader is an experienced programmer. Once this background knowledge is established, the book starts to sweep through the vast .NET class library, showing how you can use C# to solve various tasks.  This comprehensive coverage is one of the key selling points of previous versions of the book, and is maintained and enhanced with this new edition by adding new chapters on Generics, ObjectSpaces, Yukon, and Indigo. Some reference material is included either as appendices or is available to download from the Wrox website.

After the introduction and initial chapter, the book is divided into a number of sections that cover both the C# language and its application in a variety of areas. Coverage includes:

• Writing Windows applications and Windows services
• Writing web pages and web services with ASP.NET
• Manipulating XML using C# 2005
• Understanding .NET Assemblies
• Using ADO.NET to access databases
• Integration with COM, COM+, and Active Directory
• Distributed applications with .NET Remoting
• Generating graphics using C# 2005
• Accessing files and the Registry, and controlling .NET security

Product Details

• Table of Contents
• Read an Excerpt

Table of Contents

Read an Excerpt

21: Graphics with GDI+

However there are situations in which simply using controls doesn't give you the flexibility you need in your user interface. For example, you may want to draw text in a given font in a precise position in a window, or you may want to display images without using a picture box control, simple shapes or other graphics. A good example, is the Word for Windows program that I am using to write this chapter. At the top of the screen are various menus and toolbars that I can use to access different features of Word. Some of these menus and buttons bring up dialog boxes or even property sheets. That part of the user interface is what we covered in Chapter 9. However, the main part of the screen in Word for Windows is very different. It's an SDI window, which displays a representation of the document. It has text carefully laid out in the right place and displayed with a variety of sizes and fonts. Any diagrams in the document must be displayed, and if you're looking at the document in Print Layout view, the borders of the actual pages need to be drawn in too. None of this can be done with the controls from Chapter 9. To display that kind of output, Word for Windows must take direct responsibility for telling the operating system precisely what needs to be displayed where in its SDI window. How to do this kind of thing is subject matter for this chapter.

We're going to show you how to draw a variety of items including:

• Lines, simple shapes.
• Images from bitmap and other image files.
• Text.

In the process, we'll also need to use a variety of helper objects including pens (used to define the characteristics of lines), brushes (used to define how areas are filled in – for example, what color the area is and whether it is solid, hatched, or filled according to some other pattern), and fonts (used to define the shape of characters of text). We'll also go into some detail on how devices interpret and display different colors.

The code needed to actually draw to the screen is often quite simple, and it relies on a technology called GDI+. GDI+ consists of the set of .NET base classes that are available for the purpose of carrying out custom drawing on the screen. These classes are able to arrange for the appropriate instructions to be sent to the graphics device drivers to ensure the correct output is placed on the monitor screen (or printed to a hard copy). Just as for the rest of the .NET base classes, the GDI+ classes are based on a very intuitive and easy to use object model.

Although the GDI+ object model is conceptually fairly simple we still need a good understanding of the underlying principles behind how Windows arranges for items to be drawn on the screen in order to draw effectively and efficiently using GDI+.

This chapter is broadly divided into two main sections. In the first two-thirds of the chapter we will explore the concepts behind GDI+ and examine how drawing takes place, which means that this part of the chapter will be quite theoretical, with the emphasis on understanding the concepts. There will be quite a few samples, almost all of them very small applications that display specific hard-coded items (mostly simple shapes such as rectangles and ellipses). Then for the last third of the chapter we change tack and concentrate on working through a much longer sample, called CapsEditor, which displays the contents of a text file and allows the user to make some modifications to the displayed data. The purpose of this sample, is to show how the principles of drawing should be put into practice in a real application. The actual drawing itself usually requires little code – the GDI+ classes work at quite a high level, so in most cases only a couple of lines of code are required to draw a single item (for example, an image or a piece of text). However, a well designed application that uses GDI+ will need to do a lot of additional work behind the scenes, that is it must ensure that the drawing takes place efficiently, and that the screen is updated when required, without any unnecessary drawing taking place. (This is important because most drawing work carries a very big performance hit for applications.) The CapsEditor sample shows how you'll typically need to do much of this background management.

The GDI+ base class library is huge, and we will scarcely scratch the surface of its features in this chapter. That's a deliberate decision, because trying to cover more than a tiny fraction of the classes, methods and properties available would have effectively turned this chapter into a reference guide that simply listed classes and so on. We believe it's more important to understand the fundamental principles involved in drawing; then you will be in a good position to explore the classes available yourself. (Full lists of all the classes and methods available in GDI+ are of course available in the MSDN documentation.) Developers coming from a VB background, in particular, are likely to find the concepts involved in drawing quite unfamiliar, since VB's focus lies so strongly in controls that handle their own painting. Those coming from a C++/MFC background are likely to be in more comfortable territory since MFC does require developers to take control of more of the drawing process, using GDI+'s predecessor, GDI. However, even if you have a good background in GDI, you'll find a lot of the material is new. GDI+ does actually sit as a wrapper around GDI, but nevertheless GDI+ has an object model which hides many of the workings of GDI very effectively. In particular, GDI+ replaces GDI's largely stateful model in which items were selected into a device context with a more stateless one, in which each drawing operation takes place independently. A Graphics object (representing the device context) is the only object that persists between drawing operations.

By the way, in this chapter we'll use the terms drawing and painting interchangeably to describe the process of displaying some item on the screen or other display device.

Before we get started we will quickly list the main namespaces you'll find in the GDI+ base classes. They are...

...Almost all the classes, structs and so on. we use in this chapter will be taken from the System.Drawing namespace.

Understanding Drawing Principles

GDI and GDI+