Catálogo de publicaciones - libros

You covered a lot of ground in this chapter. You were introduced to the delights of the new Visual C# 2005 Express user interface and development environment, and you also took a look at some of the neat features the IDE provides when you’re writing code. You even wrote a full web browser application, something you’ll be taking another look at in Chapter 16 later in the book.

After this whirlwind tour of the IDE, you’ll be pleased to know that in the next chapter I slow things down a bit so you can take a long hard look at just what a C# program is and what it all means. Those of you who have never written code will soon understand all the things that may have worried you in the earlier examples. Those of you coming here from other languages are about to wonder just how on earth you ever got along before C# came around.

See you in the next chapter.

I wanted in this chapter to give you a quick tour of C# and the kinds of things you can do with it. The programmers among you will by now have had a lot of their questions answered, but also a lot more will have come up. For example, what about interfaces and structures, abstract classes, reference types and value types, scoping, and so on?

The newcomers among you will also have a lot of questions, I’m sure. This chapter covered a lot of the very basics of C# but I intentionally avoided a great many details. It would take an entire book to cover the language and what you can do with it (this book in fact), but C# is one of those languages where it’s hard to explain any one thing without introducing a whole bunch of others.

So, in Chapter 3 you’ll dig a lot deeper, starting out with working with data in your programs, revisiting control structures, and looking at some of the nuances and trip wires C# brings with it when working with these things. So consider what you just read as a video walk-through of just what the theme park holds. In the next chapter you’ll get to go on some of the rides.

This chapter has covered pretty much the core essence of C#. You’ve seen how to create variables and then how to write code to work with them. That code can make decisions, it can loop, and so on. Now you’ve got the basics down, you can move into the real meat, starting with functions and methods (same thing) in the next chapter. Hang in there—you don’t have far to go now before you can start making beautiful Windows applications with cool user interfaces. You have to learn to walk first, though.

As usual, we’ve covered a lot in this chapter—more than I had originally planned, in fact. But, it’s all vitally important. C# is an object-oriented programming language and so everything you do will make use of the OOP facilities the language provides.

By using these tools effectively and really working in a true OOP style, your programs can become a lot easier to maintain, extend, and work on than their non-object-oriented cousins. But, you’ll notice that so far you haven’t really looked at just what is a good way to use these facilities to design a great OOP app. The bad news is that I don’t really have the time or scope to do that in this book. Throughout the rest of this book and especially in the next chapter (where you’ll look at some of the more advanced OOP features of C#), I’ll try to coax you toward the good habits and away from the bad. But it’s well worth picking up one or two other books after you have C# figured out to get a good grip on just what is, and what isn’t, good OOP design.

We’ve covered a lot of ground in this chapter, focusing on the more advanced stuff that you are likely to want, or need, to do with objects. Object references, interfaces, and casting can take a little while to get used to if you are new to the world of C#, but they are invaluable tools that will stand you in good stead.

The next chapter wraps up your introduction to the features of the C# language with a look at exceptions. With that out of the way, you’ll be ready to start learning all about what it takes to use Visual C# 2005 Express to write great Windows applications.

Exceptions do happen in programs. Sometimes you’ll even expect one to happen, and at other times you’ll need to code for the worse, just in case something goes wrong.

C#’s try... catch... finally block lets you catch and work with the exceptions, bubbling them up to other code if necessary.

This pretty much concludes our tour of the major language features of C#. There are still nuances to learn, but they are out of the scope of a beginner’s book. You’re sure to pick them up as you work through the rest of the book, building real Windows applications, and as you start to work on your own programs.

So without further ado, let’s dive into the rest of the treats Visual C# 2005 Express has to offer so you can start to learn how to really use the tool to write great applications.

Visual Studio has always been the IDE of choice for millions of developers around the globe simply because it makes programming easier. With Visual Studio 2005 and the Express tools, it just got even better.

In this chapter you took a look at some of the GUI aids for Windows user-interface design, as well IntelliSense, and the features hidden away in the C# Express Edit menu. I picked these items for a full explanation because they warrant it, especially if you’ve never used Visual Studio before. There are still a lot of other neat features to explore on the menus, so feel free to click away to your heart’s content before moving on. Don’t forget, online help can get you out of a bind if you find something particularly strange.

You’re all set now to start learning how to write Windows applications. See you in the next chapter.

You covered a lot of ground in this chapter, looking at the most common properties and events of all controls, as well as drilling down into event handling. You also took a look at some of the most common controls you’ll use in your apps, including buttons, text boxes, date and time controls, radio buttons, and check boxes. In fact, armed with your knowledge of C# Express you could probably go some way now to developing a simple Windows application on your own.

The journey, though, is far from over. In the next chapter you’ll take a look behind the scenes at event handling and I’ll equip you for the more complex controls and chapters to come.

Well, we certainly covered a lot of ground in this chapter. It’s so easy when you start out with Windows programming to take the humble window for granted, but as you’ve seen here there’s a whole lot more to it than meets the eye. In fact, there’s a lot more to it than we could cover here (the idea is to get you up to speed coding, after all, and not to publish the world’s first 10,000-page .NET encyclopedia). Take a look at the online help for the form to see the full list of all its properties, methods, and events, and of course have fun experimenting with the samples in this chapter to further explore the wonderful world of forms and dialogs.

As you can see, .NET gives a great deal of flexibility when it comes to displaying lists of data. In fact, the TreeView control when you really explore it offers a phenomenal amount of power.

When we move on to databases a little later, you’ll see a grid control that does even more than all these lists. You’ll also take a look at how to connect these list controls to a database to automatically show the database contents.