Head First C#

Spis treści książki

• Head First C#
• Dedication
• A Note Regarding Supplemental Files
• Advance Praise for Head First C#
• Praise for other Head First books
•  
• How to Use this Book: Intro
  • Who is this book for?
  • Who should probably back away from this book?
  • We know what youre thinking.
  • And we know what your brain is thinking.
  • Metacognition: thinking about thinking
  • Heres what WE did:
  • Heres what YOU can do to bend your brain into submission
  • What you need for this book:
  • Read me
  • The technical review team
    • Technical Reviewers:
  • Acknowledgments
  • Safari Books Online
• 1. Get Productive With c#: Visual Applications, in 10 minutes or less
  • Why you should learn C#
    • Heres what the IDE automates for you...
    • What you get with Visual Studio and 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
  • Heres what youre going to build
  • What you do in Visual Studio...
  • What Visual Studio does for you...
  • Develop the user interface
  • Visual Studio, behind the scenes
  • Add to the auto-generated code
  • You can already run your application
  • Where are my files?
  • Heres what weve done so far
  • We need a database to store our information
  • The IDE created a database
  • SQL is its own language
  • Creating the table for the Contact List
  • The blanks on contact card are columns in our People table
  • Finish building the table
  • Diagram your data
  • Insert your card data into the database
  • Connect your form to your database objects with a data source
  • Add database-driven controls to your form
  • Good programs are intuitive to use
  • Test drive
    • The IDE builds first, then runs.
  • How to turn YOUR application into EVERYONES application
  • Give your users the application
  • You built a complete data-driven application
  • You built a complete data-driven application
  • CSharpcross
  • CSharpcross Solution
• 2. Its All Just Code: Under the Hood
  • When youre doing this...
  • ...the IDE does this
  • Where programs come from
    • Every program starts out as source code files
    • The .NET Framework gives you the right tools for the job
    • Build the program to create an executable
    • Your program runs inside the CLR
  • The IDE helps you code
  • When you change things in the IDE, youre also changing your code
    • Wait, wait! What did that say?
  • Anatomy of a program
    • Lets take a closer look at your code
  • Your program knows where to start
  • You can change your programs entry point
    • So what happened?
  • Two classes can be in the same namespace
  • Your programs use variables to work with data
    • Declare your variables
    • Variables vary
    • You have to assign values to variables before you use them
    • A few useful types
  • C# uses familiar math symbols
  • Loops perform an action over and over again
    • Use a code snippet to write simple for loops
  • Time to start coding
    • Add statements to show a message
  • if/else statements make decisions
  • Set up conditions and see if theyre true
    • Use logical operators to check conditions
    • Set a variable and then check its value
    • Add another conditional test
    • Add loops to your program
  • Csharpcross
  • Csharpcross Solution
• 3. Objects: Get Oriented!: Making Code Make Sense
  • How Mike thinks about his problems
  • How Mikes car navigation system thinks about his problems
  • Mikes Navigator class has methods to set and modify routes
    • Some methods have a return value
  • Use what youve learned to build a simple application
  • Mike gets an idea
    • He could create three different Navigator classes...
  • Mike can use objects to solve his problem
  • You use a class to build an object
    • An object gets its methods from its class
  • When you create a new object from a class, its called an instance of that class.
  • A better solution... brought to you by objects!
  • An instance uses fields to keep track of things
    • Methods are what an object does. Fields are what the object knows.
  • Lets create some instances!
  • Thanks for the memory
  • Whats on your programs mind
  • You can use class and method names to make your code intuitive
  • Give your classes a natural structure
    • Lets build a class diagram
  • 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
  • Theres an even easier way to initialize objects
  • A few ideas for designing intuitive classes
  • Objectcross
  • Objectcross Solution
• 4. Types and References: Its 10:00. Do you know where your data is?
  • The variables 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 cant just assign it to any variable
    • So what happened?
  • When you cast a value thats 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 arent any more references, your object gets garbage collected
  • Typecross
  • Multiple references and their side effects
  • Two references means TWO ways to change an objects data
  • A special case: arrays
    • Use each element in an array like it is a normal variable
  • Arrays can contain a bunch of reference variables, too
  • Welcome to Sloppy Joes Budget House o Discount Sandwiches!
  • Objects use references to talk to each other
  • Where no object has gone before
  • Typecross Solution
• I. C# Lab A Day at the Races
  • 5. Encapsulation: Keep your privates... private
    • Kathleen is an event planner
    • What does the estimator do?
    • Kathleens Test Drive
    • Each option should be calculated individually
    • Its easy to accidentally misuse your objects
    • Encapsulation means keeping some of the data in a class private
    • Use encapsulation to control access to your classs 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
      • A quick example of encapsulation
    • Properties make encapsulation easier
    • Build an application to test the Farmer class
    • Use automatic properties to finish the class
      • Fully encapsulate the Farmer class
    • What if we want to change the feed multiplier?
    • Use a constructor to initialize private fields
  • 6. Inheritance: Your objects family tree
    • Kathleen does birthday parties, too
    • We need a BirthdayParty class
      • Heres what we need to do:
    • 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
      • Dinner parties and birthday parties are both parties
    • 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 what you need to override
    • Think about how to group the animals
    • Create the class hierarchy
    • Every subclass extends its base class
      • C# always calls the most specific method
    • Use a colon to inherit from a base class
    • We know that inheritance adds the base class fields, properties, and methods to the subclass...
      • ... but some birds dont fly!
    • 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
      • The base class constructor is executed before the subclass constructor
    • Now youre ready to finish the job for Kathleen!
    • Build a beehive management system
    • First youll build the basic system
    • Use inheritance to extend the bee management system
  • 7. Interfaces and Abstract Classes: Making classes keep their promises
    • Lets get back to bee-sics
      • Lots of things are still the same
    • 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 interfaces methods
    • Get a little practice using interfaces
    • You cant 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
      • Any class that implements an interface that inherits from IWorker must implement its methods and properties
    • The RoboBee 4000 can do a worker bees 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
      • When downcasting fails, as returns null
    • Upcasting and downcasting work with interfaces, too
    • Theres 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
      • Solution: use an abstract class
    • An abstract method doesnt have a body
      • Avoid ambiguity!
      • The four princples of object oriented programming
    • Polymorphism means that one object can take many different forms
      • Keep your eyes open for polymorphism in the next exercise!
      • But were not done yet!
  • 8. Enums and Collections: Storing lots of data
    • Strings dont 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...
      • ... but what if you wanted to do more?
    • 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
    • Lets create a list of Ducks
      • Heres the initializer
    • Lists are easy, but SORTING can be tricky
      • You could sort a list of ducks by size...
      • ...or by type.
      • Lists know how to sort themselves
    • Two ways to sort your ducks
      • An objects CompareTo() method compares it with another object
    • Use IComparer to tell your List how to sort
    • Create an instance of your comparer object
      • Multiple IComparer implementations, multiple ways to sort your objects
    • 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...
      • Generic collections are an important part of the .NET framework
    • A queue is FIFO First In, First Out
    • A stack is LIFO Last In, First Out
• II. C# Lab: The Quest
  • 9. Reading and Writing Files: Save the byte array, save the world
    • C# uses streams to read and write data
    • Different streams read and write different things
      • Things you can do with a stream:
    • A FileStream writes bytes to a file
    • How to write text to a file in 3 simple steps
    • The Swindler launches another diabolical plan
    • Reading and writing takes two objects
    • Data can go through more than one stream
    • Use built-in objects to pop up standard dialog boxes
      • ShowDialog() pops up a dialog box
    • Dialog boxes are just another .NET control
    • Dialog boxes are objects, too
    • Use the built-in File and Directory classes to work with files and directories
      • Things you can do with a File:
      • Things you can do with a Directory:
    • 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
      • Use multiple using statements for multiple objects
    • Trouble at work
      • You can help Brian out by building a program to manage his excuses
    • 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 its serialized?
    • But what exactly IS an objects 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
      • Youll need a BinaryFormatter object
      • Now just create a stream and read or write your objects
    • If you want your class to be serializable, mark it with the [Serializable] attribute
    • Lets serialize and deserialize a deck of cards
    • .NET converts text to Unicode automatically
    • C# can use byte arrays to move data around
    • Use a BinaryWriter to write binary data
      • Use BinaryReader to read the data back in
    • You can read and write serialized files manually, too
    • Find where the files differ, and use that information to alter them
    • Working with binary files can be tricky
    • Use file streams to build a hex dumper
      • How to make a hex dump
      • Working with hex
    • StreamReader and StreamWriter will do just fine
  • 10. Exception Handling: Putting out fires gets old
    • Brian needs his excuses to be mobile
      • But the program isnt working!
    • When your program throws an exception, .NET generates an Exception object.
    • Brians code did something unexpected
    • All exception objects inherit from Exception
    • The debugger helps you track down and prevent exceptions in your code
      • Debugging means running your code line by line to see what happens
    • Use the IDEs debugger to ferret out exactly what went wrong in the excuse manager
    • Uh-ohthe codes still got problems...
    • Handle exceptions with try and catch
    • What happens when a method you want to call is risky?
    • Use the debugger to follow the try/catch flow
    • If you have code that ALWAYS should run, use a finally block
    • Use the Exception object to get information about the problem
    • Use more than one catch block to handle multiple types of exceptions
    • One class throws an exception, another class catches the exception
    • Bees need an OutOfHoney exception
    • An easy way to avoid a lot of problems: using gives you try and finally for free
    • Exception avoidance: implement IDisposable to do your own clean up
    • The worst catch block EVER: comments
      • You should handle your exceptions, not bury them
    • Temporary solutions are okay (temporarily)
    • A few simple ideas for exception handling
    • Brian finally gets his vacation...
      • ... and things are looking up back home!
  • 11. Events and Delegates: What your code does when youre not looking
    • Ever wish your objects could think for themselves?
    • But how does an object KNOW to respond?
    • When an EVENT occurs... objects listen
      • Want to DO SOMETHING with an event? You need an event handler
    • One object raises its event, others listen for it...
    • Then, the other objects handle the event
    • Connecting the dots
      • Use a standard name when you add a method to raise an event
    • The IDE creates event handlers for you automatically
    • The forms youve been building all use events
      • One event, multiple handlers
    • Connecting event senders with event receivers
      • My people will get in touch with your people.
    • A delegate STANDS IN for an actual method
      • A delegate adds a new type to your project
    • Delegates in action
    • Any object can subscribe to a public event...
      • ... but thats not always a good thing!
    • Use a callback instead of an event to hook up exactly one object to a delegate
    • Callbacks use delegates, but NOT events
  • 12. Review and Preview: Knowledge, power, and building cool stuff
    • Youve come a long way, baby
    • Weve also become beekeepers
      • But we can do a lot better now...
    • The beehive simulator architecture
    • Building the beehive simulator
    • Life and death of a flower
    • Now we need a Bee class
    • P. A. H. B. (Programmers Against Homeless Bees)
    • The hive runs on honey
    • Filling out the Hive class
    • The hives Go() method
    • Were ready for the World
      • The World object keeps everything Go() ing
    • Were building a turn-based system
    • Heres the code for World
    • Giving the bees behavior
    • The main form tells the world to Go()
    • We can use World to get statistics
    • Timers fire events over and over again
    • The timers using a delegate behind the scenes
    • Add a Timer to the simulator
    • Test drive
    • Lets work with groups of bees
    • A collection collects... DATA
    • LINQ makes working with data in collections and databases easy
    • Test drive (Part 2)
    • One final challenge: Open and Save
  • 13. Controls and Graphics: Make it pretty
    • Youve been using controls all along to interact with your programs
    • Form controls are just objects
    • Use controls to animate the beehive simulator
    • Add a renderer to your architecture
    • The renderer draws everything in the World on the two forms
      • The simulator renders the world after each frame
    • Controls are well-suited for visual display elements
    • Build your first animated control
      • We want a control in the toolbox
    • BeeControl is LIKE a PictureBox... so lets start by INHERITING from PictureBox
    • Create a button to add the BeeControl to your form
    • Your controls need to dispose their controls, too!
    • A UserControl is an easy way to build a control
    • The renderer uses your BeeControl to draw animated bees on your forms
    • Add the hive and field forms to the project
      • Figure out where your locations are
    • Build the Renderer
    • Now connect the main form to your two new forms, HiveForm and FieldForm
    • Test drive... ahem... buzz
    • Looks great, but somethings not quite right...
    • Lets take a closer look at those performance issues
    • You resized your Bitmaps using a Graphics object
      • Lets see image resizing in action
    • Your image resources are stored in Bitmap objects
      • Then each Bitmap is drawn to the screen
      • The bigger they are...
    • Use System.Drawing to TAKE CONTROL of graphics yourself
    • A 30-second tour of GDI+ graphics
    • Use graphics to draw a picture on a form
    • Graphics can fix our transparency problem...
      • ... but theres a catch
    • Use the Paint event to make your graphics stick
    • A closer look at how forms and controls repaint themselves
    • Double buffering makes animation look a lot smoother
    • Double buffering is built into forms and controls
      • Overhaul the Beehive Simulator
    • Use a Graphics object and an event handler for printing
    • PrintDocument works with the print dialog and print preview window objects
      • Use e.HasMorePages to print multi-page documents
    • Theres so much more to be done...
  • 14. Captain Amazing the Death of the Object
    • Your last chance to DO something... your objects finalizer
    • When EXACTLY does a finalizer run?
      • You can SUGGEST to .NET that its time to collect the garbage
    • Dispose() works with using, finalizers work with garbage collection
    • Finalizers cant depend on stability
    • Make an object serialize itself in its Dispose()
    • A struct looks like an object...
    • ..but isnt on the heap
    • Values get copied, references get assigned
    • Structs are value types; objects are reference types
      • Heres what happened...
    • The stack vs. the heap: more on memory
    • Captain Amazing... not so much
    • Extension methods add new behavior to EXISTING classes
    • Extending a fundamental type: string
  • 15. Linq: Get control of your data
    • An easy project...
    • ... but the datas all over the place
    • LINQ can pull data from multiple sources
    • .NET collections are already set up for LINQ
    • LINQ makes queries easy
    • LINQ is simple, but your queries dont have to be
    • LINQ is versatile
    • LINQ can combine your results into groups
    • Combine Jimmys values into groups
    • Use join to combine two collections into one query
    • Jimmy saved a bunch of dough
    • Connect LINQ to a SQL database
    • Use a join query to connect Starbuzz and Objectville
• III. C# Lab 3: Invaders
  • A. Leftovers: The top 5 things we wanted to include in this book
    • #1 LINQ to XML
      • Save and load XML files
      • Query your data
      • Read data from an RSS feed
    • #2 Refactoring
      • Extract a method
      • Rename a variable
      • Consolidate a conditional expression
    • #3 Some of our favorite Toolbox components
    • #4 Console Applications
    • #5 Windows Presentation Foundation
    • Did you know that C# and the .NET Framework can...
• Index
• About the Authors
• Copyright

pokaż cały spis treści

ukryj recenzje