Head First C#

Overview

Head First C# is a complete learning experience for learning how to program with C#, XAML, the .NET Framework, and Visual Studio. Fun and highly visual, this introduction to C# is designed to keep you engaged and entertained from first page to last.

You’ll build a fully functional video game in the opening chapter, and then learn how to use classes and object-oriented programming, draw graphics and animation, and query data with LINQ and serialize it to files. And you'll do it ...

See more details below
Paperback (Third Edition)
$29.99
BN.com price
(Save 40%)$49.99 List Price

Pick Up In Store

Reserve and pick up in 60 minutes at your local store

Other sellers (Paperback)
  • All (16) from $25.74   
  • New (14) from $28.06   
  • Used (2) from $25.74   
Head First C#

Available on NOOK devices and apps  
  • NOOK Devices
  • NOOK HD/HD+ Tablet
  • NOOK
  • NOOK Color
  • NOOK Tablet
  • Tablet/Phone
  • NOOK for Windows 8 Tablet
  • NOOK for iOS
  • NOOK for Android
  • NOOK Kids for iPad
  • PC/Mac
  • NOOK for Windows 8
  • NOOK for PC
  • NOOK for Mac
  • NOOK Study
  • NOOK for Web

Want a NOOK? Explore Now

NOOK Book (eBook)
$22.99
BN.com price
(Save 42%)$39.99 List Price

Overview

Head First C# is a complete learning experience for learning how to program with C#, XAML, the .NET Framework, and Visual Studio. Fun and highly visual, this introduction to C# is designed to keep you engaged and entertained from first page to last.

You’ll build a fully functional video game in the opening chapter, and then learn how to use classes and object-oriented programming, draw graphics and animation, and query data with LINQ and serialize it to files. And you'll do it all by creating games, solving puzzles, and doing hands-on projects. By the time you're done, you'll be a solid C# programmer—and you'll have a great time along the way!

  • Create a fun arcade game in the first chapter, and build games and other projects throughout the book
  • Learn how to use XAML to design attractive and interactive pages and windows
  • Build modern Windows Store apps using the latest Microsoft technology
  • Learn WPF (Windows Presentation Foundation) using the downloadable WPF Learner's Guide
  • Using the Model-View-ViewModel (MVVM) pattern to create robust architecture
  • Build a bonus Windows Phone project and run it in the Visual Studio Windows Phone emulator

Projects in the book work with all editions of Visual Studio, including the free Express editions.

Read More Show Less

Product Details

  • ISBN-13: 9781449343507
  • Publisher: O'Reilly Media, Incorporated
  • Publication date: 9/2/2013
  • Edition description: Third Edition
  • Edition number: 3
  • Pages: 960
  • Sales rank: 157,864
  • Product dimensions: 8.00 (w) x 9.20 (h) x 1.80 (d)

Meet the Author

Bestselling O'Reilly authors Jennifer Greene and Andrew Stellman have been building software and writing about software engineering together since they first met in 1998. Their first book, Applied Software Project Management, was published by O’Reilly in 2005. Other Stellman and Greene books for O’Reilly include Beautiful Teams (2009), and their first book in the Head First series, Head First PMP (2007). They founded Stellman & Greene Consulting in 2003 to build a really neat software project for scientists studying herbicide exposure in Vietnam vets. In addition to building software and writing books, they’ve provided training and consulted for companies and spoken at conferences and meetings of software engineers, architects and project managers.

Jenny studied philosophy in college but, like everyone else in the field, couldn’t find a job doing it. Luckily, she’s a great software engineer, so she started out working at an online service, and that’s the first time she really got a good sense of what good software development looked like. She moved to New York in 1998 to work on software quality at a financial software company. She’s managed a teams of developers, testers and PMs on software projects in media and finance since then. She’s traveled all over the world to work with different software teams and build all kinds of cool projects.

Andrew, despite being raised a New Yorker, has lived in Minneapolis, Geneva, and 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 book for O’Reilly. He and Jenny first worked together at a company on Wall Street that built financial software, where he was managing a team of programmers. Over the years he’s been a Vice President at a major investment bank, architected large-scale real-time back end systems, managed large international software teams, and consulted for companies, schools, and organizations, including Microsoft, the National Bureau of Economic Research, and MIT. He’s had the privilege working with some pretty amazing programmers during that time, and likes to think that he’s learned a few things from them.

Read More Show Less

Table of Contents

;
Head First C#;
What will you learn from this book?;
Why does this book look so different?;
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;
Acknowledgments;
Safari® Books Online;
Chapter 1: Start Building With c#: Build something cool, fast!;
1.1 Why you should learn C#;
1.2 C# and the Visual Studio IDE make lots of things easy;
1.3 What you do in Visual Studio...;
1.4 What Visual Studio does for you...;
1.5 Aliens attack!;
1.6 Only you can help save the Earth;
1.7 Here’s what you’re going to build;
1.8 Start with a blank application;
1.9 Set up the grid for your page;
1.10 Add controls to your grid;
1.11 Use properties to change how the controls look;
1.12 Controls make the game work;
1.13 You’ve set the stage for the game;
1.14 What you’ll do next;
1.15 Add a method that does something;
1.16 Fill in the code for your method;
1.17 Finish the method and run your program;
1.18 Here’s what you’ve done so far;
1.19 Add timers to manage the gameplay;
1.20 Make the Start button work;
1.21 Run the program to see your progress;
1.22 Add code to make your controls interact with the player;
1.23 Dragging humans onto enemies ends the game;
1.24 Your game is now playable;
1.25 Make your enemies look like aliens;
1.26 Add a splash screen and a tile;
1.27 Publish your app;
1.28 Use the Remote Debugger to sideload your app;
1.29 Start remote debugging;
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 Anatomy of a program;
2.6 Two classes can be in the same namespace;
2.7 Your programs use variables to work with data;
2.8 C# uses familiar math symbols;
2.9 Use the debugger to see your variables change;
2.10 Loops perform an action over and over;
2.11 if/else statements make decisions;
2.12 Build an app from the ground up;
2.13 Make each button do something;
2.14 Set up conditions and see if they’re true;
2.15 Windows Desktop apps are easy to build;
2.16 Rebuild your app for Windows Desktop;
2.17 Your desktop app knows where to start;
2.18 You can change your program’s entry point;
2.19 When you change things in the IDE, you’re also changing your code;
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;
3.21 A few ideas for designing intuitive classes;
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 Debug the mileage calculator;
4.9 Combining = with an operator;
4.10 Objects use variables, too;
4.11 Refer to your objects with reference variables;
4.12 References are like labels for your object;
4.13 If there aren’t any more references, your object gets garbage-collected;
4.14 Multiple references and their side effects;
4.15 Two references means TWO ways to change an object’s data;
4.16 A special case: arrays;
4.17 Arrays can contain a bunch of reference variables, too;
4.18 Welcome to Sloppy Joe’s Budget House o’ Discount Sandwiches!;
4.19 Objects use references to talk to each other;
4.20 Where no object has gone before;
4.21 Build a typing game;
4.22 Controls are objects, just like any other object;
Chapter C# Lab: A Day at the Races;
5.1 The Spec: Build a Racetrack Simulator;
5.2 You’ll need three classes and a form;
5.3 Here’s your application architecture;
5.4 Here’s what your GUI should look like;
5.5 The Finished Product;
Chapter 5: Encapsulation: Keep your privates... private;
6.1 Kathleen is an event planner;
6.2 What does the estimator do?;
6.3 You’re going to build a program for Kathleen;
6.4 Kathleen’s test drive;
6.5 Each option should be calculated individually;
6.6 It’s easy to accidentally misuse your objects;
6.7 Encapsulation means keeping some of the data in a class private;
6.8 Use encapsulation to control access to your class’s methods and fields;
6.9 But is the RealName field REALLY protected?;
6.10 Private fields and methods can only be accessed from inside the class;
6.11 A few ideas for encapsulating classes;
6.12 Encapsulation keeps your data pristine;
6.13 Properties make encapsulation easier;
6.14 Build an application to test the Farmer class;
6.15 Use automatic properties to finish the class;
6.16 What if we want to change the feed multiplier?;
6.17 Use a constructor to initialize private fields;
Chapter 6: Inheritance: Your object’s family tree;
7.1 Kathleen does birthday parties, too;
7.2 We need a BirthdayParty class;
7.3 Build the Party Planner version 2.0;
7.4 One more thing...can you add a $100 fee for parties over 12?;
7.5 When your classes use inheritance, you only need to write your code once;
7.6 Build up your class model by starting general and getting more specific;
7.7 How would you design a zoo simulator?;
7.8 Use inheritance to avoid duplicate code in subclasses;
7.9 Different animals make different noises;
7.10 Think about how to group the animals;
7.11 Create the class hierarchy;
7.12 Every subclass extends its base class;
7.13 Use a colon to inherit from a base class;
7.14 We know that inheritance adds the base class fields, properties, and methods to the subclass...;
7.15 A subclass can override methods to change or replace methods it inherited;
7.16 Any place where you can use a base class, you can use one of its subclasses instead;
7.17 A subclass can hide methods in the superclass;
7.18 Use the override and virtual keywords to inherit behavior;
7.19 A subclass can access its base class using the base keyword;
7.20 When a base class has a constructor, your subclass needs one, too;
7.21 Now you’re ready to finish the job for Kathleen!;
7.22 Build a beehive management system;
7.23 How you’ll build the beehive management system;
7.24 Use inheritance to extend the bee management system;
Chapter 7: Interfaces and Abstract Classes: Making classes keep their promises;
8.1 Let’s get back to bee-sics;
8.2 We can use inheritance to create classes for different types of bees;
8.3 An interface tells a class that it must implement certain methods and properties;
8.4 Use the interface keyword to define an interface;
8.5 Now you can create an instance of NectarStinger that does both jobs;
8.6 Classes that implement interfaces have to include ALL of the interface’s methods;
8.7 Get a little practice using interfaces;
8.8 You can’t instantiate an interface, but you can reference an interface;
8.9 Interface references work just like object references;
8.10 You can find out if a class implements a certain interface with “is”;
8.11 Interfaces can inherit from other interfaces;
8.12 The RoboBee 4000 can do a worker bee’s job without using valuable honey;
8.13 is tells you what an object implements; as tells the compiler how to treat your object;
8.14 A CoffeeMaker is also an Appliance;
8.15 Upcasting works with both objects and interfaces;
8.16 Downcasting lets you turn your appliance back into a coffee maker;
8.17 Upcasting and downcasting work with interfaces, too;
8.18 There’s more than just public and private;
8.19 Access modifiers change visibility;
8.20 Some classes should never be instantiated;
8.21 An abstract class is like a cross between a class and an interface;
8.22 Like we said, some classes should never be instantiated;
8.23 An abstract method doesn’t have a body;
8.24 The Deadly Diamond of Death!;
8.25 Polymorphism means that one object can take many different forms;
Chapter 8: Enums and Collections: Storing Lots of Data;
9.1 Strings don’t always work for storing categories of data;
9.2 Enums let you work with a set of valid values;
9.3 Enums let you represent numbers with names;
9.4 We could use an array to create a deck of cards...;
9.5 Arrays are hard to work with;
9.6 Lists make it easy to store collections of...anything;
9.7 Lists are more flexible than arrays;
9.8 Lists shrink and grow dynamically;
9.9 Generics can store any type;
9.10 Collection initializers are similar to object initializers;
9.11 Let’s create a List of Ducks;
9.12 Lists are easy, but SORTING can be tricky;
9.13 IComparable>Duck< helps your list sort its ducks;
9.14 Use IComparer to tell your List how to sort;
9.15 Create an instance of your comparer object;
9.16 IComparer can do complex comparisons;
9.17 Overriding a ToString() method lets an object describe itself;
9.18 Update your foreach loops to let your Ducks and Cards print themselves;
9.19 You can upcast an entire list using IEnumerable;
9.20 You can build your own overloaded methods;
9.21 Use a dictionary to store keys and values;
9.22 The dictionary functionality rundown;
9.23 Build a program that uses a dictionary;
9.24 And yet MORE collection types...;
9.25 A queue is FIFO—First In, First Out;
9.26 A stack is LIFO—Last In, First Out;
Chapter 9: Reading and Writing Files: Save the last byte for me!;
10.1 .NET uses streams to read and write data;
10.2 Different streams read and write different things;
10.3 A FileStream reads and writes bytes to a file;
10.4 Write text to a file in three simple steps;
10.5 The Swindler launches another diabolical plan;
10.6 Reading and writing using two objects;
10.7 Data can go through more than one stream;
10.8 Use built-in objects to pop up standard dialog boxes;
10.9 Dialog boxes are just another WinForms control;
10.10 Dialog boxes are objects, too;
10.11 Use the built-in File and Directory classes to work with files and directories;
10.12 Use file dialogs to open and save files (all with just a few lines of code);
10.13 IDisposable makes sure your objects are disposed of properly;
10.14 Avoid filesystem errors with using statements;
10.15 Trouble at work;
10.16 Writing files usually involves making a lot of decisions;
10.17 Use a switch statement to choose the right option;
10.18 Use a switch statement to let your deck of cards read from a file or write itself out to one;
10.19 Add an overloaded Deck() constructor that reads a deck of cards in from a file;
10.20 What happens to an object when it’s serialized?;
10.21 But what exactly IS an object’s state? What needs to be saved?;
10.22 When an object is serialized, all of the objects it refers to get serialized, too...;
10.23 Serialization lets you read or write a whole object graph all at once;
10.24 If you want your class to be serializable, mark it with the [Serializable] attribute;
10.25 Let’s serialize and deserialize a deck of cards;
10.26 .NET uses Unicode to store characters and text;
10.27 C# can use byte arrays to move data around;
10.28 Use a BinaryWriter to write binary data;
10.29 You can read and write serialized files manually, too;
10.30 Find where the files differ, and use that information to alter them;
10.31 Working with binary files can be tricky;
10.32 Use file streams to build a hex dumper;
10.33 StreamReader and StreamWriter will do just fine (for now);
10.34 Use Stream.Read() to read bytes from a stream;
Chapter C# Lab: The Quest;
11.1 The spec: build an adventure game;
11.2 The design: building the form;
11.3 The architecture: using the objects;
11.4 Gameplay concerns are separated into the Game object;
11.5 Building the Game class;
11.6 Finding common behavior: movement;
11.7 The Mover class source code;
11.8 The Player class keeps track of the player;
11.9 Write the Move() method for the Player;
11.10 Add an Attack() method, too;
11.11 Bats, ghosts, and ghouls inherit from the Enemy class;
11.12 Write the different Enemy subclasses;
11.13 Weapon inherits from Mover; each weapon inherits from Weapon;
11.14 Different weapons attack in different ways;
11.15 Potions implement the IPotion interface;
11.16 The form brings it all together;
11.17 The form’s UpdateCharacters() method moves the PictureBoxes into position;
11.18 The fun’s just beginning!;
Chapter 10: Designing Windows Store Apps with Xaml: Taking your apps to the next level;
12.1 Brian’s running Windows 8;
12.2 Windows Forms use an object graph set up by the IDE;
12.3 Use the IDE to explore the object graph;
12.4 Windows Store apps use XAML to create UI objects;
12.5 Redesign the Go Fish! form as a Windows Store app page;
12.6 Page layout starts with controls;
12.7 Rows and columns can resize to match the page size;
12.8 Use the grid system to lay out app pages;
12.9 Data binding connects your XAML pages to your classes;
12.10 XAML controls can contain text...and more;
12.11 Use data binding to build Sloppy Joe a better menu;
12.12 Use static resources to declare your objects in XAML;
12.13 Use a data template to display objects;
12.14 INotifyPropertyChanged lets bound objects send updates;
12.15 Modify MenuMaker to notify you when the GeneratedDate property changes;
Chapter 11: Async, Await, and Data Contract Serialization: Pardon the interruption;
13.1 Brian runs into file trouble;
13.2 Windows Store apps use await to be more responsive;
13.3 Use the FileIO class to read and write files;
13.4 Build a slightly less simple text editor;
13.5 A data contract is an abstract definition of your object’s data;
13.6 Use async methods to find and open files;
13.7 KnownFolders helps you access high-profile folders;
13.8 The whole object graph is serialized to XML;
13.9 Stream some Guy objects to your app’s local folder;
13.10 Take your Guy Serializer for a test drive;
13.11 Use a Task to call one async method from another;
13.12 Build Brian a new Excuse Manager app;
13.13 Separate the page, excuse, and Excuse Manager;
13.14 Create the main page for the Excuse Manager;
13.15 Add the app bar to the main page;
13.16 Build the ExcuseManager class;
13.17 Add the code-behind for the page;
Chapter 12: Exception Handling: Putting out fires gets old;
14.1 Brian needs his excuses to be mobile;
14.2 Brian’s code did something unexpected;
14.3 All exception objects inherit from Exception;
14.4 The debugger helps you track down and prevent exceptions in your code;
14.5 Use the IDE’s debugger to ferret out exactly what went wrong in the Excuse Manager;
14.6 Uh oh—the code’s still got problems...;
14.7 Handle exceptions with try and catch;
14.8 What happens when a method you want to call is risky?;
14.9 Use the debugger to follow the try/catch flow;
14.10 If you have code that ALWAYS should run, use a finally block;
14.11 Use the Exception object to get information about the problem;
14.12 Use more than one catch block to handle multiple types of exceptions;
14.13 One class throws an exception that a method in another class can catch;
14.14 Bees need an OutOfHoney exception;
14.15 An easy way to avoid a lot of problems: using gives you try and finally for free;
14.16 Exception avoidance: implement IDisposable to do your own cleanup;
14.17 The worst catch block EVER: catch-all plus comments;
14.18 Temporary solutions are OK (temporarily);
14.19 A few simple ideas for exception handling;
14.20 Brian finally gets his vacation...;
Chapter 13: Captain Amazing The Death of the Object;
15.1 Your last chance to DO something...your object’s finalizer;
15.2 When EXACTLY does a finalizer run?;
15.3 Dispose() works with using; finalizers work with garbage collection;
15.4 Finalizers can’t depend on stability;
15.5 Make an object serialize itself in its Dispose();
15.6 A struct looks like an object...;
15.7 ...but isn’t an object;
15.8 Values get copied; references get assigned;
15.9 Structs are value types; objects are reference types;
15.10 The stack vs. the heap: more on memory;
15.11 Use out parameters to make a method return more than one value;
15.12 Pass by reference using the ref modifier;
15.13 Use optional parameters to set default values;
15.14 Use nullable types when you need nonexistent values;
15.15 Nullable types help you make your programs more robust;
15.16 “Captain” Amazing...not so much;
15.17 Extension methods add new behavior to EXISTING classes;
15.18 Extending a fundamental type: string;
Chapter 14: Querying Data and Building Apps with LINQ: Get Control of your Data;
16.1 Jimmy’s a Captain Amazing super-fan...;
16.2 ...but his collection’s all over the place;
16.3 LINQ can pull data from multiple sources;
16.4 .NET collections are already set up for LINQ;
16.5 LINQ makes queries easy;
16.6 LINQ is simple, but your queries don’t have to be;
16.7 Jimmy could use some help;
16.8 Start building Jimmy an app;
16.9 Use the new keyword to create anonymous types;
16.10 LINQ is versatile;
16.11 Add the new queries to Jimmy’s app;
16.12 LINQ can combine your results into groups;
16.13 Combine Jimmy’s values into groups;
16.14 Use join to combine two collections into one sequence;
16.15 Jimmy saved a bunch of dough;
16.16 Use semantic zoom to navigate your data;
16.17 Add semantic zoom to Jimmy’s app;
16.18 You made Jimmy’s day;
16.19 The IDE’s Split App template helps you build apps for navigating data;
Chapter 15: Events and Delegates: What your Code does When You’re Not Looking;
17.1 Ever wish your objects could think for themselves?;
17.2 But how does an object KNOW to respond?;
17.3 When an EVENT occurs...objects listen;
17.4 One object raises its event, others listen for it...;
17.5 Then, the other objects handle the event;
17.6 Connecting the dots;
17.7 The IDE generates event handlers for you automatically;
17.8 Generic EventHandlers let you define your own event types;
17.9 Windows Forms use many different events;
17.10 One event, multiple handlers;
17.11 Windows Store apps use events for process lifetime management;
17.12 Add process lifetime management to Jimmy’s comics;
17.13 XAML controls use routed events;
17.14 Create an app to explore routed events;
17.15 Connecting event senders with event listeners;
17.16 A delegate STANDS IN for an actual method;
17.17 Delegates in action;
17.18 An object can subscribe to an event...;
17.19 Use a callback to control who’s listening;
17.20 A callback is just a way to use delegates;
17.21 You can use callbacks with MessageDialog commands;
17.22 Use delegates to use the Windows settings charm;
Chapter 16: Architecting Apps with the Mvvm Pattern: Great apps on the inside and outside;
18.1 The Head First Basketball Conference needs an app;
18.2 But can they agree on how to build it?;
18.3 Do you design for binding or for working with data?;
18.4 MVVM lets you design for binding and data;
18.5 Use the MVVM pattern to start building the basketball roster app;
18.6 User controls let you create your own controls;
18.7 The ref needs a stopwatch;
18.8 MVVM means thinking about the state of the app;
18.9 Start building the stopwatch app’s Model;
18.10 Events alert the rest of the app to state changes;
18.11 Build the view for a simple stopwatch;
18.12 Add the stopwatch ViewModel;
18.13 Finish the stopwatch app;
18.14 Converters automatically convert values for binding;
18.15 Converters can work with many different types;
18.16 A style alters the appearance of a type of control;
18.17 Visual states make controls respond to changes;
18.18 Use DoubleAnimation to animate double values;
18.19 Use object animations to animate object values;
18.20 Build an analog stopwatch using the same ViewModel;
18.21 UI controls can be instantiated with C# code, too;
18.22 C# can build “real” animations, too;
18.23 Create a user control to animate a picture;
18.24 Make your bees fly around a page;
18.25 Use ItemsPanelTemplate to bind controls to a Canvas;
18.26 Congratulations! (But you’re not done yet...);
Chapter C# Lab: Invaders;
19.1 The grandfather of video games;
19.2 Your mission: defend the planet against wave after wave of invaders;
19.3 The architecture of Invaders;
19.4 Build out the object model for the Model;
19.5 Building the InvadersModel class;
19.6 The InvadersModel methods;
19.7 Filling out the InvadersModel class;
19.8 LINQ makes collision detection much easier;
19.9 Build the Invaders page for the View;
19.10 Maintain the play area’s aspect ratio;
19.11 Respond to swipe and keyboard input;
19.12 An AnimatedImage control displays the ships;
19.13 Add a control for the big stars;
19.14 A static InvadersHelper class helps the ViewModel;
19.15 Use the Settings charm to open an About pop up;
19.16 Build the ViewModel;
19.17 Handling user input;
19.18 Build the InvadersViewModel methods;
19.19 The View’s updated when the timer ticks;
19.20 The player’s ship can move and die;
19.21 “Shots fired!”;
19.22 And yet there’s more to do...;
Chapter 17: Bonus Project!: Build a Windows Phone app;
20.1 Bee Attack!;
20.2 Before you begin...;
Leftovers: The top things we wanted to include in this book;
#1. There’s so much more to Windows Store;
#2. The Basics;
#3. Namespaces and assemblies;
#4. Use BackgroundWorker to make your WinForms responsive;
#5. The Type class and GetType();
#6. Equality, IEquatable, and Equals();
#7. Using yield return to create enumerable objects;
#8. Refactoring;
#9. Anonymous types, anonymous methods, and lambda expressions;
#10. LINQ to XML;
#11. Windows Presentation Foundation;
Did you know that C# and the .NET Framework can...;

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

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

Reminder:

  • - 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

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