Cover image for Stephens' C# Programming with Visual Studio® 2010 24-Hour Trainer

Stephens' C# Programming with Visual Studio® 2010 24-Hour Trainer

Author Rod Stephens
Release Date: 2010/05/01
ISBN: 9780470596906
Topic:
0%
140
Chapters
0-1
Hours read
0k
Total Words
    Start Reading Now    
       Add to Wishlist       
View table of contents

Book Description

A unique book-and-video package for Stephens' C# Programming with Visual Studio® 2010 24-Hour Trainer

Visual C# has become a leading programming language, resulting in greater career opportunities for Visual C# programmers. This Wrox guide literally shows novice programmers how to program in C# with Microsoft Visual Studio, using both written and visual instruction.

Easy-to-follow lessons reinforced with step-by-step instructions, screencasts, and supplemental exercises make it easy to master Visual C# programming regardless of your learning style. Each lesson begins with a discussion of a concept or technique and proceeds through step-by-step directions for using the technique Visual C# has surpassed Visual Basic as the most popular programming language.

Coverage Includes:

  • Getting Started with the Visual Studio IDE

  • Creating Controls

  • Making Controls Arrange Themselves

  • Handling Events

  • Making Menus

  • Making Tool Strips and Status Strips

  • Using RichTextBoxes

  • Using Standard Dialogs

  • Creating and Displaying New Forms

  • Building Custom Dialogs

  • Using Variables and Performing Calculations

  • Debugging Code

  • Understanding Scope

  • Working with Strings

  • Working with Dates and Times

  • Using Arrays and Collections

  • Using Enumerations and Structures

  • Making Choices

  • Repeating Program Steps

  • Handling Errors

  • Preventing Bugs

  • Defining Classes

  • Initializing Objects

  • Fine-Tuning Classes

  • Overloading Operators

  • Using Interfaces

  • Making Generic Classes

  • Reading and Writing Files

  • Using File System Classes

  • Printing

  • Using the Clipboard

  • Providing Drag and Drop

  • Localizing Programs

  • Programming Databases

  • LINQ to Objects

  • LINQ to SQL

  • Drawing with GDI+

  • Making WPF Applications

  • Printing with WPF

Table of Contents

  1. Stephens’ C# Programming with Visual Studio® 2010 24-Hour Trainer
    1. Copyright
    2. About the Author
    3. Credits
    4. Acknowledgments
    5. Brief contents
    6. Contents (1/3)
    7. Contents (2/3)
    8. Contents (3/3)
    9. Introduction
      1. Who This Book Is For
      2. What This Book Covers (And What It Doesn’t)
      3. The Wrox 24-Hour Trainer Approach
      4. How This Book Is Structured
      5. What You Need to Use This Book
      6. Conventions
      7. Source Code
      8. Errata
      9. p2p.wrox.com
    10. Section I: The Visual Studio IDE and Controls
      1. Chapter 1: Getting Started with the Visual Studio IDE (1/4)
      2. Chapter 1: Getting Started with the Visual Studio IDE (2/4)
      3. Chapter 1: Getting Started with the Visual Studio IDE (3/4)
      4. Chapter 1: Getting Started with the Visual Studio IDE (4/4)
        1. Installing C#
        2. Configuring the IDE
        3. Building Your First Program
        4. Copying Projects
        5. Exploring the IDE
        6. Try It
        7. Exercises
      5. Chapter 2: Creating Controls (1/4)
      6. Chapter 2: Creating Controls (2/4)
      7. Chapter 2: Creating Controls (3/4)
      8. Chapter 2: Creating Controls (4/4)
        1. Understanding Controls
        2. Creating Controls
        3. Setting Control Properties
        4. Arranging Controls
        5. Try It
        6. Exercises
      9. Chapter 3: Making Controls Arrange Themselves (1/2)
      10. Chapter 3: Making Controls Arrange Themselves (2/2)
        1. Restricting Form Size
        2. Using Anchor Properties
        3. Using Dock Properties
        4. Try It
        5. Exercises
      11. Chapter 4: Handling Events (1/2)
      12. Chapter 4: Handling Events (2/2)
        1. Making Event Handlers
        2. Using Event Parameters
        3. Removing Event Handlers
        4. Adding and Removing Event Handlers in Code
        5. Useful Events
        6. Try It
        7. Exercises
      13. Chapter 5: Making Menus (1/2)
      14. Chapter 5: Making Menus (2/2)
        1. Creating Menus
        2. Setting Menu Properties
        3. Handling Menu Events
        4. Creating Context Menus
        5. Try It
        6. Exercises
      15. Chapter 6: Making Tool Strips and Status Strips (1/3)
      16. Chapter 6: Making Tool Strips and Status Strips (2/3)
      17. Chapter 6: Making Tool Strips and Status Strips (3/3)
        1. Using Tool Strips
        2. Using Tool Strip Containers
        3. Using Status Strips
        4. Try It
        5. Exercises
      18. Chapter 7: Using RichTextBoxes (1/2)
      19. Chapter 7: Using RichTextBoxes (2/2)
        1. Using RichTextBox Properties
        2. Giving the User Control
        3. Using RichTextBox Methods
        4. Try It
        5. Exercises
      20. Chapter 8: Using Standard Dialogs (1/3)
      21. Chapter 8: Using Standard Dialogs (2/3)
      22. Chapter 8: Using Standard Dialogs (3/3)
        1. Using Dialogs in General
        2. Using Dialog Properties
        3. Using File Filters
        4. Try It
        5. Exercises
      23. Chapter 9: Creating and Displaying New Forms (1/3)
      24. Chapter 9: Creating and Displaying New Forms (2/3)
      25. Chapter 9: Creating and Displaying New Forms (3/3)
        1. Adding New Forms
        2. Understanding Classes and Instances
        3. Displaying Forms
        4. Controlling Remote Forms
        5. Try It
        6. Exercises
      26. Chapter 10: Building Custom Dialogs (1/2)
      27. Chapter 10: Building Custom Dialogs (2/2)
        1. Making Custom Dialogs
        2. Setting the Dialog Result
        3. Using Custom Dialogs
        4. Try It
        5. Exercises
    11. Section II: Variables and Calculations
      1. Chapter 11: Using Variables and Performing Calculations (1/5)
      2. Chapter 11: Using Variables and Performing Calculations (2/5)
      3. Chapter 11: Using Variables and Performing Calculations (3/5)
      4. Chapter 11: Using Variables and Performing Calculations (4/5)
      5. Chapter 11: Using Variables and Performing Calculations (5/5)
        1. What Are Variables?
        2. Data Types
        3. Declaring Variables
        4. Literal Values
        5. Type Conversions
        6. Performing Calculations
        7. Constants
        8. Try It
        9. Exercises
      6. Chapter 12: Debugging Code (1/3)
      7. Chapter 12: Debugging Code (2/3)
      8. Chapter 12: Debugging Code (3/3)
        1. Deferred Techniques
        2. Debugging Then and Now
        3. Setting Breakpoints
        4. Reading Variables
        5. Stepping Through Code
        6. Using Watches
        7. Using the Immediate Window
        8. Try It
        9. Exercises
      9. Chapter 13: Understanding Scope (1/3)
      10. Chapter 13: Understanding Scope (2/3)
      11. Chapter 13: Understanding Scope (3/3)
        1. Scope Within a Class
        2. Accessibility
        3. Restricting Scope and Accessibility
        4. Try It
        5. Exercises
      12. Chapter 14: Working with Strings (1/3)
      13. Chapter 14: Working with Strings (2/3)
      14. Chapter 14: Working with Strings (3/3)
        1. String Methods
        2. Format and ToString
        3. Try It
        4. Exercises
      15. Chapter 15: Working with Dates and Times (1/2)
      16. Chapter 15: Working with Dates and Times (2/2)
        1. Creating DateTime Variables
        2. Local and Utc Time
        3. DateTime Properties and Methods
        4. Timespans
        5. Try It
        6. Exercises
      17. Chapter 16: Using Arrays and Collections (1/3)
      18. Chapter 16: Using Arrays and Collections (2/3)
      19. Chapter 16: Using Arrays and Collections (3/3)
        1. Arrays
        2. Collection Classes
        3. Try It
        4. Exercises
      20. Chapter 17: Using Enumerations and Structures (1/2)
      21. Chapter 17: Using Enumerations and Structures (2/2)
        1. Enumerations
        2. Structures
        3. Structures Versus Classes
        4. Try It
        5. Exercises
    12. Section II: Program Statements
      1. Chapter 18: Making Choices (1/2)
      2. Chapter 18: Making Choices (2/2)
        1. Decision Statements
        2. If Statements
        3. If-Else
        4. Cascading If Statements
        5. Nested If Statements
        6. Switch Statements
        7. Try It
        8. Exercises
      3. Chapter 19: Repeating Program Steps (1/3)
      4. Chapter 19: Repeating Program Steps (2/3)
      5. Chapter 19: Repeating Program Steps (3/3)
        1. For Loops
        2. Foreach Loops
        3. While Loops
        4. Do Loops
        5. Break and Continue
        6. Try It
        7. Exercises
      6. Chapter 20: Reusing Code with Methods (1/2)
      7. Chapter 20: Reusing Code with Methods (2/2)
        1. Method Advantages
        2. Method Syntax
        3. Parameters by Reference
        4. Try It
        5. Exercises
      8. Chapter 21: Handling Errors (1/2)
      9. Chapter 21: Handling Errors (2/2)
        1. Errors and Exceptions
        2. Try-Catch Blocks
        3. Throwing Errors
        4. Try It
        5. Exercises
      10. Chapter 22: Preventing Bugs (1/2)
      11. Chapter 22: Preventing Bugs (2/2)
        1. Input Assertions
        2. Other Assertions
        3. Try It
        4. Exercises
    13. Section IV: Classes
      1. Chapter 23: Defining Classes (1/4)
      2. Chapter 23: Defining Classes (2/4)
      3. Chapter 23: Defining Classes (3/4)
      4. Chapter 23: Defining Classes (4/4)
        1. What is a Class?
        2. Class Benefits
        3. Making a Class
        4. Try It
        5. Methods
        6. Events
        7. Try It
        8. Inheritance
        9. Polymorphism
        10. Try It
        11. Exercises
      5. Chapter 24: Initializing Objects (1/3)
      6. Chapter 24: Initializing Objects (2/3)
      7. Chapter 24: Initializing Objects (3/3)
        1. Initializing Objects
        2. Constructors
        3. Destructors
        4. Invoking Other Constructors
        5. Try It
        6. Exercises
      8. Chapter 25: Fine-Tuning Classes (1/2)
      9. Chapter 25: Fine-Tuning Classes (2/2)
        1. Overloading Methods
        2. Overriding Methods
        3. Try It
        4. Exercises
      10. Chapter 26: Overloading Operators (1/2)
      11. Chapter 26: Overloading Operators (2/2)
        1. Overloadable Operators
        2. Unary Operators
        3. Binary Operators
        4. Comparison Operators
        5. Try It
        6. Exercises
      12. Chapter 27: Using Interfaces (1/3)
      13. Chapter 27: Using Interfaces (2/3)
      14. Chapter 27: Using Interfaces (3/3)
        1. Interface Advantages
        2. Implementing Interfaces
        3. Defining Interfaces
        4. Try It
        5. Exercises
      15. Chapter 28: Making Generic Classes (1/2)
      16. Chapter 28: Making Generic Classes (2/2)
        1. Defining Generic Classes
        2. Using Generic Constraints
        3. Making Generic Methods
        4. Try It
        5. Exercises
    14. Section V: System Interactions
      1. Chapter 29: Reading and Writing Files (1/2)
      2. Chapter 29: Reading and Writing Files (2/2)
        1. Understanding Streams
        2. Writing Files
        3. Reading Files
        4. Try It
        5. Exercises
      3. Chapter 30: Using File System Classes (1/2)
      4. Chapter 30: Using File System Classes (2/2)
        1. The DriveInfo Class
        2. The DirectoryInfo Class
        3. The Directory Class
        4. The FileInfo Class
        5. The File Class
        6. The Path Class
        7. Try It
        8. Exercises
      5. Chapter 31: Printing (1/2)
      6. Chapter 31: Printing (2/2)
        1. Basic Printing
        2. Try It
        3. Exercises
      7. Chapter 32: Using the Clipboard (1/2)
      8. Chapter 32: Using the Clipboard (2/2)
        1. Adding Data to the Clipboard
        2. Getting Data from the Clipboard
        3. Try It
        4. Exercises
      9. Chapter 33: Providing Drag and Drop (1/2)
      10. Chapter 33: Providing Drag and Drop (2/2)
        1. Understanding Drag and Drop Events
        2. Starting a Drag
        3. Catching a Drop
        4. Try It
        5. Exercises
    15. Section VI: Specialized Topics
      1. Chapter 34: Localizing Programs (1/2)
      2. Chapter 34: Localizing Programs (2/2)
        1. Understanding Localization
        2. Building Localized Interfaces
        3. Processing Locale-Specific Values
        4. Try It
        5. Exercises
      3. Chapter 35: Programming Databases, Part 1 (1/2)
      4. Chapter 35: Programming Databases, Part 1 (2/2)
        1. Connecting to a Database
        2. Displaying Records in a Grid
        3. Displaying Records One Row at a Time
        4. Try It
        5. Exercises
      5. Chapter 36: Programming Databases, Part 2 (1/2)
      6. Chapter 36: Programming Databases, Part 2 (2/2)
        1. Searching
        2. Filtering
        3. Sorting
        4. Try It
        5. Exercises
      7. Chapter 37: LINQ to Objects (1/3)
      8. Chapter 37: LINQ to Objects (2/3)
      9. Chapter 37: LINQ to Objects (3/3)
        1. LINQ Basics
        2. Where Clauses
        3. Order By Clauses
        4. Select Clauses
        5. Try It
        6. Exercises
      10. Chapter 38: LINQ to SQL (1/3)
      11. Chapter 38: LINQ to SQL (2/3)
      12. Chapter 38: LINQ to SQL (3/3)
        1. Connecting to the Database
        2. Making LINQ to SQL Classes
        3. Writing Code
        4. Using LINQ Queries
        5. Understanding Nullable Fields
        6. Understanding Query Execution
        7. Using LINQ to SQL with Access
        8. Try It
        9. Exercises
      13. Chapter 39: Drawing with GDI+ (1/3)
      14. Chapter 39: Drawing with GDI+ (2/3)
      15. Chapter 39: Drawing with GDI+ (3/3)
        1. Graphics
        2. Pen
        3. Brush
        4. Try It
        5. Exercises
      16. Chapter 40: Making WPF Applications (1/3)
      17. Chapter 40: Making WPF Applications (2/3)
      18. Chapter 40: Making WPF Applications (3/3)
        1. Weighing WPF’s Benefits and Weaknesses
        2. Building WPF Applications
        3. Arranging WPF Controls
        4. Editing XAML Code
        5. Using WPF Styles
        6. Try It
        7. Exercises
      19. Chapter 41: Printing with WPF (1/2)
      20. Chapter 41: Printing with WPF (2/2)
        1. Printing Visuals
        2. Try It
        3. Exercises
      21. Appendix A: Glossary (1/2)
      22. Appendix A: Glossary (2/2)
      23. Appendix B: Control Summary (1/2)
      24. Appendix B: Control Summary (2/2)
      25. Appendix C: What’s on the DVD?
        1. System Requirements
        2. Using the DVD
        3. What’s on the DVD
        4. Troubleshooting
        5. Customer Care
    16. Index (1/6)
    17. Index (2/6)
    18. Index (3/6)
    19. Index (4/6)
    20. Index (5/6)
    21. Index (6/6)
18.219.35.128