Do you want to learn C#? Programmers around the world have learned that C# lets them design great-looking programs and build them fast. With C#, you ve got a powerful programming language and a valuable tool at your fingertips. And with the Visual Studio IDE, you ll never have to spend hours writing obscure code just to get a button working. C#, Visual Studio and .NET take care of the grunt-work, and let you focus on the interesting parts of getting your programs written. Sound appealing?
Unlike other C# books, which just show you examples and expect you to just memorize them and move on, Head First C# gets you writing code from the beginning. You're given the tools you need, and then you're guided through fun and engaging programming projects. You'll build programs to play a card game, explore a house, and help lazy programmers manage their sick day excuses. But it's not all fun and games: you'll build business applications too, like a contact database and a program to help a party planner estimate her dinner parties. You'll build a dungeon role-playing game and a fully animated, colorful simulation of a beehive. And by the end of the book, you'll build a fast-paced, full-featured retro Invaders arcade game.
Make no mistake: by the time you're done with Head First C#, you'll be able to build full-scale, complex, and highly visual programs. And you'll have all of the C# tools you need to tackle almost any programming problem that comes your way.
Head First C# is built for your brain, using the revolutionary approach that was pioneered by the highly acclaimed and popular Head First series. You'll never get that bored, "eyes glazed over" feeling from Head First C#, because it guides you through one challenging project after another until, by the end of the book, you're a C# rock star!
Here's what you'll learn:
- Core C# programming concepts
- How to use the Visual Studio 2008 IDE to build, debug and run your programs
- Important .NET 3.5 features, including generic collections, Windows forms, GDI+ graphics, streams, serialization and more
- Using object oriented programming concepts to help you build well-designed programs
- How to build robust applications with good error handling
- The latest C# 3.0 features, including LINQ, object and collection initializers, automatic properties, extension methods and more
Throughout the book, you'll confront and conquer advanced C# concepts. Some of the most mysterious ideas are demystified and explained with clear examples: how Unicode works, events and delegates, references versus value types, the stack versus the heap, what's really going on with garbage collection, and more.
Thousands of readers have learned C# using this innovative book, including:
- Beginning programmers who want to learn programming from the ground up
- More advanced programmers who are proficient in another language (like Visual Basic, Java, SQL, FoxPro) and want to add C# to their toolbox
- Programmers who understand basic C# syntax, but are still looking to get a handle on how objects work
- Anyone who's tried to learn C#, but had to deal with books full of dull examples and nothing but boring console applications
- Lots of people who just want to learn how to build cool games!
Head First C# is built to work with any version of Visual Studio 2008, including the free express edition. (It can also can be used with any version of Visual Studio 2005.)
Table of contents
- A Note Regarding Supplemental Files
- Advance Praise for Head First C#
- Praise for other Head First books
How to Use this Book: Intro
- Who is this book for?
- Who should probably back away from this book?
- We know what you’re thinking.
- And we know what your brain is thinking.
- Metacognition: thinking about thinking
- Here’s what WE did:
- Here’s what YOU can do to bend your brain into submission
- What you need for this book:
- Read me
- The technical review team
- Safari® Books Online
1. Get Productive With c#: Visual Applications, in 10 minutes or less
- Why you should learn C#
- C# and the Visual Studio IDE make lots of things easy
- Help the CEO go paperless
- Get to know your users’ needs before you start building your program
- Here’s what you’re going to build
- What you do in Visual Studio...
- What Visual Studio does for you...
- Develop the user interface
- Visual Studio, behind the scenes
- Add to the auto-generated code
- You can already run your application
- Where are my files?
- Here’s what we’ve done so far
- We need a database to store our information
- The IDE created a database
- SQL is its own language
- Creating the table for the Contact List
- The blanks on contact card are columns in our People table
- Finish building the table
- Diagram your data
- Insert your card data into the database
- Connect your form to your database objects with a data source
- Add database-driven controls to your form
- Good programs are intuitive to use
- Test drive
- How to turn YOUR application into EVERYONE’S application
- Give your users the application
- You built a complete data-driven application
- You built a complete data-driven application
- CSharpcross Solution
2. It’s All Just Code: Under the Hood
- When you’re doing this...
- ...the IDE does this
- Where programs come from
- The IDE helps you code
- When you change things in the IDE, you’re also changing your code
- Anatomy of a program
- Your program knows where to start
- You can change your program’s entry point
- Two classes can be in the same namespace
- Your programs use variables to work with data
- C# uses familiar math symbols
- Loops perform an action over and over again
- Time to start coding
- if/else statements make decisions
- Set up conditions and see if they’re true
- Csharpcross Solution
3. Objects: Get Oriented!: Making Code Make Sense
- How Mike thinks about his problems
- How Mike’s car navigation system thinks about his problems
- Mike’s Navigator class has methods to set and modify routes
- Use what you’ve learned to build a simple application
- Mike gets an idea
- Mike can use objects to solve his problem
- You use a class to build an object
- When you create a new object from a class, it’s called an instance of that class.
- A better solution... brought to you by objects!
- An instance uses fields to keep track of things
- Let’s create some instances!
- Thanks for the memory
- What’s on your program’s mind
- You can use class and method names to make your code intuitive
- Give your classes a natural structure
- Class diagrams help you organize your classes so they make sense
- Build a class to work with some guys
- Create a project for your guys
- Build a form to interact with the guys
- There’s an even easier way to initialize objects
- A few ideas for designing intuitive classes
- Objectcross Solution
4. Types and References: It’s 10:00. Do you know where your data is?
- The variable’s type determines what kind of data it can store
- A variable is like a data to-go cup
- 10 pounds of data in a 5 pound bag
- Even when a number is the right size, you can’t just assign it to any variable
- When you cast a value that’s too big, C# will adjust it automatically
- C# does some casting automatically
- When you call a method, the variables must match the types of the parameters
- Combining = with an operator
- Objects use variables, too
- Refer to your objects with reference variables
- References are like labels for your object
- If there aren’t any more references, your object gets garbage collected
- Multiple references and their side effects
- Two references means TWO ways to change an object’s data ways to change an object’s data
- A special case: arrays
- Arrays can contain a bunch of reference variables, too
- Welcome to Sloppy Joe’s Budget House o’ Discount Sandwiches!
- Objects use references to talk to each other
- Where no object has gone before
- Typecross Solution
I. C# Lab A Day at the Races
5. Encapsulation: Keep your privates... private
- Kathleen is an event planner
- What does the estimator do?
- Kathleen’s Test Drive
- Each option should be calculated individually
- It’s easy to accidentally misuse your objects
- Encapsulation means keeping some of the data in a class private
- Use encapsulation to control access to your class’s methods and fields
- But is the realName field REALLY protected?
- Private fields and methods can only be accessed from inside the class
- A few ideas for encapsulating classes
- Encapsulation keeps your data pristine
- Properties make encapsulation easier
- Build an application to test the Farmer class
- Use automatic properties to finish the class
- What if we want to change the feed multiplier?
- Use a constructor to initialize private fields
6. Inheritance: Your object’s family tree
- Kathleen does birthday parties, too
- We need a BirthdayParty class
- One more thing... can you add a $100 fee for parties over 12?
- When your classes use inheritance, you only need to write your code once
- Build up your class model by starting general and getting more specific
- How would you design a zoo simulator?
- Use inheritance to avoid duplicate code in subclasses
- Different animals make different noises
- Think about how to group the animals
- Create the class hierarchy
- Every subclass extends its base class
- Use a colon to inherit from a base class
- We know that inheritance adds the base class fields, properties, and methods to the subclass...
- A subclass can override methods to change or replace methods it inherited
- Any place where you can use a base class, you can use one of its subclasses instead
- A subclass can access its base class using the base keyword
- When a base class has a constructor, your subclass needs one too
- Now you’re ready to finish the job for Kathleen!
- Build a beehive management system
- First you’ll build the basic system
- Use inheritance to extend the bee management system
7. Interfaces and Abstract Classes: Making classes keep their promises
- Let’s get back to bee-sics
- We can use inheritance to create classes for different types of bees
- An interface tells a class that it must implement certain methods and properties
- Use the interface keyword to define an interface
- Now you can create an instance of NectarStinger that does both jobs
- Classes that implement interfaces have to include ALL of the interface’s methods of the interface’s methods
- Get a little practice using interfaces
- You can’t instantiate an interface, but you can reference an interface
- Interface references work just like object references
- You can find out if a class implements a certain interface with “is”
- Interfaces can inherit from other interfaces
- The RoboBee 4000 can do a worker bee’s job without using valuable honey
- is tells you what an object implements, as tells the compiler how to treat your object
- A CoffeeMaker is also an Appliance
- Upcasting works with both objects and interfaces
- Downcasting lets you turn your appliance back into a coffee maker
- Upcasting and downcasting work with interfaces, too
- There’s more than just public and private
- Access modifiers change scope
- Some classes should never be instantiated
- An abstract class is like a cross between a class and an interface
- Like we said, some classes should never be instantiated
- An abstract method doesn’t have a body
- Polymorphism means that one object can take many different forms
8. Enums and Collections: Storing lots of data
- Strings don’t always work for storing categories of data
- Enums let you enumerate a set of valid values
- Enums let you represent numbers with names
- We could use an array to create a deck of cards...
- Arrays are hard to work with
- Lists make it easy to store collections of... anything
- Lists are more flexible than arrays
- Lists shrink and grow dynamically
- List objects can store any type
- Collection initializers work just like object initializers
- Let’s create a list of Ducks
- Lists are easy, but SORTING can be tricky
- Two ways to sort your ducks
- Use IComparer to tell your List how to sort
- Create an instance of your comparer object
- IComparer can do complex comparisons
- Use a dictionary to store keys and values
- The Dictionary Functionality Rundown
- Your key and value can be different types, too
- You can build your own overloaded methods
- And yet MORE collection types...
- A queue is FIFO — First In, First Out — First In, First Out
- A stack is LIFO — Last In, First Out — Last In, First Out
- 5. Encapsulation: Keep your privates... private
II. C# Lab: The Quest
9. Reading and Writing Files: Save the byte array, save the world
- C# uses streams to read and write data
- Different streams read and write different things
- A FileStream writes bytes to a file
- How to write text to a file in 3 simple steps
- The Swindler launches another diabolical plan
- Reading and writing takes two objects
- Data can go through more than one stream
- Use built-in objects to pop up standard dialog boxes
- Dialog boxes are just another .NET control
- Dialog boxes are objects, too
- Use the built-in File and Directory classes to work with files and directories
- Use File Dialogs to open and save files (all with just a few lines of code)
- IDisposable makes sure your objects are disposed properly
- Avoid file system errors with using statements
- Trouble at work
- Writing files usually involves making a lot of decisions
- Use a switch statement to choose the right option
- Use a switch statement to let your deck of cards read from a file or write itself out to one
- Add an overloaded Deck() constructor that reads a deck of cards in from a file
- What happens to an object when it’s serialized?
- But what exactly IS an object’s state? What needs to be saved? an object’s state? What needs to be saved?
- When an object is serialized, all of the objects it refers to get serialized too...
- Serialization lets you read or write a whole object all at once
- If you want your class to be serializable, mark it with the [Serializable] attribute
- Let’s serialize and deserialize a deck of cards
- .NET converts text to Unicode automatically
- C# can use byte arrays to move data around
- Use a BinaryWriter to write binary data
- You can read and write serialized files manually, too
- Find where the files differ, and use that information to alter them
- Working with binary files can be tricky
- Use file streams to build a hex dumper
- StreamReader and StreamWriter will do just fine
10. Exception Handling: Putting out fires gets old
- Brian needs his excuses to be mobile
- When your program throws an exception, .NET generates an Exception object.
- Brian’s code did something unexpected
- All exception objects inherit from Exception
- The debugger helps you track down and prevent exceptions in your code
- Use the IDE’s debugger to ferret out exactly what went wrong in the excuse manager
- Uh-oh—the code’s still got problems...
- Handle exceptions with try and catch
- What happens when a method you want to call is risky?
- Use the debugger to follow the try/catch flow
- If you have code that ALWAYS should run, use a finally block
- Use the Exception object to get information about the problem
- Use more than one catch block to handle multiple types of exceptions
- One class throws an exception, another class catches the exception
- Bees need an OutOfHoney exception
- An easy way to avoid a lot of problems: using gives you try and finally for free
- Exception avoidance: implement IDisposable to do your own clean up
- The worst catch block EVER: comments
- Temporary solutions are okay (temporarily)
- A few simple ideas for exception handling
- Brian finally gets his vacation...
11. Events and Delegates: What your code does when you’re not looking
- Ever wish your objects could think for themselves?
- But how does an object KNOW to respond?
- When an EVENT occurs... objects listen
- One object raises its event, others listen for it...
- Then, the other objects handle the event
- Connecting the dots
- The IDE creates event handlers for you automatically
- The forms you’ve been building all use events
- Connecting event senders with event receivers
- A delegate STANDS IN for an actual method
- Delegates in action
- Any object can subscribe to a public event...
- Use a callback instead of an event to hook up exactly one object to a delegate
- Callbacks use delegates, but NOT events
12. Review and Preview: Knowledge, power, and building cool stuff
- You’ve come a long way, baby
- We’ve also become beekeepers
- The beehive simulator architecture
- Building the beehive simulator
- Life and death of a flower
- Now we need a Bee class
- P. A. H. B. (Programmers Against Homeless Bees)
- The hive runs on honey
- Filling out the Hive class
- The hive’s Go() method
- We’re ready for the World
- We’re building a turn-based system
- Here’s the code for World
- Giving the bees behavior
- The main form tells the world to Go()
- We can use World to get statistics
- Timers fire events over and over again
- The timer’s using a delegate behind the scenes
- Add a Timer to the simulator
- Test drive
- Let’s work with groups of bees
- A collection collects... DATA
- LINQ makes working with data in collections and databases easy
- Test drive (Part 2)
- One final challenge: Open and Save
13. Controls and Graphics: Make it pretty
- You’ve been using controls all along to interact with your programs
- Form controls are just objects
- Use controls to animate the beehive simulator
- Add a renderer to your architecture
- The renderer draws everything in the World on the two forms
- Controls are well-suited for visual display elements
- Build your first animated control
- BeeControl is LIKE a PictureBox... so let’s start by a PictureBox... so let’s start by INHERITING from PictureBox
- Create a button to add the BeeControl to your form
- Your controls need to dispose their controls, too!
- A UserControl is an easy way to build a control
- The renderer uses your BeeControl to draw animated bees on your forms
- Add the hive and field forms to the project
- Build the Renderer
- Now connect the main form to your two new forms, HiveForm and FieldForm
- Test drive... ahem... buzz
- Looks great, but something’s not quite right...
- Let’s take a closer look at those performance issues
- You resized your Bitmaps using a Graphics object
- Your image resources are stored in Bitmap objects
- Use System.Drawing to TAKE CONTROL of graphics yourself
- A 30-second tour of GDI+ graphics
- Use graphics to draw a picture on a form
- Graphics can fix our transparency problem...
- Use the Paint event to make your graphics stick
- A closer look at how forms and controls repaint themselves
- Double buffering makes animation look a lot smoother
- Double buffering is built into forms and controls
- Use a Graphics object and an event handler for printing
- PrintDocument works with the print dialog and print preview window objects
- There’s so much more to be done...
14. Captain Amazing the Death of the Object
- Your last chance to DO something... your object’s finalizer something... your object’s finalizer
- When EXACTLY does a finalizer run?
- Dispose() works with using, finalizers work with garbage collection
- Finalizers can’t depend on stability
- Make an object serialize itself in its Dispose()
- A struct looks like an object...
- ..but isn’t on the heap
- Values get copied, references get assigned
- Structs are value types; objects are reference types
- The stack vs. the heap: more on memory
- Captain Amazing... not so much
- Extension methods add new behavior to EXISTING classes
- Extending a fundamental type: string
15. Linq: Get control of your data
- An easy project...
- ... but the data’s all over the place
- LINQ can pull data from multiple sources
- .NET collections are already set up for LINQ
- LINQ makes queries easy
- LINQ is simple, but your queries don’t have to be
- LINQ is versatile
- LINQ can combine your results into groups
- Combine Jimmy’s values into groups
- Use join to combine two collections into one query
- Jimmy saved a bunch of dough
- Connect LINQ to a SQL database
- Use a join query to connect Starbuzz and Objectville
- 9. Reading and Writing Files: Save the byte array, save the world
III. C# Lab 3: Invaders
A. Leftovers: The top 5 things we wanted to include in this book
- #1 LINQ to XML
- #2 Refactoring
- #3 Some of our favorite Toolbox components
- #4 Console Applications
- #5 Windows Presentation Foundation
- Did you know that C# and the .NET Framework can...
- A. Leftovers: The top 5 things we wanted to include in this book
- About the Authors
- Title: Head First C#
- Release date: November 2007
- Publisher(s): O'Reilly Media, Inc.
- ISBN: 9780596514822
You might also like
People expect effortless, engaging interaction with desktop and web applications, but producing software that generates enjoyable …
Think Like a Programmer
In this one-of-a-kind text, author V. Anton Spraul breaks down the ways that programmers solve problems …
Go is rapidly becoming the preferred language for building web services. There are plenty of tutorials …
Head First Design Patterns, 2nd Edition
You know you don’t want to reinvent the wheel, so you look to design patterns—the lessons …