Head First C#: A Learner's Guide to Real-World Programming with Visual C# and .NET / Edition 2

Paperback (Print)
Used and New from Other Sellers
Used and New from Other Sellers
from $12.70
Usually ships in 1-2 business days
(Save 74%)
Other sellers (Paperback)
  • All (9) from $12.70   
  • New (1) from $215.00   
  • Used (8) from $12.70   
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any BN.com coupons and promotions
Seller since 2014

Feedback rating:



New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Page 1 of 1
Showing All
Sort by


You want to learn C# programming, but you're not sure you want to suffer through another tedious technical book. You're in luck: Head First C# introduces this language in a fun, visual way. You'll quickly learn everything from creating your first program to learning sophisticated coding skills with C# 4.0, Visual Studio 2010 and .NET 4, while avoiding common errors that frustrate many students.

The second edition offers several hands-on labs along the way to help you build and test programs using skills you've learned up to that point. In the final lab, you'll put everything together. From objects to garbage collection and from exceptions to interactions, you'll learn C# in a way that engages and entertains your brain. Here are a few of the topics you'll learn:

  • Start by building a useful application with pre-built components in Visual Studio 2010
  • Discover how objects work, using real-world examples
  • Store numbers, text, and other basic data types using primitives
  • Save complex data in files and databases with great C# tools
  • Build intuitive and easy-to-use interfaces by following simple rules
  • Design your code to catch exceptions — things you don't expect
  • Develop good programming habits, such as refactoring code and applying unit tests
  • Learn how web services put your programs in touch with the rest of the world
  • Make it easy for other people to install your software
Read More Show Less

Product Details

  • ISBN-13: 9781449380342
  • Publisher: O'Reilly Media, Incorporated
  • Publication date: 6/10/2010
  • Edition description: Second Edition
  • Edition number: 2
  • Pages: 797
  • Product dimensions: 8.00 (w) x 9.20 (h) x 1.80 (d)

Meet the Author

Andrew Stellman, despite being raised a New Yorker, has lived in Pittsburgh twice. The first time was when he graduated from Carnegie Mellon's School of Computer Science, and then again when he and Jenny were starting their consulting business and writing their first project management book for O'Reilly. When he moved back to his hometown, his first job after college was as a programmer at EMI-Capitol Records—which actually made sense, since he went to LaGuardia High School of Music and Art and the Performing Arts to study cello and jazz bass guitar. He and Jenny first worked together at that same financial software company, where he was managing a team of programmers. He's since managed various teams of software engineers, requirements analysts, and led process improvement efforts. Andrew keeps himself busy eating an enormous amount of string cheese and Middle Eastern desserts, playing music (but video games even more), studying taiji and aikido, having a girlfriend named Lisa, and owning a pomeranian. For more information about Andrew, Jennifer Greene, and their books, visit http://www.stellman-greene.com.

Jennifer Greene has managed just about every aspect of software development during her career. She spent the past 15 years building software for many different kinds of companies, including small start-ups and huge companies. Jenny's built software test teams and has helped many companies diagnose and deal with habitual process problems so they could build better software. Since her start in software test and process definition, she's branched out into development management and project management. Jenny is currently managing a large development team for a global media company.

Read More Show Less

Table of Contents

Advance Praise for Head First C#;
Praise for other Head First books;
How to Use this Book: Intro;
Who is this book for?;
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;
Chapter 1: Get Productive with C#: Visual Applications, in 10 minutes or less;
1.1 Why you should learn C#;
1.2 C# and the Visual Studio IDE make lots of things easy;
1.3 Help the CEO go paperless;
1.4 Get to know your users’ needs before you start building your program;
1.5 Here’s what you’re going to build;
1.6 What you do in Visual Studio...;
1.7 What Visual Studio does for you...;
1.8 Develop the user interface;
1.9 Visual Studio, behind the scenes;
1.10 Add to the auto-generated code;
1.11 You can already run your application;
1.12 Where are my files?;
1.13 Here’s what we’ve done so far;
1.14 We need a database to store our information;
1.15 The IDE created a database;
1.16 SQL is its own language;
1.17 Creating the table for the Contact List;
1.18 The blanks on the contact card are columns in our People table;
1.19 Finish building the table;
1.20 Insert your card data into the database;
1.21 Connect your form to your database objects with a data source;
1.22 Add database-driven controls to your form;
1.23 Good programs are intuitive to use;
1.24 Test drive;
1.25 How to turn YOUR application into EVERYONE’S application;
1.26 Give your users the application;
1.27 You’re NOT done: test your installation;
1.28 You’ve built a complete data-driven application;
Chapter 2: It’s All Just Code: Under the hood;
2.1 When you’re doing this...;
2.2 ...the IDE does this;
2.3 Where programs come from;
2.4 The IDE helps you code;
2.5 When you change things in the IDE, you’re also changing your code;
2.6 Anatomy of a program;
2.7 Your program knows where to start;
2.8 You can change your program’s entry point;
2.9 Two classes can be in the same namespace;
2.10 Your programs use variables to work with data;
2.11 C# uses familiar math symbols;
2.12 Use the debugger to see your variables change;
2.13 Loops perform an action over and over;
2.14 Time to start coding;
2.15 if/else statements make decisions;
2.16 Set up conditions and see if they’re true;
Chapter 3: Objects: Get Oriented!: Making code make sense;
3.1 How Mike thinks about his problems;
3.2 How Mike’s car navigation system thinks about his problems;
3.3 Mike’s Navigator class has methods to set and modify routes;
3.4 Use what you’ve learned to build a program that uses a class;
3.5 Mike gets an idea;
3.6 Mike can use objects to solve his problem;
3.7 You use a class to build an object;
3.8 When you create a new object from a class, it’s called an instance of that class;
3.9 A better solution...brought to you by objects!;
3.10 An instance uses fields to keep track of things;
3.11 Let’s create some instances!;
3.12 Thanks for the memory;
3.13 What’s on your program’s mind;
3.14 You can use class and method names to make your code intuitive;
3.15 Give your classes a natural structure;
3.16 Class diagrams help you organize your classes so they make sense;
3.17 Build a class to work with some guys;
3.18 Create a project for your guys;
3.19 Build a form to interact with the guys;
3.20 There’s an easier way to initialize objects;
Chapter 4: Types and References: It’s 10:00. Do you know where your data is?;
4.1 The variable’s type determines what kind of data it can store;
4.2 A variable is like a data to-go cup;
4.3 10 pounds of data in a 5 pound bag;
4.4 Even when a number is the right size, you can’t just assign it to any variable;
4.5 When you cast a value that’s too big, C# will adjust it automatically;
4.6 C# does some casting automatically;
4.7 When you call a method, the arguments must be compatible with the types of the parameters;
4.8 Combining = with an operator;
4.9 Objects use variables, too;
4.10 Refer to your objects with reference variables;
4.11 References are like labels for your object;
4.12 If there aren’t any more references, your object gets garbage-collected;
4.13 Multiple references and their side effects;
4.14 Two references means TWO ways to change an object’s data;
4.15 A special case: arrays;
4.16 Arrays can contain a bunch of reference variables, too;
4.17 Welcome to Sloppy Joe’s Budget House o’ Discount Sandwiches!;
4.18 Objects use references to talk to each other;
4.19 Where no object has gone before;
4.20 Build a typing game;
C# Lab: A Day at the Races;
Chapter 5: Encapsulation: Keep your privates... private;
5.1 Kathleen is an event planner;
5.2 What does the estimator do?;
5.3 Kathleen’s Test Drive;
5.4 Each option should be calculated individually;
5.5 It’s easy to accidentally misuse your objects;
5.6 Encapsulation means keeping some of the data in a class private;
5.7 Use encapsulation to control access to your class’s methods and fields;
5.8 But is the realName field REALLY protected?;
5.9 Private fields and methods can only be accessed from inside the class;
5.10 Encapsulation keeps your data pristine;
5.11 Properties make encapsulation easier;
5.12 Build an application to test the Farmer class;
5.13 Use automatic properties to finish the class;
5.14 What if we want to change the feed multiplier?;
5.15 Use a constructor to initialize private fields;
Chapter 6: Inheritance: Your object’s family tree;
6.1 Kathleen does birthday parties, too;
6.2 We need a BirthdayParty class;
6.3 Build the Party Planner version 2.0;
6.4 One more thing...can you add a $100 fee for parties over 12?;
6.5 When your classes use inheritance, you only need to write your code once;
6.6 Build up your class model by starting general and getting more specific;
6.7 How would you design a zoo simulator?;
6.8 Use inheritance to avoid duplicate code in subclasses;
6.9 Different animals make different noises;
6.10 Think about how to group the animals;
6.11 Create the class hierarchy;
6.12 Every subclass extends its base class;
6.13 Use a colon to inherit from a base class;
6.14 We know that inheritance adds the base class fields, properties, and methods to the subclass...;
6.15 A subclass can override methods to change or replace methods it inherited;
6.16 Any place where you can use a base class, you can use one of its subclasses instead;
6.17 A subclass can hide methods in the superclass;
6.18 Use the override and virtual keywords to inherit behavior;
6.19 A subclass can access its base class using the base keyword;
6.20 When a base class has a constructor, your subclass needs one, too;
6.21 Now you’re ready to finish the job for Kathleen!;
6.22 Build a beehive management system;
6.23 First you’ll build the basic system;
6.24 Use inheritance to extend the bee management system;
Chapter 7: Interfaces and Abstract Classes: Making classes keep their promises;
7.1 Let’s get back to bee-sics;
7.2 We can use inheritance to create classes for different types of bees;
7.3 An interface tells a class that it must implement certain methods and properties;
7.4 Use the interface keyword to define an interface;
7.5 Now you can create an instance of NectarStinger that does both jobs;
7.6 Classes that implement interfaces have to include ALL of the interface’s methods;
7.7 Get a little practice using interfaces;
7.8 You can’t instantiate an interface, but you can reference an interface;
7.9 Interface references work just like object references;
7.10 You can find out if a class implements a certain interface with “is”;
7.11 Interfaces can inherit from other interfaces;
7.12 The RoboBee 4000 can do a worker bee’s job without using valuable honey;
7.13 is tells you what an object implements, as tells the compiler how to treat your object;
7.14 A CoffeeMaker is also an Appliance;
7.15 Upcasting works with both objects and interfaces;
7.16 Downcasting lets you turn your appliance back into a coffee maker;
7.17 Upcasting and downcasting work with interfaces, too;
7.18 There’s more than just public and private;
7.19 Access modifiers change visibility;
7.20 Some classes should never be instantiated;
7.21 An abstract class is like a cross between a class and an interface;
7.22 Like we said, some classes should never be instantiated;
7.23 An abstract method doesn’t have a body;
7.24 Polymorphism means that one object can take many different forms;
Chapter 8: Enums and Collections; Storing lots of data;
8.1 Strings don’t always work for storing categories of data;
8.2 Enums let you work with a set of valid values;
8.3 Enums let you represent numbers with names;
8.4 We could use an array to create a deck of cards...;
8.5 Arrays are hard to work with;
8.6 Lists make it easy to store collections of...anything;
8.7 Lists are more flexible than arrays;
8.8 Lists shrink and grow dynamically;
8.9 Generics can store any type;
8.10 Collection initializers work just like object initializers;
8.11 Let’s create a List of Ducks;
8.12 Lists are easy, but SORTING can be tricky;
8.13 IComparable>Duck< helps your list sort its ducks;
8.14 Use IComparer to tell your List how to sort;
8.15 Create an instance of your comparer object;
8.16 IComparer can do complex comparisons;
8.17 Overriding a ToString() method lets an object describe itself;
8.18 Update your foreach loops to let your Ducks and Cards print themselves;
8.19 You can upcast an entire list using IEnumerable;
8.20 You can build your own overloaded methods;
8.21 Use a dictionary to store keys and values;
8.22 The Dictionary Functionality Rundown;
8.23 Build a program that uses a Dictionary;
8.24 And yet MORE collection types...;
8.25 A queue is FIFO—First In, First Out;
8.26 A stack is LIFO—Last In, First Out;
C# Lab: The Quest;
Chapter 9: Reading and Writing Files: Save the byte array, save the world;
9.1 .NET uses streams to read and write data;
9.2 Different streams read and write different things;
9.3 A FileStream reads and writes bytes to a file;
9.4 How to write text to a file in 3 simple steps;
9.5 The Swindler launches another diabolical plan;
9.6 Reading and writing using two objects;
9.7 Data can go through more than one stream;
9.8 Use built-in objects to pop up standard dialog boxes;
9.9 Dialog boxes are just another .NET control;
9.10 Dialog boxes are objects, too;
9.11 Use the built-in File and Directory classes to work with files and directories;
9.12 Use file dialogs to open and save files (all with just a few lines of code);
9.13 IDisposable makes sure your objects are disposed of properly;
9.14 Avoid file system errors with using statements;
9.15 Trouble at work;
9.16 Writing files usually involves making a lot of decisions;
9.17 Use a switch statement to choose the right option;
9.18 Use a switch statement to let your deck of cards read from a file or write itself out to one;
9.19 Add an overloaded Deck() constructor that reads a deck of cards in from a file;
9.20 What happens to an object when it’s serialized?;
9.21 But what exactly IS an object’s state? What needs to be saved?;
9.22 When an object is serialized, all of the objects it refers to get serialized, too...;
9.23 Serialization lets you read or write a whole object all at once;
9.24 If you want your class to be serializable, mark it with the [Serializable] attribute;
9.25 Let’s serialize and deserialize a deck of cards;
9.26 .NET uses Unicode to store characters and text;
9.27 C# can use byte arrays to move data around;
9.28 Use a BinaryWriter to write binary data;
9.29 You can read and write serialized files manually, too;
9.30 Find where the files differ, and use that information to alter them;
9.31 Working with binary files can be tricky;
9.32 Use file streams to build a hex dumper;
9.33 StreamReader and StreamWriter will do just fine (for now);
9.34 Use Stream.Read() to read bytes from a stream;
Chapter 10: Exception Handling: Putting out fires gets old;
10.1 Brian needs his excuses to be mobile;
10.2 When your program throws an exception, .NET generates an Exception object;
10.3 Brian’s code did something unexpected;
10.4 All exception objects inherit from Exception;
10.5 The debugger helps you track down and prevent exceptions in your code;
10.6 Use the IDE’s debugger to ferret out exactly what went wrong in the Excuse Manager;
10.7 Uh oh—the code’s still got problems...;
10.8 Handle exceptions with try and catch;
10.9 What happens when a method you want to call is risky?;
10.10 Use the debugger to follow the try/catch flow;
10.11 If you have code that ALWAYS should run, use a finally block;
10.12 Use the Exception object to get information about the problem;
10.13 Use more than one catch block to handle multiple types of exceptions;
10.14 One class throws an exception, another class catches the exception;
10.15 Bees need an OutOfHoney exception;
10.16 An easy way to avoid a lot of problems: using gives you try and finally for free;
10.17 Exception avoidance: implement IDisposable to do your own cleanup;
10.18 The worst catch block EVER: catch-all plus comments;
10.19 Temporary solutions are OK (temporarily);
10.20 A few simple ideas for exception handling;
10.21 Brian finally gets his vacation...;
Chapter 11: Events and Delegates: What your code does when you’re not looking;
11.1 Ever wish your objects could think for themselves?;
11.2 But how does an object KNOW to respond?;
11.3 When an EVENT occurs...objects listen;
11.4 One object raises its event, others listen for it...;
11.5 Then, the other objects handle the event;
11.6 Connecting the dots;
11.7 The IDE creates event handlers for you automatically;
11.8 Generic EventHandlers let you define your own event types;
11.9 The forms you’ve been building all use events;
11.10 One event, multiple handlers;
11.11 Connecting event senders with event receivers;
11.12 A delegate STANDS IN for an actual method;
11.13 Delegates in action;
11.14 An object can subscribe to an event...;
11.15 Use a callback to control who’s listening;
11.16 A callback is just a way to use delegates;
Chapter 12: Review and Preview: Knowledge, power, and building cool stuff;
12.1 You’ve come a long way, baby;
12.2 We’ve also become beekeepers;
12.3 The beehive simulator architecture;
12.4 Building the beehive simulator;
12.5 Life and death of a flower;
12.6 Now we need a Bee class;
12.7 P. A. H. B. (Programmers Against Homeless Bees);
12.8 The hive runs on honey;
12.9 Filling out the Hive class;
12.10 The hive’s Go() method;
12.11 We’re ready for the World;
12.12 We’re building a turn-based system;
12.13 Here’s the code for World;
12.14 Giving the bees behavior;
12.15 The main form tells the world to Go();
12.16 We can use World to get statistics;
12.17 Timers fire events over and over again;
12.18 The timer’s using an event handler behind the scenes;
12.19 Add a timer to the simulator;
12.20 Test drive;
12.21 Let’s work with groups of bees;
12.22 A collection collects...DATA;
12.23 LINQ makes working with data in collections and databases easy;
12.24 Test drive (Part 2);
12.25 One final challenge: Open and Save;
Chapter 13: Controls and Graphics: Make it pretty;
13.1 You’ve been using controls all along to interact with your programs;
13.2 Form controls are just objects;
13.3 Use controls to animate the beehive simulator;
13.4 Add a renderer to your architecture;
13.5 The renderer draws everything in the world on the two forms;
13.6 Controls are well suited for visual display elements;
13.7 Build your first animated control;
13.8 BeeControl is LIKE a PictureBox...so let’s start by INHERITING from PictureBox;
13.9 Create a button to add the BeeControl to your form;
13.10 Your controls need to dispose their controls, too!;
13.11 A UserControl is an easy way to build a control;
13.12 Your simulator’s renderer will use your BeeControl to draw animated bees on your forms;
13.13 Add the hive and field forms to the project;
13.14 Build the renderer;
13.15 Now connect the main form to your two new forms, HiveForm and FieldForm;
13.16 Test drive...ahem...buzz;
13.17 Looks great, but something’s not quite right...;
13.18 Let’s take a closer look at those performance issues;
13.19 You resized your Bitmaps using a Graphics object;
13.20 Your image resources are stored in Bitmap objects;
13.21 Use System.Drawing to TAKE CONTROL of graphics yourself;
13.22 A 30-second tour of GDI+ graphics;
13.23 Use graphics to draw a picture on a form;
13.24 Graphics can fix our transparency problem...;
13.25 Use the Paint event to make your graphics stick;
13.26 A closer look at how forms and controls repaint themselves;
13.27 Double buffering makes animation look a lot smoother;
13.28 Double buffering is built into forms and controls;
13.29 Use a Graphics object and an event handler for printing;
13.30 PrintDocument works with the print dialog and print preview window objects;
Chapter 14: Captain Amazing: The Death of the Object;
14.1 Your last chance to DO something... your object’s finalizer;
14.2 When EXACTLY does a finalizer run?;
14.3 Dispose() works with using, finalizers work with garbage collection;
14.4 Finalizers can’t depend on stability;
14.5 Make an object serialize itself in its Dispose();
14.6 A struct looks like an object...;
14.7 ...but isn’t an object;
14.8 Values get copied; references get assigned;
14.9 Structs are value types; objects are reference types;
14.10 The stack vs. the heap: more on memory;
14.11 Use out parameters to make a method return more than one value;
14.12 Pass by reference using the ref modifier;
14.13 Use optional parameters to set default values;
14.14 Use nullable types when you need nonexistent values;
14.15 Nullable types help you make your programs more robust;
14.16 Captain Amazing...not so much;
14.17 Extension methods add new behavior to EXISTING classes;
14.18 Extending a fundamental type: string;
Chapter 15: LINQ: Get control of your data;
15.1 An easy project...;
15.2 ...but the data’s all over the place;
15.3 LINQ can pull data from multiple sources;
15.4 .NET collections are already set up for LINQ;
15.5 LINQ makes queries easy;
15.6 LINQ is simple, but your queries don’t have to be;
15.7 LINQ is versatile;
15.8 LINQ can combine your results into groups;
15.9 Combine Jimmy’s values into groups;
15.10 Use join to combine two collections into one query;
15.11 Jimmy saved a bunch of dough;
15.12 Connect LINQ to a SQL database;
15.13 Use a join query to connect Starbuzz and Objectville;
C# Lab: Invaders;
Leftovers: The top 11 things we wanted to include in this book;
#1. The Basics;
#2. Namespaces and assemblies;
#3. Use BackgroundWorker to make your UI responsive;
#4. The Type class and GetType();
#5. Equality, IEquatable, and Equals();
#6. Using yield return to create enumerable objects;
#7. Refactoring;
#8. Anonymous types, anonymous methods, and lambda expressions;
#9. Serializing data using DataContractSerializer;
#10. LINQ to XML;
#11. Windows Presentation Foundation;
Did you know that C# and the .NET Framework can...;

Read More Show Less

Customer Reviews

Average Rating 4
( 12 )
Rating Distribution

5 Star


4 Star


3 Star


2 Star


1 Star


Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation


  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing 1 Customer Reviews
  • Posted June 6, 2010


    Do you want to learn how to use C#? If you do, then this book is for you. Authors Andrew Stellman and Jennifer Greene PSE, have done an outstanding job of writing the second edition of a book using Visual C# 2010 Express Edition, which uses C# 4.0 and .NET Framework 4.0.

    Stellman and Greene, begin by showing you how with Visual Studio IDE, you'll never have to spend hours writing obscure code to get a button to work again. Next, the authors show you how to get a lot of work done by using IDE. Then, they show you why objects are really useful. The authors continue by showing you the ins and outs of C#'s data types, and how to work with data in your program; and, even help you figure out a few dirty secrets about objects. Next, they show you the power of encapsulation. Then, they show you how to subclass an object to get its behavior, but keep the flexibility to make changes to that behavior. The authors continue by showing you how interfaces let you work with any class that can do the job. Next, they show you how collections let you store, sort and manage all of the data that your programs need to pore through. Then, the authors show you how to write data to a file, and then how to read that information back in from a file. They continue by showing you how to write code to deal with problems that come up by using exception handling. Next, the authors show you what events are all about: One object publishes an event, the other objects subscribe, and everyone works together to keep things moving. Then, they show you how to build some software. They continue by discussing the Graphics object, bitmaps, and a determination to not accept the graphics status quo. Finally, the authors discuss how LINQ not only lets you query data in a simple intuitive way, but, how it lets you group data, and merge data from different data sources.

    This most excellent book is a learning experience, not a reference book. In other words, this book makes assumptions about what you've already seen and learned.

    2 out of 2 people found this review helpful.

    Was this review helpful? Yes  No   Report this review
Sort by: Showing 1 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)