Head First C#. 4th Edition Andrew Stellman, Jennifer Greene

Kup polskie wydanie:

Dostępność produktu

Produkt nie został jeszcze oceniony pod kątem ułatwień dostępu lub nie podano żadnych informacji o ułatwieniach dostępu lub są one niewystarczające. Prawdopodobnie Wydawca/Dostawca jeszcze nie umożliwił dokonania walidacji produktu lub nie przekazał odpowiednich informacji na temat jego dostępności.

Spis treści książki

• Intro: How to use this book
  • Who is this book for?
    • Who should probably avoid 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
  • README
  • The technical review team
  • Acknowledgments
    • And finally...
  • OReilly online learning
• 1. Start Building with C#: Build something greatfast!
  • Why you should learn C#
    • Visual Studio is your gateway to C#
    • If youre on Windows...
    • If youre on a Mac...
  • Visual Studio is a tool for writing code and exploring C#
  • Create your first project in Visual Studio
  • Lets build a game!
    • Your animal matching game is a WPF app
  • Heres how youll build your game
  • Create a WPF project in Visual Studio
    • Visual Studio created a project folder full of files for you
  • Use XAML to design your window
  • Design the window for your game
  • Set the window size and title with XAML properties
  • Add rows and columns to the XAML grid
  • Make the rows and columns equal size
  • Add a TextBlock control to your grid
  • Now youre ready to start writing code for your game
  • Generate a method to set up the game
  • Finish your SetUpGame method
  • Run your program
  • Add your new project to source control
  • The next step to build the game is handling mouse clicks
  • Make your TextBlocks respond to mouse clicks
  • Add the TextBlock_MouseDown code
  • Make the rest of the TextBlocks call the same MouseDown event handler
  • Finish the game by adding a timer
  • Add a timer to your games code
  • Use the debugger to troubleshoot the exception
  • Add the rest of the code and finish the game
  • Update your code in source control
  • Even better ifs
• 2. Dive into C#: Statements, Classes, and Code
  • Lets take a closer look at the files for a console app
    • A statement performs one single action
  • Two classes can be in the same namespace (and file!)
  • Statements are the building blocks for your apps
  • Your programs use variables to work with data
    • Declare your variables
    • Variables vary
    • You need to assign values to variables before you use them
    • A few useful types
  • Generate a new method to work with variables
  • Add code that uses operators to your method
  • Use the debugger to watch your variables change
  • Use operators to work with variables
  • if statements make decisions
    • if/else statements also do something if a condition isnt true
  • Loops perform an action over and over
    • while loops keep looping statements while a condition is true
    • do/while loops run the statements then check the condition
    • for loops run a statement after each loop
  • Use code snippets to help write loops
  • Controls drive the mechanics of your user interfaces
  • Create a WPF app to experiment with controls
  • Add a TextBox control to your app
  • Add C# code to update the TextBlock
  • Add an event handler that only allows number input
  • Add sliders to the bottom row of the grid
  • Add C# code to make the rest of the controls work
• Unity Lab #1: Explore C# with Unity
  • Unity is a powerful tool for game design
  • Download Unity Hub
  • Use Unity Hub to create a new project
  • Make Visual Studio your Unity script editor
  • Take control of the Unity layout
  • Choose the Wide layout to match our screenshots
  • Your scene is a 3D environment
  • Unity games are made with GameObjects
  • Use the Move Gizmo to move your GameObjects
  • The Inspector shows your GameObjects components
  • Add a material to your Sphere GameObject
  • Rotate your sphere
  • Move the Scene view camera with the Hand tool and Scene Gizmo
  • Get creative!
• 3. Objectsget oriented!: Making code make sense
  • If code is useful, it gets reused
  • Some methods take parameters and return a value
  • Lets build a program that picks some cards
  • Create your PickRandomCards console app
  • Finish your PickSomeCards method
  • Your finished CardPicker class
  • Anas working on her next game
    • Anas game is evolving
  • Build a paper prototype for a classic game
  • Up next: build a WPF version of your card picking app
  • A StackPanel is a container that stacks other controls
  • Reuse your CardPicker class in a new WPF app
  • Use a Grid and StackPanel to lay out the main window
  • Lay out your Card Picker desktop apps window
    • Anas prototypes look great
    • but what if she wants more than one enemy?
  • Ana can use objects to solve her 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 for Anabrought to you by objects
    • Theory and practice
  • An instance uses fields to keep track of things
    • Methods are what an object does. Fields are what the object knows.
  • Thanks for the memory
  • Whats on your programs mind
  • Sometimes code can be difficult to read
    • Extremely compact code can be especially problematic
    • Most code doesnt come with a manual
  • Use intuitive class and method names
  • Build a class to work with some guys
  • Theres an easier way to initialize objects with C#
  • Use the C# Interactive window to run C# code
• 4. Types and References: Getting the Reference
  • Owen could use our help!
    • Storytelling, fantasy, and mechanics
  • Character sheets store different types of data on paper
  • A variables type determines what kind of data it can store
  • C# has several types for storing integers
    • Types for storing really HUGE and really tiny numbers
  • Lets talk about strings
  • A literal is a value written directly into your code
    • Use suffixes to give your literals types
  • A variable is like a data to-go cup
    • Use the Convert class to explore bits and bytes
  • Other types come in different sizes, too
  • 10 pounds of data in a 5-pound bag
  • Casting lets you copy values that C# cant automatically convert to another type
    • So what happened?
    • When you cast a value thats too big,C# adjusts it to fit its new container
  • C# does some conversions automatically
  • When you call a method, the arguments need to be compatible with the types of the parameters
    • Owen is constantly improving his game
    • but the trial and error can be time-consuming
  • Lets help Owen experiment with ability scores
  • Use the C# compiler to find the problematic line of code
    • Add a cast to get the AbilityScoreCalculator class to compile...
    • but theres still a bug!
    • And now we can finally fix Owens bug
  • Use reference variables to access your objects
    • References are like sticky notes for your objects
    • If there arent any more references,your object gets garbage-collected
  • Multiple references and their side effects
    • Two references mean TWO variables that can change the same objects data
  • Objects use references to talk to each other
  • Arrays hold multiple values
    • Use each element in an array like its a normal variable
  • Arrays can contain reference variables
  • null means a reference points to nothing
  • Welcome to Sloppy Joes Budget House o Discount Sandwiches!
• Unity Lab #2: Write C# Code for Unity
  • C# scripts add behavior to your GameObjects
  • Add a C# script to your GameObject
  • Write C# code to rotate your sphere
  • Add a breakpoint and debug your game
  • Use a hit count to skip frames
  • Use the debugger to understand Time.deltaTime
  • Add a cylinder to show where the Y axis is
  • Add fields to your class for the rotation angle and speed
  • Use Debug.DrawRay to explore how 3D vectors work
  • Use Unity to visualize vectors in 3D
  • Run the game to see the ray in the Scene view
  • Add a duration to the ray so it leaves a trail
  • Rotate your ball around a point in the scene
  • Use Unity to take a closer look at rotation and vectors
  • Get creative!
• 5. Encapsulation: Keep your Privates Private
  • Lets help Owen roll for damage
  • Create a console app to calculate damage
  • Design the XAML for a WPF version of the damage calculator
  • The code-behind for the WPF damage calculator
  • Tabletop talk (or maybedice discussion?)
  • Lets try to fix that bug
  • Use Debug.WriteLine to print diagnostic information
  • 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 instances of the same class
  • Why encapsulation? Think of an object as a black box
    • Encapsulation makes your classes
    • A few ideas for encapsulating classes
  • Lets use encapsulation to improve the SwordDamage class
    • Is every member of the SwordDamage class public?
    • Are fields or methods being misused?
    • Is there calculation required after setting a field?
    • So what fields and methods really need to be public?
  • Encapsulation keeps your data safe
    • Lets use encapsulation in a class
  • Write a console app to test the PaintballGun class
    • Our class is well-encapsulated, but...
  • Properties make encapsulation easier
    • Replace the GetBalls and SetBalls methods with a property
  • Modify your Main method to use the Balls property
    • Debug your PaintballGun class to understand how the property works
  • Auto-implemented properties simplify your code
    • Use the prop snippet to create an auto-implemented property
  • Use a private setter to create a read-only property
    • Make the BallsLoaded setter private
  • What if we want to change the magazine size?
    • But theres a problemhow do we initialize MagazineSize?
  • Use a constructor with parameters to initialize properties
  • Specify arguments when you use the new keyword
    • A few useful facts about methods and properties
• 6. Inheritance: Your Objects Family Tree
  • Calculate damage for MORE weapons
  • Use a switch statement to match several candidates
  • One more thing...can we calculate damage for a dagger? and a mace? and a staff? and...
  • 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?
  • Different animals have different behaviors
  • Every subclass extends its base class
    • C# always calls the most specific method
  • Any place where you can use a base class, you can use one of its subclasses instead
  • Use a colon to extend 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 members it inherited
  • Some members are only implemented in a subclass
  • Use the debugger to understand how overriding works
  • Build an app to explore virtual and override
  • A subclass can hide methods in the base class
    • Hiding methods versus overriding methods
    • Use the new keyword when youre hiding methods
    • Use different references to call hidden methods
  • Use the override and virtual keywords to inherit behavior
  • A subclass can access its base class using the base keyword
  • When a base class has a constructor, your subclass needs to call it
  • A subclass and base class can have different constructors
  • Its time to finish the job for Owen
  • When your classes overlap as little as possible, thats an important design principle called separation of concerns
    • Use the debugger to really understand how these classes work
  • Build a beehive management system
  • The beehive management system class model
  • The Queen class: how she manages the worker bees
  • The UI: add the XAML for the main window
  • Feedback drives your Beehive Management game
    • Workers and honey are in a feedback loop
  • The Beehive Management System is turn-based...now lets convert it to real-time
  • Some classes should never be instantiated
  • An abstract class is an intentionally incomplete class
  • Like we said, some classes should never be instantiated
    • Solution: use an abstract class
  • An abstract method doesnt have a body
  • Abstract properties work just like abstract methods
• Unity Lab #3: GameObject Instances
  • Lets build a game in Unity!
  • Create a new material inside the Materials folder
  • Spawn a billiard ball at a random point in the scene
  • Use the debugger to understand Random.value
  • Turn your GameObject into a prefab
  • Create a script to control the game
  • Attach the script to the Main Camera
  • Press Play to run your code
  • Watch the live instances in the Hierarchy window
  • Use the Inspector to work with GameObject instances
  • Use physics to keep balls from overlapping
  • Get creative!
• 7. Interfaces, Casting, and is: Making Classes keep their Promises
  • The beehive is under attack!
    • So we need a DefendHive method, because enemies can attack at any time
  • We can use casting to call the DefendHive method...
    • ...but what if we add more Bee subclasses that can defend?
  • An interface defines methods and properties that a class must implement...
    • ...but theres no limit to the number of interfaces a class can implement
  • Interfaces let unrelated classes do the same job
  • Get a little practice using interfaces
  • You cant instantiate an interface, but you can reference an interface
    • If you try to instantiate an interface, your code wont build
    • Use the interface to reference an object you already have
  • Interface references are ordinary object references
  • The RoboBee 4000 can do a worker bees job without using valuable honey
  • The IWorkers Job property is a hack
  • Use is to check the type of an object
  • Use is to access methods in a subclass
  • What if we want different animals to swim or hunt in packs?
  • Use interfaces to work with classes that do the same job
    • Use the is keyword to check if the Animal is a swimmer or pack hunter
  • Safely navigate your class hierarchy with is
  • C# has another tool for safe type conversion: the as keyword
  • Use upcasting and downcasting to move up and down a class hierarchy
  • A quick example of upcasting
  • Upcasting turns your CoffeeMaker into an Appliance
  • Downcasting turns your Appliance back into a CoffeeMaker
  • Upcasting and downcasting work with interfaces, too
  • Interfaces can inherit from other interfaces
  • Interfaces can have static members
  • Default implementations give bodies to interface methods
  • Add a ScareAdults method with a default implementation
  • Data binding updates WPF controls automatically
  • Modify the Beehive Management System to use data binding
  • Polymorphism means that one object can take many different forms
    • Keep your eyes open for polymorphism!
    • The four core principles of object-oriented programming
• 8. Enums and Collections: Organizing your Data
  • Strings dont always work for storing categories of data
  • Enums let you work with a set of valid values
    • An enum defines a new type
  • 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 can be annoying to work with
  • Lists make it easy to store collections of...anything
  • Lists are more flexible than arrays
  • Lets build an app to store shoes
  • Generic collections can store any type
    • Generic lists are declared using <angle brackets>
  • Collection initializers are similar to object initializers
  • Lets create a List of Ducks
    • Heres the initializer for your List of Ducks
  • Lists are easy, but SORTING can be tricky
    • Lists know how to sort themselves
  • IComparable<Duck> helps your List sort its Ducks
    • An objects CompareTo method compares it to another object
  • Use IComparer to tell your List how to sort
    • Add an IComparer to your project
  • Create an instance of your comparer object
    • Multiple IComparer implementations, multiple ways to sort your objects
  • Comparers can do complex comparisons
  • Overriding a ToString method lets an object describe itself
    • Override the ToString method to see your Ducks in the IDE
  • Update your foreach loops to let your Ducks and Cards write themselves to the console
    • Add a ToString method to your Card object, too
  • You can upcast an entire list using IEnumerable<T>
  • Use a Dictionary to store keys and values
  • The Dictionary functionality rundown
    • Your key and value can be different types
  • Build a program that uses a dictionary
  • And yet MORE collection types...
    • Generic .NET collections implement IEnumerable
  • A queue is FIFOfirst in, first out
  • A stack is LIFOlast in, first out
• Unity Lab #4: User Interfaces
  • Add a score that goes up when the player clicks a ball
  • Add two different modes to your game
  • Add game mode to your game
  • Add a UI to your game
  • Use the 2D view to work with the Canvas
  • Set up the Text that will display the score in the UI
  • Add a button that calls a method to start the game
  • Make the Play Again button and Score Text work
  • Finish the code for the game
  • Get creative!
• 9. LINQ and lambdas: Get control of your data
  • Jimmys a Captain Amazing super-fan...
  • ...but his collections all over the place
  • Use LINQ to query your collections
  • LINQ works with any IEnumerable<T>
    • LINQ methods enumerate your sequences
  • LINQs query syntax
    • LINQ queries are built from clauses
  • LINQ works with objects
  • Use a LINQ query to finish the app for Jimmy
  • The var keyword lets C# figure out variable types for you
    • When you use var, C# figures out the variables type automatically
  • LINQ is versatile
  • LINQ queries arent run until you access their results
  • Use a group query to separate your sequence into groups
  • Use join queries to merge data from two sequences
  • Use the new keyword to create anonymous types
  • Unit tests help you make sure your code works
    • Visual Studio for Windows has a Test Explorer window
    • Visual Studio for Mac has the Unit Tests tool window
  • Add a unit test project to Jimmys comic collection app
  • Write your first unit test
  • Write a unit test for the GetReviews method
  • Write unit tests to handle edge cases and weird data
  • Use the => operator to create lambda expressions
  • A lambda test drive
  • Refactor a clown with lambdas
  • Use the ?: operator to make your lambdas make choices
  • Lambda expressions and LINQ
    • Use lambda expressions with methods that take a Func parameter
  • LINQ queries can be written as chained LINQ methods
    • The OrderBy LINQ method sorts a sequence
    • The Where LINQ method pulls out a subset of a sequence
  • Use the => operator to create switch expressions
  • Explore the Enumerable class
    • Enumerable.Empty creates an empty sequence of any type
    • Enumerable.Repeat repeats a value a number of times
    • So what exactly is an IEnumerable<T>?
  • Create an enumerable sequence by hand
  • Use yield return to create your own sequences
    • Use the debugger to explore yield return
  • Use yield return to refactor ManualSportSequence
    • Add an indexer to BetterSportSequence
  • Collectioncross
  • Collectioncross Solution
• 10. Reading and writing files: Save the last byte for me!
  • .NET uses streams to read and write data
  • Different streams read and write different things
    • Things you can do with a stream:
  • A FileStream reads and writes bytes in a file
  • Write text to a file in three simple steps
  • The Swindler launches another diabolical plan
  • StreamWriter Magnets
  • StreamWriter Magnets Solution
  • Use a StreamReader to read a file
  • Data can go through more than one stream
  • Pool Puzzle
  • Pool Puzzle Solution
  • Use the static File and Directory classes to work with files and directories
    • Things you can do with the static File class:
    • Things you can do with the static Directory class:
  • IDisposable makes sure objects are closed properly
    • Use the IDE to explore IDisposable
  • Avoid filesystem errors with using statements
    • Use multiple using statements for multiple objects
  • Use a MemoryStream to stream data to memory
    • Use Encoding.UTF8.GetString to convert byte arrays to strings
  • 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...
  • Use JsonSerialization to serialize your objects
  • JSON only includes data, not specific C# types
  • Next up: well take a deep dive into our data
  • C# strings are encoded with Unicode
  • Visual Studio works really well with Unicode
  • .NET uses Unicode to store characters and text
  • C# can use byte arrays to move data around
  • Use a BinaryWriter to write binary data
  • Use BinaryReader to read the data back in
  • A hex dump lets you see the bytes in your files
    • How to make a hex dump of some plain text
  • Use StreamReader to build a hex dumper
  • Use Stream.Read to read bytes from a stream
  • Modify your hex dumper to use command-line arguments
    • Run your app from the command line
• Unity Lab #5: Raycasting
  • Create a new Unity project and start to set up the scene
  • Set up the camera
  • Create a GameObject for the player
  • Introducing Unitys navigation system
  • Set up the NavMesh
  • Make your player automatically navigate the play area
• 11. Captain Amazing: The Death of the Object
  • The life and death of an object
  • Use the GC class (with caution) to force garbage collection
  • 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
  • Finalizers cant depend on other objects
    • Dont use finalizers for serialization
  • A struct looks like an object...
    • ...but isnt an object
  • 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
  • Use out parameters to make a method return more than one value
  • Pass by reference using the ref modifier
  • Use optional parameters to set default values
  • A null reference doesnt refer to any object
  • Non-nullable reference types help you avoid NREs
    • Use encapsulation to prevent your property from ever being null
  • The null-coalescing operator ?? helps with nulls
    • ?? checks for null and returns an alternative
    • ??= assigns a value to a variable only if its null
  • Nullable value types can be null...and handled safely
  • Captain Amazing...not so much
  • Pool Puzzle
  • Pool Puzzle Solution
  • Extension methods add new behavior to EXISTING classes
  • Extending a fundamental type: string
  • Extension Magnets
  • Extension Magnets Solution
• 12. Exception Handling: Putting out Fires Gets old
  • Your hex dumper reads a filename from the command line
    • But what happens if you give HexDump an invalid filename?
  • When your program throws an exception, the CLR generates an Exception object
  • All Exception objects inherit from System.Exception
  • There are some files you just cant dump
  • What happens when a method you want to call is risky?
  • Handle exceptions with try and catch
  • Use the debugger to follow the try/catch flow
  • If you have code that ALWAYS needs to run, use a finally block
  • Catch-all exceptions handle System.Exception
    • Avoid catch-all exception with multiple catch blocks
  • Pool Puzzle
  • Pool Puzzle Solution
  • Use the right exception for the situation
    • Catch custom exceptions that extend System.Exception
  • Exception Magnets
  • Exception Magnets Solution
  • Exception filters help you create precise handlers
  • The worst catch block EVER: catch-all plus comments
    • You should handle your exceptions, not bury them
  • Temporary solutions are OK (temporarily)
• Unity Lab #6 Scene Navigation
  • Lets pick up where the last Unity Lab left off
  • Add a platform to your scene
  • Use bake options to make the platform walkable
  • Include the stairs and ramp in your NavMesh
  • Fix height problems in the NavMesh
  • Add a NavMesh Obstacle
  • Add a script to move the obstacle up and down
  • Get creative!
  • Downloadable exercise: Animal match boss battle
  • Thank you for reading our book!
  • But wait, theres more! Your journeys just begun...
  • And check out these essential (and amazing!) books by some of our friends and colleagues, also published by OREILLY
• A. ASP.NET Core Blazor projects: Visual Studio for Mac Learners Guide
  • Why you should learn C#
    • Visual Studio is your gateway to C#
    • Install .NET Core
    • You can also use Visual Studio for Windows to build Blazor web applications
  • Visual Studio is a tool for writing code and exploring C#
  • Create your first project in Visual Studio for Mac
  • Use the Visual Studio IDE to explore your app
  • Lets build a game!
    • Your animal matching game is a Blazor WebAssembly app
  • Heres how youll build your game
  • Create a Blazor WebAssembly App in Visual Studio
  • Run your Blazor web app in a browser
  • Now youre ready to start writing code for your game
    • How the page layout in your animal matching game will work
  • Visual Studio helps you write C# code
  • Finish creating your emoji list and display it in the app
    • Replace the contents of the page
  • Shuffle the animals so theyre in a random order
  • Youre running your game in the debugger
  • Add your new project to source control
  • Add C# code to handle mouse clicks
  • Add click event handlers to your buttons
    • Heres the code for the event handler
    • Hook up your event handler to the buttons
  • Test your event handler
    • But what happens if you click on the same button twice?
  • Use the debugger to troubleshoot the problem
  • Keep debugging your event handler
  • Track down the bug thats causing the problem...
    • ...and fix the bug!
  • Add code to reset the game when the player wins
  • Finish the game by adding a timer
  • Add a timer to your games code
  • Clean up the navigation menu
  • Even better ifs...
  • from Chapter 2 dive into C#
  • Controls drive the mechanics of your user interfaces
  • Create a new Blazor WebAssembly App project
  • Create a page with a slider control
  • Add a text input to your app
  • Add color and date pickers to your app
  • from Chapter 3 objects...get oriented!
  • Up next: build a Blazor version of your card picking app
    • Reuse your CardPicker class in a new Blazor app
  • The page is laid out with rows and columns
  • The slider uses data binding to update a variable
  • from Chapter 4 types and references
    • Welcome to Sloppy Joes Budget House o Discount Sandwiches!
• B. Code Kata Guide for the Advanced and/or Impatient
• Index

pokaż cały spis treści

ukryj recenzje