You are previewing Head First C#, 2nd Edition.

Head First C#, 2nd Edition

Cover of Head First C#, 2nd Edition by Andrew Stellman... Published by O'Reilly Media, Inc.
  1. Head First C#
  2. Dedication
  3. A Note Regarding Supplemental Files
  4. Advance Praise for Head First C#
  5. Praise for other Head First books
  7. How to Use this Book: Intro
    1. Who is this book for?
      1. Who should probably back away from this book?
    2. We know what you’re thinking
    3. And we know what your brain is thinking
    4. Metacognition: thinking about thinking
    5. Here’s what WE did
    6. Here’s what YOU can do to bend your brain into submission
    7. What you need for this book
    8. Read me
    9. The technical review team
    10. Acknowledgments
    11. Safari® Books Online
  8. 1. Get Productive with C#: Visual Applications, in 10 minutes or less
    1. Why you should learn C#
      1. Here’s what the IDE automates for you...
      2. What you get with Visual Studio and C#...
    2. C# and the Visual Studio IDE make lots of things easy
    3. Help the CEO go paperless
    4. Get to know your users’ needs before you start building your program
    5. Here’s what you’re going to build
    6. What you do in Visual Studio...
    7. What Visual Studio does for you...
    8. Develop the user interface
    9. Visual Studio, behind the scenes
    10. Add to the auto-generated code
    11. You can already run your application
    12. Where are my files?
    13. Here’s what we’ve done so far
      1. .NET Visual Objects
    14. We need a database to store our information
    15. The IDE created a database
    16. SQL is its own language
    17. Creating the table for the Contact List
    18. The blanks on the contact card are columns in our People table
    19. Finish building the table
    20. Insert your card data into the database
    21. Connect your form to your database objects with a data source
    22. Add database-driven controls to your form
    23. Good programs are intuitive to use
    24. Test drive
      1. The IDE builds first, then runs
    25. How to turn YOUR application into EVERYONE’S application
    26. Give your users the application
    27. You’re NOT done: test your installation
    28. You’ve built a complete data-driven application
  9. 2. It’s All Just Code: Under the hood
    1. When you’re doing this...
    2. ...the IDE does this
    3. Where programs come from
      1. Every program starts out as source code files
      2. The .NET Framework gives you the right tools for the job
      3. Build the program to create an executable
      4. Your program runs inside the CLR
    4. The IDE helps you code
    5. When you change things in the IDE, you’re also changing your code
      1. Wait, wait! What did that say?
    6. Anatomy of a program
      1. Let’s take a closer look at your code
    7. Your program knows where to start
    8. You can change your program’s entry point
      1. So what happened?
    9. Two classes can be in the same namespace
    10. Your programs use variables to work with data
      1. Declare your variables
      2. Variables vary
      3. You have to assign values to variables before you use them
      4. A few useful types
    11. C# uses familiar math symbols
    12. Use the debugger to see your variables change
    13. Loops perform an action over and over
      1. Use a code snippet to write simple for loops
    14. Time to start coding
      1. Add statements to show a message
    15. if/else statements make decisions
    16. Set up conditions and see if they’re true
      1. Use logical operators to check conditions
      2. Set a variable and then check its value
      3. Add another conditional test
      4. Add loops to your program
  10. 3. Objects: Get Oriented!: Making code make sense
    1. How Mike thinks about his problems
    2. How Mike’s car navigation system thinks about his problems
    3. Mike’s Navigator class has methods to set and modify routes
      1. Some methods have a return value
    4. Use what you’ve learned to build a program that uses a class
      1. So what did you just build?
    5. Mike gets an idea
      1. He could create three different Navigator classes...
    6. Mike can use objects to solve his problem
    7. You use a class to build an object
      1. An object gets its methods from its class
    8. When you create a new object from a class, it’s called an instance of that class
    9. A better solution...brought to you by objects!
      1. Theory and practice
      2. A little advice for the code exercises
    10. An instance uses fields to keep track of things
      1. Methods are what an object does. Fields are what the object knows
    11. Let’s create some instances!
    12. Thanks for the memory
      1. Let’s take a closer look at what happened here
    13. What’s on your program’s mind
    14. You can use class and method names to make your code intuitive
    15. Give your classes a natural structure
      1. Let’s build a class diagram
    16. Class diagrams help you organize your classes so they make sense
    17. Build a class to work with some guys
    18. Create a project for your guys
    19. Build a form to interact with the guys
    20. There’s an easier way to initialize objects
  11. 4. Types and References: It’s 10:00. Do you know where your data is?
    1. The variable’s type determines what kind of data it can store
    2. A variable is like a data to-go cup
    3. 10 pounds of data in a 5 pound bag
    4. Even when a number is the right size, you can’t just assign it to any variable
      1. So what happened?
    5. When you cast a value that’s too big, C# will adjust it automatically
    6. C# does some casting automatically
    7. When you call a method, the arguments must be compatible with the types of the parameters
    8. Combining = with an operator
    9. Objects use variables, too
    10. Refer to your objects with reference variables
    11. References are like labels for your object
    12. If there aren’t any more references, your object gets garbage-collected
    13. Multiple references and their side effects
    14. Two references means TWO ways to change an object’s data
    15. A special case: arrays
      1. Use each element in an array like it is a normal variable
    16. Arrays can contain a bunch of reference variables, too
    17. Welcome to Sloppy Joe’s Budget House o’ Discount Sandwiches!
    18. Objects use references to talk to each other
    19. Where no object has gone before
    20. Build a typing game
  12. I. C# Lab: A Day at the Races
    1. 5. Encapsulation: Keep your privates... private
      1. Kathleen is an event planner
      2. What does the estimator do?
      3. Kathleen’s Test Drive
      4. Each option should be calculated individually
      5. It’s easy to accidentally misuse your objects
      6. Encapsulation means keeping some of the data in a class private
      7. Use encapsulation to control access to your class’s methods and fields
      8. But is the realName field REALLY protected?
      9. Private fields and methods can only be accessed from inside the class
      10. Encapsulation keeps your data pristine
      11. Properties make encapsulation easier
      12. Build an application to test the Farmer class
      13. Use automatic properties to finish the class
      14. What if we want to change the feed multiplier?
      15. Use a constructor to initialize private fields
    2. 6. Inheritance: Your object’s family tree
      1. Kathleen does birthday parties, too
      2. We need a BirthdayParty class
      3. Build the Party Planner version 2.0
      4. One more thing...can you add a $100 fee for parties over 12?
      5. When your classes use inheritance, you only need to write your code once
      6. Build up your class model by starting general and getting more specific
      7. How would you design a zoo simulator?
      8. Use inheritance to avoid duplicate code in subclasses
      9. Different animals make different noises
      10. Think about how to group the animals
      11. Create the class hierarchy
      12. Every subclass extends its base class
      13. Use a colon to inherit from a base class
      14. We know that inheritance adds the base class fields, properties, and methods to the subclass...
      15. A subclass can override methods to change or replace methods it inherited
      16. Any place where you can use a base class, you can use one of its subclasses instead
      17. A subclass can hide methods in the superclass
      18. Use the override and virtual keywords to inherit behavior
      19. A subclass can access its base class using the base keyword
      20. When a base class has a constructor, your subclass needs one, too
      21. Now you’re ready to finish the job for Kathleen!
      22. Build a beehive management system
      23. First you’ll build the basic system
      24. Use inheritance to extend the bee management system
    3. 7. Interfaces and Abstract Classes: Making classes keep their promises
      1. Let’s get back to bee-sics
      2. We can use inheritance to create classes for different types of bees
      3. An interface tells a class that it must implement certain methods and properties
      4. Use the interface keyword to define an interface
      5. Now you can create an instance of NectarStinger that does both jobs
      6. Classes that implement interfaces have to include ALL of the interface’s methods
      7. Get a little practice using interfaces
      8. You can’t instantiate an interface, but you can reference an interface
      9. Interface references work just like object references
      10. You can find out if a class implements a certain interface with “is”
      11. Interfaces can inherit from other interfaces
      12. The RoboBee 4000 can do a worker bee’s job without using valuable honey
      13. is tells you what an object implements, as tells the compiler how to treat your object
      14. A CoffeeMaker is also an Appliance
      15. Upcasting works with both objects and interfaces
      16. Downcasting lets you turn your appliance back into a coffee maker
      17. Upcasting and downcasting work with interfaces, too
      18. There’s more than just public and private
      19. Access modifiers change visibility
      20. Some classes should never be instantiated
      21. An abstract class is like a cross between a class and an interface
      22. Like we said, some classes should never be instantiated
      23. An abstract method doesn’t have a body
      24. Polymorphism means that one object can take many different forms
    4. 8. Enums and Collections; Storing lots of data
      1. Strings don’t always work for storing categories of data
      2. Enums let you work with a set of valid values
      3. Enums let you represent numbers with names
      4. We could use an array to create a deck of cards...
      5. Arrays are hard to work with
      6. Lists make it easy to store collections of...anything
      7. Lists are more flexible than arrays
      8. Lists shrink and grow dynamically
      9. Generics can store any type
      10. Collection initializers work just like object initializers
      11. Let’s create a List of Ducks
      12. Lists are easy, but SORTING can be tricky
      13. IComparable<Duck> helps your list sort its ducks
      14. Use IComparer to tell your List how to sort
      15. Create an instance of your comparer object
      16. IComparer can do complex comparisons
      17. Overriding a ToString() method lets an object describe itself
      18. Update your foreach loops to let your Ducks and Cards print themselves
      19. You can upcast an entire list using IEnumerable
      20. You can build your own overloaded methods
      21. Use a dictionary to store keys and values
      22. The Dictionary Functionality Rundown
      23. Build a program that uses a Dictionary
      24. And yet MORE collection types...
      25. A queue is FIFO—First In, First Out
      26. A stack is LIFO—Last In, First Out
  13. II. C# Lab: The Quest
    1. 9. Reading and Writing Files: Save the byte array, save the world
      1. .NET uses streams to read and write data
      2. Different streams read and write different things
      3. A FileStream reads and writes bytes to a file
      4. How to write text to a file in 3 simple steps
      5. The Swindler launches another diabolical plan
      6. Reading and writing using two objects
      7. Data can go through more than one stream
      8. Use built-in objects to pop up standard dialog boxes
      9. Dialog boxes are just another .NET control
      10. Dialog boxes are objects, too
      11. Use the built-in File and Directory classes to work with files and directories
      12. Use file dialogs to open and save files (all with just a few lines of code)
      13. IDisposable makes sure your objects are disposed of properly
      14. Avoid file system errors with using statements
      15. Trouble at work
      16. Writing files usually involves making a lot of decisions
      17. Use a switch statement to choose the right option
      18. Use a switch statement to let your deck of cards read from a file or write itself out to one
      19. Add an overloaded Deck() constructor that reads a deck of cards in from a file
      20. What happens to an object when it’s serialized?
      21. But what exactly IS an object’s state? What needs to be saved?
      22. When an object is serialized, all of the objects it refers to get serialized, too...
      23. Serialization lets you read or write a whole object all at once
      24. If you want your class to be serializable, mark it with the [Serializable] attribute
      25. Let’s serialize and deserialize a deck of cards
      26. .NET uses Unicode to store characters and text
      27. C# can use byte arrays to move data around
      28. Use a BinaryWriter to write binary data
      29. You can read and write serialized files manually, too
      30. Find where the files differ, and use that information to alter them
      31. Working with binary files can be tricky
      32. Use file streams to build a hex dumper
      33. StreamReader and StreamWriter will do just fine (for now)
      34. Use Stream.Read() to read bytes from a stream
    2. 10. Exception Handling: Putting out fires gets old
      1. Brian needs his excuses to be mobile
      2. When your program throws an exception, .NET generates an Exception object
      3. Brian’s code did something unexpected
      4. All exception objects inherit from Exception
      5. The debugger helps you track down and prevent exceptions in your code
      6. Use the IDE’s debugger to ferret out exactly what went wrong in the Excuse Manager
      7. Uh oh—the code’s still got problems...
      8. Handle exceptions with try and catch
      9. What happens when a method you want to call is risky?
      10. Use the debugger to follow the try/catch flow
      11. If you have code that ALWAYS should run, use a finally block
      12. Use the Exception object to get information about the problem
      13. Use more than one catch block to handle multiple types of exceptions
      14. One class throws an exception, another class catches the exception
      15. Bees need an OutOfHoney exception
      16. An easy way to avoid a lot of problems: using gives you try and finally for free
      17. Exception avoidance: implement IDisposable to do your own cleanup
      18. The worst catch block EVER: catch-all plus comments
      19. Temporary solutions are OK (temporarily)
      20. A few simple ideas for exception handling
      21. Brian finally gets his vacation...
    3. 11. Events and Delegates: What your code does when you’re not looking
      1. Ever wish your objects could think for themselves?
      2. But how does an object KNOW to respond?
      3. When an EVENT occurs...objects listen
      4. One object raises its event, others listen for it...
      5. Then, the other objects handle the event
      6. Connecting the dots
      7. The IDE creates event handlers for you automatically
      8. Generic EventHandlers let you define your own event types
      9. The forms you’ve been building all use events
      10. One event, multiple handlers
      11. Connecting event senders with event receivers
      12. A delegate STANDS IN for an actual method
      13. Delegates in action
      14. An object can subscribe to an event...
      15. Use a callback to control who’s listening
      16. A callback is just a way to use delegates
    4. 12. Review and Preview: Knowledge, power, and building cool stuff
      1. You’ve come a long way, baby
      2. We’ve also become beekeepers
      3. The beehive simulator architecture
      4. Building the beehive simulator
      5. Life and death of a flower
      6. Now we need a Bee class
      7. P. A. H. B. (Programmers Against Homeless Bees)
      8. The hive runs on honey
      9. Filling out the Hive class
      10. The hive’s Go() method
      11. We’re ready for the World
      12. We’re building a turn-based system
      13. Here’s the code for World
      14. Giving the bees behavior
      15. The main form tells the world to Go()
      16. We can use World to get statistics
      17. Timers fire events over and over again
      18. The timer’s using an event handler behind the scenes
      19. Add a timer to the simulator
      20. Test drive
      21. Let’s work with groups of bees
      22. A collection collects...DATA
      23. LINQ makes working with data in collections and databases easy
      24. Test drive (Part 2)
      25. One final challenge: Open and Save
    5. 13. Controls and Graphics: Make it pretty
      1. You’ve been using controls all along to interact with your programs
      2. Form controls are just objects
      3. Use controls to animate the beehive simulator
      4. Add a renderer to your architecture
      5. The renderer draws everything in the world on the two forms
      6. Controls are well suited for visual display elements
      7. Build your first animated control
      8. BeeControl is LIKE a let’s start by INHERITING from PictureBox
      9. Create a button to add the BeeControl to your form
      10. Your controls need to dispose their controls, too!
      11. A UserControl is an easy way to build a control
      12. Your simulator’s renderer will use your BeeControl to draw animated bees on your forms
      13. Add the hive and field forms to the project
      14. Build the renderer
      15. Now connect the main form to your two new forms, HiveForm and FieldForm
      16. Test
      17. Looks great, but something’s not quite right...
      18. Let’s take a closer look at those performance issues
      19. You resized your Bitmaps using a Graphics object
      20. Your image resources are stored in Bitmap objects
      21. Use System.Drawing to TAKE CONTROL of graphics yourself
      22. A 30-second tour of GDI+ graphics
      23. Use graphics to draw a picture on a form
      24. Graphics can fix our transparency problem...
      25. Use the Paint event to make your graphics stick
      26. A closer look at how forms and controls repaint themselves
      27. Double buffering makes animation look a lot smoother
      28. Double buffering is built into forms and controls
      29. Use a Graphics object and an event handler for printing
      30. PrintDocument works with the print dialog and print preview window objects
    6. 14. Captain Amazing: The Death of the Object
      1. Your last chance to DO something... your object’s finalizer
      2. When EXACTLY does a finalizer run?
      3. Dispose() works with using, finalizers work with garbage collection
      4. Finalizers can’t depend on stability
      5. Make an object serialize itself in its Dispose()
      6. A struct looks like an object...
      7. ...but isn’t an object
      8. Values get copied; references get assigned
      9. Structs are value types; objects are reference types
      10. The stack vs. the heap: more on memory
      11. Use out parameters to make a method return more than one value
      12. Pass by reference using the ref modifier
      13. Use optional parameters to set default values
      14. Use nullable types when you need nonexistent values
      15. Nullable types help you make your programs more robust
      16. Captain Amazing...not so much
      17. Extension methods add new behavior to EXISTING classes
      18. Extending a fundamental type: string
    7. 15. LINQ: Get control of your data
      1. An easy project...
      2. ...but the data’s all over the place
      3. LINQ can pull data from multiple sources
      4. .NET collections are already set up for LINQ
      5. LINQ makes queries easy
      6. LINQ is simple, but your queries don’t have to be
      7. LINQ is versatile
      8. LINQ can combine your results into groups
      9. Combine Jimmy’s values into groups
      10. Use join to combine two collections into one query
      11. Jimmy saved a bunch of dough
      12. Connect LINQ to a SQL database
      13. Use a join query to connect Starbuzz and Objectville
  14. III. C# Lab: Invaders
    1. A. Leftovers: The top 11 things we wanted to include in this book
      1. #1. The Basics
      2. #2. Namespaces and assemblies
      3. #3. Use BackgroundWorker to make your UI responsive
      4. #4. The Type class and GetType()
      5. #5. Equality, IEquatable, and Equals()
      6. #6. Using yield return to create enumerable objects
      7. #7. Refactoring
      8. #8. Anonymous types, anonymous methods, and lambda expressions
      9. #9. Serializing data using DataContractSerializer
      10. #10. LINQ to XML
      11. #11. Windows Presentation Foundation
      12. Did you know that C# and the .NET Framework can...
  15. Index
  16. About the Authors
  17. Copyright
O'Reilly logo

How to Use this Book: Intro

image with no caption

In this section, we answer the burning question: “So why DID they put that in a C# programming book?”

Who is this book for?

If you can answer “yes” to all of these:

  1. Do you want to learn C#?

  2. Do you like to tinker—do you learn by doing, rather than just reading?

  3. Do you prefer stimulating dinner party conversation to dry, dull, academic lectures?

this book is for you.

Who should probably back away from this book?

If you can answer “yes” to any of these:

  1. Does the idea of writing a lot of code make you bored and a little twitchy?

  2. Are you a kick-butt C++ or Java programmer looking for a reference book?

  3. Are you afraid to try something different? Would you rather have a root canal than mix stripes with plaid? Do you believe that a technical book can’t be serious if C# concepts are anthropomorphized?

this book is not for you.

image with no caption

[Note from marketing: this book is for anyone with a credit card.]

We know what you’re thinking

“How can this be a serious C# programming book?”

“What’s with all the graphics?”

“Can I actually learn it this way?”

And we know what your brain is thinking

Your brain craves novelty. It’s always searching, scanning, waiting for something unusual. It was built that way, and it helps you stay alive.

So what does your brain do with all the routine, ordinary, normal things you encounter? Everything it can to stop them from interfering with the brain’s real job—recording things that matter. It doesn’t bother saving the boring things; they never make it past the “this is obviously not important” filter.

image with no caption

How does your brain know what’s important? Suppose you’re out for a day hike and a tiger jumps in front of you, what happens inside your head and body?

Neurons fire. Emotions crank up. Chemicals surge.

And that’s how your brain knows...

This must be important! Don’t forget it!

But imagine you’re at home, or in a library. It’s a safe, warm, tiger-free zone. You’re studying. Getting ready for an exam. Or trying to learn some tough technical topic your boss thinks will take a week, ten days at the most.

Just one problem. Your brain’s trying to do you a big favor. It’s trying to make sure that this obviously non-important content doesn’t clutter up scarce resources. Resources that are better spent storing the really big things. Like tigers. Like the danger of fire. Like how you should never have posted those “party” photos on your Facebook page.

And there’s no simple way to tell your brain, “Hey brain, thank you very much, but no matter how dull this book is, and how little I’m registering on the emotional Richter scale right now, I really do want you to keep this stuff around.”

image with no caption

Metacognition: thinking about thinking

If you really want to learn, and you want to learn more quickly and more deeply, pay attention to how you pay attention. Think about how you think. Learn how you learn.

Most of us did not take courses on metacognition or learning theory when we were growing up. We were expected to learn, but rarely taught to learn.

But we assume that if you’re holding this book, you really want to learn how to build programs in C#. And you probably don’t want to spend a lot of time. If you want to use what you read in this book, you need to remember what you read. And for that, you’ve got to understand it. To get the most from this book, or any book or learning experience, take responsibility for your brain. Your brain on this content.

The trick is to get your brain to see the new material you’re learning as Really Important. Crucial to your well-being. As important as a tiger. Otherwise, you’re in for a constant battle, with your brain doing its best to keep the new content from sticking.

image with no caption

So just how DO you get your brain to treat C# like it was a hungry tiger?

There’s the slow, tedious way, or the faster, more effective way. The slow way is about sheer repetition. You obviously know that you are able to learn and remember even the dullest of topics if you keep pounding the same thing into your brain. With enough repetition, your brain says, “This doesn’t feel important to him, but he keeps looking at the same thing over and over and over, so I suppose it must be.”

The faster way is to do anything that increases brain activity, especially different types of brain activity. The things on the previous page are a big part of the solution, and they’re all things that have been proven to help your brain work in your favor. For example, studies show that putting words within the pictures they describe (as opposed to somewhere else in the page, like a caption or in the body text) causes your brain to try to makes sense of how the words and picture relate, and this causes more neurons to fire. More neurons firing = more chances for your brain to get that this is something worth paying attention to, and possibly recording.

A conversational style helps because people tend to pay more attention when they perceive that they’re in a conversation, since they’re expected to follow along and hold up their end. The amazing thing is, your brain doesn’t necessarily care that the “conversation” is between you and a book! On the other hand, if the writing style is formal and dry, your brain perceives it the same way you experience being lectured to while sitting in a roomful of passive attendees. No need to stay awake.

But pictures and conversational style are just the beginning.

Here’s what WE did

We used pictures, because your brain is tuned for visuals, not text. As far as your brain’s concerned, a picture really is worth a thousand words. And when text and pictures work together, we embedded the text in the pictures because your brain works more effectively when the text is within the thing the text refers to, as opposed to in a caption or buried in the text somewhere.

image with no caption

We used redundancy, saying the same thing in different ways and with different media types, and multiple senses, to increase the chance that the content gets coded into more than one area of your brain.

We used concepts and pictures in unexpected ways because your brain is tuned for novelty, and we used pictures and ideas with at least some emotional content, because your brain is tuned to pay attention to the biochemistry of emotions. That which causes you to feel something is more likely to be remembered, even if that feeling is nothing more than a little humor, surprise, or interest.

We used a personalized, conversational style, because your brain is tuned to pay more attention when it believes you’re in a conversation than if it thinks you’re passively listening to a presentation. Your brain does this even when you’re reading.

image with no caption

We included more than 80 activities, because your brain is tuned to learn and remember more when you do things than when you read about things. And we made the exercises challenging-yet-do-able, because that’s what most people prefer.

image with no caption

We used multiple learning styles, because you might prefer step-by-step procedures, while someone else wants to understand the big picture first, and someone else just wants to see an example. But regardless of your own learning preference, everyone benefits from seeing the same content represented in multiple ways.

We include content for both sides of your brain, because the more of your brain you engage, the more likely you are to learn and remember, and the longer you can stay focused. Since working one side of the brain often means giving the other side a chance to rest, you can be more productive at learning for a longer period of time.

image with no caption

And we included stories and exercises that present more than one point of view, because your brain is tuned to learn more deeply when it’s forced to make evaluations and judgments.

We included challenges, with exercises, and by asking questions that don’t always have a straight answer, because your brain is tuned to learn and remember when it has to work at something. Think about it—you can’t get your body in shape just by watching people at the gym. But we did our best to make sure that when you’re working hard, it’s on the right things. That you’re not spending one extra dendrite processing a hard-to-understand example, or parsing difficult, jargon-laden, or overly terse text.

We used people. In stories, examples, pictures, etc., because, well, because you’re a person. And your brain pays more attention to people than it does to things.

image with no caption

Here’s what YOU can do to bend your brain into submission

image with no caption

Cut this out and stick it on your refrigerator.

So, we did our part. The rest is up to you. These tips are a starting point; listen to your brain and figure out what works for you and what doesn’t. Try new things.

  1. Slow down. The more you understand, the less you have to memorize.

    Don’t just read. Stop and think. When the book asks you a question, don’t just skip to the answer. Imagine that someone really is asking the question. The more deeply you force your brain to think, the better chance you have of learning and remembering.

  2. Do the exercises. Write your own notes.

    We put them in, but if we did them for you, that would be like having someone else do your workouts for you. And don’t just look at the exercises. Use a pencil. There’s plenty of evidence that physical activity while learning can increase the learning.

  3. Read the “There are No Dumb Questions”

    That means all of them. They’re not optional sidebars—they’re part of the core content! Don’t skip them.

  4. Make this the last thing you read before bed. Or at least the last challenging thing.

    Part of the learning (especially the transfer to long-term memory) happens after you put the book down. Your brain needs time on its own, to do more processing. If you put in something new during that processing time, some of what you just learned will be lost.

  5. Drink water. Lots of it.

    Your brain works best in a nice bath of fluid. Dehydration (which can happen before you ever feel thirsty) decreases cognitive function.

  6. Talk about it. Out loud.

    Speaking activates a different part of the brain. If you’re trying to understand something, or increase your chance of remembering it later, say it out loud. Better still, try to explain it out loud to someone else. You’ll learn more quickly, and you might uncover ideas you hadn’t known were there when you were reading about it.

  7. Listen to your brain.

    Pay attention to whether your brain is getting overloaded. If you find yourself starting to skim the surface or forget what you just read, it’s time for a break. Once you go past a certain point, you won’t learn faster by trying to shove more in, and you might even hurt the process.

  8. Feel something.

    Your brain needs to know that this matters. Get involved with the stories. Make up your own captions for the photos. Groaning over a bad joke is still better than feeling nothing at all.

  9. Write a lot of software!

    There’s only one way to learn to program: writing a lot of code. And that’s what you’re going to do throughout this book. Coding is a skill, and the only way to get good at it is to practice. We’re going to give you a lot of practice: every chapter has exercises that pose a problem for you to solve. Don’t just skip over them—a lot of the learning happens when you solve the exercises. We included a solution to each exercise—don’t be afraid to peek at the solution if you get stuck! (It’s easy to get snagged on something small.) But try to solve the problem before you look at the solution. And definitely get it working before you move on to the next part of the book.

What you need for this book

We wrote this book using Visual C# 2010 Express Edition, which uses C# 4.0 and .NET Framework 4.0. All of the screenshots that you see throughout the book were taken from that edition, so we recommend that you use it. If you’re using Visual Studio 2010 Professional, Premium, Ultimate or Test Professional editions, you’ll see some small differences, which we’ve pointed out wherever possible. You can download the Express Edition for free from Microsoft’s website—it installs cleanly alongside other editions, as well as previous versions of Visual Studio.

Read me

This is a learning experience, not a reference book. We deliberately stripped out everything that might get in the way of learning whatever it is we’re working on at that point in the book. And the first time through, you need to begin at the beginning, because the book makes assumptions about what you’ve already seen and learned.

image with no caption

The activities are NOT optional.

The exercises and activities are not add-ons; they’re part of the core content of the book. Some of them are to help with memory, some for understanding, and some to help you apply what you’ve learned. Don’t skip the written problems. The pool puzzles are the only things you don’t have to do, but they’re good for giving your brain a chance to think about twisty little logic puzzles.

The redundancy is intentional and important.

One distinct difference in a Head First book is that we want you to really get it. And we want you to finish the book remembering what you’ve learned. Most reference books don’t have retention and recall as a goal, but this book is about learning, so you’ll see some of the same concepts come up more than once.

image with no caption

Do all the exercises!

The one big assumption that we made when we wrote this book is that you want to learn how to program in C#. So we know you want to get your hands dirty right away, and dig right into the code. We gave you a lot of opportunities to sharpen your skills by putting exercises in every chapter. We’ve labeled some of them “Do this!”—when you see that, it means that we’ll walk you through all of the steps to solve a particular problem. But when you see the Exercise logo with the running shoes, then we’ve left a big portion of the problem up to you to solve, and we gave you the solution that we came up with. Don’t be afraid to peek at the solution—it’s not cheating! But you’ll learn the most if you try to solve the problem first.

image with no caption

We’ve also placed all the exercise solutions’ source code on the web so you can download it. You’ll find it at

The “Brain Power” exercises don’t have answers.

For some of them, there is no right answer, and for others, part of the learning experience of the Brain Power activities is for you to decide if and when your answers are right. In some of the Brain Power exercises you will find hints to point you in the right direction.

image with no caption

The technical review team

image with no caption

Lisa Kellner

image with no caption

Chris Burrows


We’re especially grateful for Chris’s insight and almost ridiculously helpful feedback.

image with no caption

Nick Paladino


David really helped us out, especially with some very neat IDE tricks.

image with no caption

David Sterling


Not pictured (but just as awesome are the reviewers from the first edition): Joe Albahari, Jay Hilyard, Aayam Singh, Theodore, Peter Ritchie, Bill Meitelski Andy Parker, Wayne Bradney, Dave Murdoch, Bridgette Julie Landers. And special thanks to Jon Skeet for his thorough review and suggestions for the first edition!

Technical Reviewers:

When we wrote this book, it had a bunch of mistakes, issues, problems, typos, and terrible arithmetic errors. OK, it wasn’t quite that bad. But we’re still really grateful for the work that our technical reviewers did for the book. We would have gone to press with errors (including one or two big ones) had it not been for the most kick-ass review team EVER....

First of all, we really want to thank Chris Burrows and David Sterling for their enormous amount of technical guidance. We also want to thank Lisa Kellner—this is our sixth book that she’s reviewed for us, and she made a huge difference in the readability of the final product. Thanks, Lisa! And special thanks to Nick Paladino. Thanks!

Chris Burrows is a developer at Microsoft on the C# Compiler team who focused on design and implementation of language features in C# 4.0, most notably dynamic.

David Sterling has worked on the Visual C# Compiler team for nearly 3 years.

Nicholas Paldino has been a Microsoft MVP for .NET/C# since the discipline’s inception in the MVP program and has over 13 years of experience in the programming industry, specifically targeting Microsoft technologies.


Our editor:

We want to thank our editors, Brett McLaughlin and Courtney Nash, for editing this book. Brett helped with a lot of the narrative, and the comic idea in Chapter 14 was completely his, and we think it turned out really well. Thanks!

image with no caption

The O’Reilly team:

image with no caption

Lou Barr is an amazing graphic designer who went above and beyond on this one, putting in unbelievable hours and coming up with some pretty amazing visuals. If you see anything in this book that looks fantastic, you can thank her (and her mad InDesign skillz) for it. She did all of the monster and alien graphics for the labs, and the entire comic book. Thanks so much, Lou! You are our hero, and you’re awesome to work with.

image with no caption

There are so many people at O’Reilly we want to thank that we hope we don’t forget anyone. Special thanks to production editor Rachel Monaghan, indexer Lucie Haskins, Emily Quill for her sharp proofread, Ron Bilodeau for volunteering his time and preflighting expertise, and Sanders Kleinfeld for offering one last sanity check—all of whom helped get this book from production to press in record time. And as always, we love Mary Treseler, and can’t wait to work with her again! And a big shout out to our other friends and editors, Andy Oram and Mike Hendrickson. And if you’re reading this book right now, then you can thank the greatest publicity team in the industry: Marsee Henon, Sara Peyton, Mary Rotman, Jessica Boyd, Kathryn Barrett, and the rest of the folks at Sebastopol.

Safari® Books Online

image with no caption

Safari Books Online is an on-demand digital library that lets you easily search over 7,500 technology and creative reference books and videos to find the answers you need quickly.

With a subscription, you can read any page and watch any video from our library online. Read books on your cell phone and mobile devices. Access new titles before they are available for print, and get exclusive access to manuscripts in development and post feedback for the authors. Copy and paste code samples, organize your favorites, download chapters, bookmark key sections, create notes, print out pages, and benefit from tons of other time-saving features.

O’Reilly Media has uploaded this book to the Safari Books Online service. To have full digital access to this book and others on similar topics from O’Reilly and other publishers, sign up for free at

The best content for your career. Discover unlimited learning on demand for around $1/day.