C# : the complete reference /
Saved in:
| Author / Creator: | Schildt, Herbert. |
|---|---|
| Imprint: | Berkeley, Calif. : McGraw-Hill/Osborne, c2002. |
| Description: | xxiv, 933 p. : ill. ; 23 cm. |
| Language: | English |
| Subject: | |
| Format: | Print Book |
| URL for this record: | http://pi.lib.uchicago.edu/1001/cat/bib/4840283 |
Table of Contents:
- Preface
- Part I. The C# Language
- 1. The Creation of C#
- C#'s Family Tree
- How C# Relates to the .NET Framework
- How the Common Language Runtime Works
- Managed vs. Unmanaged Code
- 2. An Overview of C#
- Object-Oriented Programming
- A First Simple Program
- Handling Syntax Errors
- A Small Variation
- A Second Simple Program
- Another Data Type
- Two Control Statements
- Using Blocks of Code
- Semicolons and Positioning
- Indentation Practices
- Identifiers
- The C# Class Libraries
- 3. Data Types, Literals, and Variables
- Why Data Types Are Important
- C#'s Value Types
- Integers
- Floating-Point Types
- The decimal Type
- Characters
- The bool Type
- Some Output Options
- Literals
- A Closer Look at Variables
- The Scope and Lifetime of Variables
- Type Conversion and Casting
- Type Conversion in Expressions
- 4. Operators
- Arithmetic Operators
- Relational and Logical Operators
- The Assignment Operator
- The Bitwise Operators
- The? Operator
- Spacing and Parentheses
- Operator Precedence
- 5. Program Control Statements
- The if Statement
- The switch Statement
- The for Loop
- The while Loop
- The do-while Loop
- The foreach Loop
- Using break to Exit a Loop
- Using continue
- The goto
- 6. Introducing Classes, Objects, and Methods
- Class Fundamentals
- How Objects Are Created
- Reference Variables and Assignment
- Methods
- Constructors
- The new Operator Revisited
- Garbage Collection and Destructors
- The this Keyword
- 7. Arrays and Strings
- Arrays
- Multidimensional Arrays
- Jagged Arrays
- Assigning Array References
- Using the Length Property
- The foreach Loop
- Strings
- 8. A Closer Look at Methods and Classes
- Controlling Access to Class Members
- Pass Objects to Methods
- Using ref and out Parameters
- Using a Variable Number of Arguments
- Returning Objects
- Method Overloading
- Overloading Constructors
- The Main() Method
- Recursion
- Understanding static
- 9. Operator Overloading
- Operator Overloading Fundamentals
- Handling Operations on C# Built-in Types
- Overloading the Relational Operators
- Overloading true and false
- Overloading the Logical Operators
- Conversion Operators
- Operator Overloading Tips and Restrictions
- Another Example of Operator Overloading
- 10. Indexers and Properties
- Indexers
- Properties
- Using Indexers and Properties
- 11. Inheritance
- Inheritance Basics
- Member Access and Inheritance
- Constructors and Inheritance
- Inheritance and Name Hiding
- Creating a Multilevel Hierarchy
- When Are Constructors Called?
- Base Class References and Derived Objects
- Virtual Methods and Overriding
- Using Abstract Classes
- Using sealed to Prevent Inheritance
- The object Class
- 12. Interfaces, Structures, and Enumerations
- Interfaces
- Using Interface References
- Interface Properties
- Interface Indexers
- Interfaces Can Be Inherited
- Name Hiding with Interface Inheritance
- Explicit Implementations
- Choosing Between an Interface and an Abstract Class
- The .NET Standard Interfaces
- An Interface Case Study
- Structures
- Enumerations
- 13. Exception Handling
- The System.Exception Class
- Exception Handling Fundamentals
- The Consequences of an Uncaught Exception
- Exceptions Let You Handle Errors Gracefully
- Using Multiple catch Statements
- Catching All Exceptions
- Nesting try Blocks
- Throwing an Exception
- Using finally
- A Closer Look at Exception
- Deriving Exception Classes
- Catching Derived Class Exceptions
- Using checked and unchecked
- 14. Using I/O
- C#'s I/O Is Built Upon Streams
- The Stream Classes
- Console I/O
- FileStream and Byte-Oriented File I/O
- Character-Based File I/O
- Redirecting the Standard Streams
- Reading and Writing Binary Data
- Random Access Files
- Using MemoryStream
- Using StringReader and StringWriter
- Converting Numeric Strings to Their Internal Representation
- 15. Delegates and Events
- Delegates
- Events
- .NET Event Guidelines
- Applying Events: A Case Study
- 16. Namespaces, the Preprocessor, and Assemblies
- Namespaces
- The Preprocessor
- Assemblies and the internal Access Modifier
- 17. Runtime Type ID, Reflection, and Attributes
- Runtime Type Identification
- Reflection
- Using Reflection
- Attributes
- Using the Built-in Attributes
- 18. Unsafe Code, Pointers, and Miscellaneous Topics
- Unsafe Code
- Miscellaneous Keywords
- const and volatile
- Part II. Exploring the C# Library
- 19. Exploring the System Namespace
- The Members of System
- The Math Class
- The Value-Type Structures
- The Array Class
- BitConverter
- Generating Random Numbers with Random
- Memory Management and the GC Class
- Object
- The IComparable Interface
- The IConvertible Interface
- The ICloneable Interface
- IFormatProvider and IFormattable
- 20. Strings and Formatting
- Strings in C#
- The String Class
- Formatting
- Using String.Format() and ToString() to Format Data
- Creating a Custom Numeric Format
- Formatting Date and Time
- Formatting Enumerations
- 21. Multithreaded Programming
- Multithreading Fundamentals
- The Thread Class
- Determining When a Thread Ends
- The IsBackground Property
- Thread Priorities
- Synchronization
- Thread Communication Using Wait(), Pulse(), and PulseAll()
- Using MethodImplAttribute
- Suspending, Resuming, and Stopping Threads
- Determining a Thread's State
- Using the Main Thread
- Multithreading Tips
- Starting a Separate Task
- 22. Working with Collections
- Collections Overview
- The Collection Interfaces
- The DictionaryEntry Structure
- The General-Purpose Collection Classes
- Storing Bits with BitArray
- The Specialized Collections
- Accessing a Collection via an Enumerator
- Storing User-Defined Classes in Collections
- Collection Summary
- 23. Networking Through the Internet
- The System.Net Members
- Uniform Resource Identifiers
- Internet Access Fundamentals
- Handling Network Errors
- The URI Class
- Accessing Additional HTTP Response Information
- MiniCrawler: A Case Study
- Using WebClient
- Part III. Applying C#
- 24. Building Components
- What Is a Component?
- What Is a C# Component?
- IComponent
- Component
- A Simple Component
- Overriding Dispose()
- Employing the using Statement
- Containers
- Are Components the Future of Programming?
- 25. Creating Form-Based Windows Applications
- A Brief History of Windows Programming
- Two Ways to Write a Form-Based Windows Application
- How Windows Interacts with the User
- Windows Forms
- A Skeletal Form-Based Windows Program
- Adding a Button
- Handling Messages
- Using a Message Box
- Adding a Menu
- What Next?
- 26. A Recursive-Descent Expression Parser
- Expressions
- Parsing Expressions: The Problem
- Parsing an Expression
- Dissecting an Expression
- A Simple Expression Parser
- Adding Variables to the Parser
- Syntax Checking in a Recursive-Descent Parser
- Some Things to Try
- A. XML Comment Quick Reference
- The XML Comment Tags
- Compiling XML Documentation
- An XML Documentation Example
- B. C# and Robotics
- Index
