Chapter 1: Get Productive with C#: Visual Applications, in 10 minutes or less
Why you should learn C#
C# and the Visual Studio IDE make lots of things easy
Help the CEO go paperless
Get to know your users’ needs before you start building your program
Here’s what you’re going to build
What you do in Visual Studio…
What Visual Studio does for you…
Develop the user interface
Visual Studio, behind the scenes
Add to the auto-generated code
You can already run your application
We need a database to store our information
Creating the table for the Contact List
The blanks on contact card are columns in our People table
Finish building the table
Diagram your data so your application can access it
Insert your card data into the database
Connect your form to your database objects with a data source
Add database-driven controls to your form
Good programs are intuitive to use
How to turn YOUR application into EVERYONE’S application
Give your users the application
You’re NOT done: test your installation
You built a complete data-driven application
Chapter 2: It’s All Just Code: Under the Hood
When you’re doing this…
…the IDE does this
Where programs come from
The IDE helps you code
When you change things in the IDE, you’re also changing your code
Anatomy of a program
Your program knows where to start
You can change your program’s entry point
Two classes can be in the same namespace
Your programs use variables to work with data
C# uses familiar math symbols
Loops perform an action over and over again
Time to start coding
if/else statements make decisions
Set up conditions and see if they’re true
Chapter 3: Objects: Get Oriented!: Making Code Make Sense
How Mike thinks about his problems
How Mike’s car navigation system thinks about his problems
Mike’s Navigator class has methods to set and modify routes
Use what you’ve learned to build a simple application
Mike gets an idea
Mike can use objects to solve his problem
You use a class to build an object
When you create a new object from a class, it’s called an instance of that class.
A better solution… brought to you by objects!
An instance uses fields to keep track of things
Let’s create some instances!
Thanks for the memory
What’s on your program’s mind
You can use class and method names to make your code intuitive
Give your classes a natural structure
Class diagrams help you organize your classes so they make sense
Build a class to work with some guys
Create a project for your guys
Build a form to interact with the guys
There’s an even easier way to initialize objects
A few ideas for designing intuitive classes
Chapter 4: Types and References: It’s 10:00. Do you know where your data is?
The variable’s type determines what kind of data it can store
A variable is like a data to-go cup
10 pounds of data in a 5 pound bag
Even when a number is the right size, you can’t just assign it to any variable
When you cast a value that’s too big, C# will adjust it automatically
C# does some casting automatically
When you call a method, the variables must match the types of the parameters
Combining = with an operator
Objects use variables, too
Refer to your objects with reference variables
References are like labels for your object
If there aren’t any more references, your object gets garbage collected
Multiple references and their side effects
Two references means TWO ways to change an object’s data
A special case: arrays
Arrays can contain a bunch of reference variables, too
Welcome to Sloppy Joe’s Budget House o’ Discount Sandwiches!
Objects use references to talk to each other
Where no object has gone before
C# Lab 1: A Day at the Races
The Spec: Build a Racetrack Simulator
The Finished Product
Chapter 5: Encapsulation: Keep your privates… private
Kathleen is an event planner
What does the estimator do?
Kathleen’s Test Drive
Each option should be calculated individually
It’s easy to accidentally misuse your objects
Encapsulation means keeping some of the data in a class private
Use encapsulation to control access to your class’s methods and fields
But is the realName field REALLY protected?
Private fields and methods can only be accessed from inside the class
A few ideas for encapsulating classes
Encapsulation keeps your data pristine
Properties make encapsulation easier
Build an application to test the Farmer class
Use automatic properties to finish the class
What if we want to change the feed multiplier?
Use a constructor to initialize private fields
Chapter 6: Inheritance: Your object’s family tree
Kathleen does birthday parties, too
We need a BirthdayParty class
One more thing… can you add a $100 fee for parties over 12?
When your classes use inheritance, you only need to write your code once
Build up your class model by starting general and getting more specific
How would you design a zoo simulator?
Use inheritance to avoid duplicate code in subclasses
Different animals make different noises
Think about how to group the animals
Create the class hierarchy
Every subclass extends its base class
Use a colon to inherit from a base class
We know that inheritance adds the base class fields, properties, and methods to the subclass…
A subclass can override methods to change or replace methods it inherited
Any place where you can use a base class, you can use one of its subclasses instead
A subclass can access its base class using the base keyword
When a base class has a constructor, your subclass needs one too
Now you’re ready to finish the job for Kathleen!
Build a beehive management system
First you’ll build the basic system
Use inheritance to extend the bee management system
Chapter 7: Interfaces and Abstract Classes: Making classes keep their promises
Let’s get back to bee-sics
We can use inheritance to create classes for different types of bees
An interface tells a class that it must implement certain methods and properties
Use the interface keyword to define an interface
Now you can create an instance of NectarStinger that does both jobs
Classes that implement interfaces have to include ALL of the interface’s methods
Get a little practice using interfaces
You can’t instantiate an interface, but you can reference an interface
Interface references work just like object references
You can find out if a class implements a certain interface with “is”
Interfaces can inherit from other interfaces
The RoboBee 4000 can do a worker bee’s job without using valuable honey
is tells you what an object implements, as tells the compiler how to treat your object
A CoffeeMaker is also an Appliance
Upcasting works with both objects and interfaces
Downcasting lets you turn your appliance back into a coffee maker
Upcasting and downcasting work with interfaces, too
There’s more than just public and private
Access modifiers change scope
Some classes should never be instantiated
An abstract class is like a cross between a class and an interface
Like we said, some classes should never be instantiated
An abstract method doesn’t have a body
Polymorphism means that one object can take many different forms
Chapter 8: Enums and Collections: Storing lots of data
Strings don’t always work for storing categories of data
Enums let you enumerate a set of valid values
Enums let you represent numbers with names
We could use an array to create a deck of cards…
Arrays are hard to work with
Lists make it easy to store collections of… anything
Lists are more flexible than arrays
Lists shrink and grow dynamically
List objects can store any type
Collection initializers work just like object initializers
Let’s create a list of Ducks
Lists are easy, but SORTING can be tricky
Two ways to sort your ducks
Use IComparer to tell your List how to sort
Create an instance of your comparer object
IComparer can do complex comparisons
Use a dictionary to store keys and values
The Dictionary Functionality Rundown
Your key and value can be different types, too
You can build your own overloaded methods
And yet MORE collection types…
A queue is FIFO — First In, First Out
A stack is LIFO — Last In, First Out
C# Lab 2: The Quest
The spec: build an adventure game
The fun’s just beginning!
Chapter 9: Reading and Writing Files: Save the byte array, save the world
C# uses streams to read and write data
Different streams read and write different things
A FileStream writes bytes to a file
Reading and writing takes two objects
Data can go through more than one stream
Use built-in objects to pop up standard dialog boxes
Dialog boxes are objects, too
Use the built-in File and Directory classes to work with files and directories
Use File Dialogs to open and save files (all with just a few lines of code)
IDisposable makes sure your objects are disposed properly
Avoid file system errors with using statements
Writing files usually involves making a lot of decisions
Use a switch statement to choose the right option
Use a switch statement to let your deck of cards read from a file or write itself out to one
Add an overloaded Deck() constructor that reads a deck of cards in from a file
What happens to an object when it’s serialized?
But what exactly IS an object’s state? What needs to be saved?
When an object is serialized, all of the objects it refers to get serialized too…
Serialization lets you read or write a whole object all at once
If you want your class to be serializable, mark it with the [Serializable] attribute
.NET converts text to Unicode automatically
C# can use byte arrays to move data around
Use a BinaryWriter to write binary data