SINGAPORE
Law
Welcome Guest | Login
SEARCH
Advanced
Microsoft Visual C# 2010 Step by Step (Step by Step (Microsoft)) (PAP/CDR): Sharp, John: BOOKS KINOKUNIYA
Book Details
Microsoft Visual C# 2010 Step by Step (Step by Step (Microsoft)) (PAP/CDR)
Microsoft Visual C# 2010 Step by Step (Step by Step (Microsoft)) (PAP/CDR)
Publisher : Microsoft Pr
Published Date : 2010/03
Binding : Paperback
ISBN : 9780735626706

BookWeb Price : S$ 75.69
Kinokuniya Privilege Card member price : S$ 68.12

Availability Status : Out of stock.
The item is subject to availability at publisher. We will e-mail you with an estimated delivery date as soon as we have more information.
Language : English

Book Description
Source: ENG
Academic Descriptors: A93603277
Place of Publication: United States
Continuations: Monograph Series,any number
Textual Format: Computer Applications
Academic Level: Extracurricular
Review:
Baker & Taylor Newly Released Computer Titles - January 2002 - Ongoing
Baker & Taylor Best-seller And Forthcoming Computer Titles - January 2000 - Ongoing
Phoenix Public Library Holdings (Internal Code for CLS)
Table of Contents
 
Acknowledgments                                    xvii
Introduction                                       xix
  Part I Introducing Microsoft Visual C# and
  Microsoft Visual Studio 2010
    Welcome to C#                                  3   (24)
      Beginning Programming with the Visual        3   (5)
      Studio 2010 Environment
      Writing Your First Program                   8   (6)
      Using Namespaces                             14  (3)
      Creating a Graphical Application             17  (9)
      Quick Reference                              26  (1)
    Working with Variables, Operators, and         27  (20)
    Expressions
      Understanding Statements                     27  (1)
      Using Identifiers                            28  (1)
        Identifying Keywords                       28  (1)
      Using Variables                              29  (2)
        Naming Variables                           30  (1)
        Declaring Variables                        30  (1)
      Working with Primitive Data Types            31  (5)
        Unassigned Local Variables                 32  (1)
        Displaying Primitive Data Type Values      32  (4)
      Using Arithmetic Operators                   36  (7)
        Operators and Types                        37  (1)
        Examining Arithmetic Operators             38  (3)
        Controlling Precedence                     41  (1)
        Using Associativity to Evaluate            42  (1)
        Expressions
        Associativity and the Assignment           42  (1)
        Operator
      Incrementing and Decrementing Variables      43  (2)
        Prefix and Postfix                         44  (1)
      Declaring Implicitly Typed Local Variables   45  (1)
      Quick Reference                              46  (1)
    Writing Methods and Applying Scope             47  (26)
      Creating Methods                             47  (6)
        Declaring a Method                         48  (1)
        Returning Data from a Method               49  (2)
        Calling Methods                            51  (1)
        Specifying the Method Call Syntax          51  (2)
      Applying Scope                               53  (3)
        Defining Local Scope                       54  (1)
        Defining Class Scope                       54  (1)
        Overloading Methods                        55  (1)
      Writing Methods                              56  (8)
      Using Optional Parameters and Named          64  (8)
      Arguments
        Defining Optional Parameters               65  (1)
        Passing Named Arguments                    66  (1)
        Resolving Ambiguities with Optional        66  (6)
        Parameters and Named Arguments
      Quick Reference                              72  (1)
    Using Decision Statements                      73  (18)
      Declaring Boolean Variables                  73  (1)
      Using Boolean Operators                      74  (3)
        Understanding Equality and Relational      74  (1)
        Operators
        Understanding Conditional Logical          75  (1)
        Operators
        Short-Circuiting                           76  (1)
        Summarizing Operator Precedence and        76  (1)
        Associativity
      Using if Statements to Make Decisions        77  (7)
        Understanding if Statement Syntax          77  (1)
        Using Blocks to Group Statements           78  (1)
        Cascading if Statements                    79  (5)
      Using switch Statements                      84  (5)
        Understanding switch Statement Syntax      85  (1)
        Following the switch Statement Rules       86  (3)
      Quick Reference                              89  (2)
    Using Compound Assignment and Iteration        91  (18)
    Statements
      Using Compound Assignment Operators          91  (1)
      Writing while Statements                     92  (5)
      Writing for Statements                       97  (2)
        Understanding for Statement Scope          98  (1)
      Writing do Statements                        99  (9)
      Quick Reference                              108 (1)
    Managing Errors and Exceptions                 109 (20)
      Coping with Errors                           109 (1)
      Trying Code and Catching Exceptions          110 (8)
        Unhandled Exceptions                       111 (1)
        Using Multiple catch Handlers              112 (1)
        Catching Multiple Exceptions               113 (5)
      Using Checked and Unchecked Integer          118 (3)
      Arithmetic
        Writing Checked Statements                 118 (1)
        Writing Checked Expressions                119 (2)
      Throwing Exceptions                          121 (3)
      Using a finally Block                        124 (2)
      Quick Reference                              126 (3)
  Part II Understanding the C# Language
    Creating and Managing Classes and Objects      129 (22)
      Understanding Classification                 129 (1)
      The Purpose of Encapsulation                 130 (1)
      Defining and Using a Class                   130 (2)
      Controlling Accessibility                    132 (10)
        Working with Constructors                  133 (1)
        Overloading Constructors                   134 (8)
      Understanding static Methods and Data        142 (7)
        Creating a Shared Field                    143 (1)
        Creating a static Field by Using the       144 (1)
        const Keyword
        Static Classes                             144 (3)
        Anonymous Classes                          147 (2)
      Quick Reference                              149 (2)
    Understanding Values and References            151 (22)
      Copying Value Type Variables and Classes     151 (5)
      Understanding Null Values and Nullable       156 (3)
      Types
        Using Nullable Types                       157 (1)
        Understanding the Properties of            158 (1)
        Nullable Types
      Using ref and out Parameters                 159 (3)
        Creating ref Parameters                    159 (1)
        Creating out Parameters                    160 (2)
      How Computer Memory Is Organized             162 (3)
        Using the Stack and the Heap               164 (1)
      The System.Object Class                      165 (1)
      Boxing                                       165 (1)
      Unboxing                                     166 (2)
      Casting Data Safely                          168 (3)
        The is Operator                            168 (1)
        The as Operator                            169 (2)
      Quick Reference                              171 (2)
    Creating Value Types with Enumerations and     173 (18)
    Structures
      Working with Enumerations                    173 (5)
        Declaring an Enumeration                   173 (1)
        Using an Enumeration                       174 (1)
        Choosing Enumeration Literal Values        175 (1)
        Choosing an Enumeration's Underlying       176 (2)
        Type
      Working with Structures                      178 (12)
        Declaring a Structure                      180 (1)
        Understanding Structure and class          181 (1)
        Differences
        Declaring Structure Variables              182 (1)
        Understanding Structure Initialization     183 (4)
        Copying Structure Variables                187 (3)
      Quick Reference                              190 (1)
    Using Arrays and Collections                   191 (28)
      What Is an Array?                            191 (15)
        Declaring Array Variables                  191 (1)
        Creating an Array Instance                 192 (1)
        Initializing Array Variables               193 (1)
        Creating an Implicitly Typed Array         194 (1)
        Accessing an Individual Array Element      195 (1)
        Iterating Through an Array                 195 (2)
        Copying Arrays                             197 (1)
        Using Multidimensional Arrays              198 (1)
        Using Arrays to Play Cards                 199 (7)
      What Are Collection Classes?                 206 (12)
        The ArrayList Collection Class             208 (2)
        The Queue Collection Class                 210 (1)
        The Stack Collection Class                 210 (1)
        The Hashtable Collection Class             211 (2)
        The SortedList Collection Class            213 (1)
        Using Collection Initializers              214 (1)
        Comparing Arrays and Collections           214 (1)
        Using Collection Classes to Play Cards     214 (4)
      Quick Reference                              218 (1)
    Understanding Parameter Arrays                 219 (12)
      Using Array Arguments                        220 (6)
        Declaring a params Array                   221 (2)
        Using params object[]                      223 (1)
        Using a params Array                       224 (2)
      Comparing Parameters Arrays and Optional     226 (3)
      Parameters
      Quick Reference                              229 (2)
    Working with Inheritance                       231 (22)
      What Is Inheritance                          231 (1)
      Using Inheritance                            232 (15)
        Calling Base Class Constructors            234 (1)
        Assigning Classes                          235 (2)
        Declaring new Methods                      237 (1)
        Declaring Virtual Methods                  238 (1)
        Declaring override Methods                 239 (3)
        Understanding protected Access             242 (5)
      Understanding Extension Methods              247 (4)
      Quick Reference                              251 (2)
    Creating Interfaces and Defining Abstract      253 (26)
    Classes
      Understanding Interfaces                     253 (16)
        Defining an Interface                      254 (1)
        Implementing an Interface                  255 (1)
        Referencing a Class Through Its            256 (1)
        Interface
        Working with Multiple Interfaces           257 (1)
        Explicitly Implementing an Interface       257 (2)
        Interface Restrictions                     259 (1)
        Defining and Using Interfaces              259 (10)
      Abstract Classes                             269 (2)
        Abstract Methods                           270 (1)
      Sealed Classes                               271 (6)
        Sealed Methods                             271 (1)
        Implementing and Using an Abstract Class   272 (5)
      Quick Reference                              277 (2)
    Using Garbage Collection and Resource          279 (16)
    Management
      The Life and Times of an Object              279 (5)
        Writing Destructors                        280 (2)
        Why Use the Garbage Collector?             282 (1)
        How Does the Garbage Collector Work?       283 (1)
        Recommendations                            284 (1)
      Resource Management                          284 (5)
        Disposal Methods                           285 (1)
        Exception-Safe Disposal                    285 (1)
        The using Statement                        286 (2)
        Calling the Dispose Method from a          288 (1)
        Destructor
      Implementing Exception-Safe Disposal         289 (3)
      Quick Reference                              292 (3)
  Part III Creating Components
    Implementing Properties to Access Fields       295 (20)
      Implementing Encapsulation by Using          296 (1)
      Methods
      What Are Properties?                         297 (5)
        Using Properties                           299 (1)
        Read-Only Properties                       300 (1)
        Write-Only Properties                      300 (1)
        Property Accessibility                     301 (1)
      Understanding the Property Restrictions      302 (2)
      Declaring Interface Properties               304 (3)
        Using Properties in a Windows              305 (2)
        Application
      Generating Automatic Properties              307 (1)
      Initializing Objects by Using Properties     308 (5)
      Quick Reference                              313 (2)
    Using Indexers                                 315 (14)
      What Is an Indexer?                          315 (7)
        An Example That Doesn't Use Indexers       315 (2)
        The Same Example Using Indexers            317 (2)
        Understanding Indexer Accessors            319 (1)
        Comparing Indexers and Arrays              320 (2)
      Indexers in Interfaces                       322 (1)
      Using Indexers in a Windows Application      323 (5)
      Quick Reference                              328 (1)
    Interrupting Program Flow and Handling         329 (24)
    Events
      Declaring and Using Delegates                329 (9)
        The Automated Factory Scenario             330 (1)
        Implementing the Factory Without Using     330 (1)
        Delegates
        Implementing the Factory by Using a        331 (2)
        Delegate
        Using Delegates                            333 (5)
      Lambda Expressions and Delegates             338 (4)
        Creating a Method Adapter                  339 (1)
        Using a Lambda Expression as an Adapter    339 (1)
        The Form of Lambda Expressions             340 (2)
      Enabling Notifications with Events           342 (3)
        Declaring an Event                         342 (1)
        Subscribing to an Event                    343 (1)
        Unsubscribing from an Event                344 (1)
        Raising an Event                           344 (1)
      Understanding WPF User Interface Events      345 (5)
        Using Events                               346 (4)
      Quick Reference                              350 (3)
    Introducing Generics                           353 (28)
      The Problem with objects                     353 (2)
      The Generics Solution                        355 (3)
        Generics vs. Generalized Classes           357 (1)
        Generics and Constraints                   358 (1)
      Creating a Generic Class                     358 (12)
        The Theory of Binary Trees                 358 (3)
        Building a Binary Tree Class by Using      361 (9)
        Generics
      Creating a Generic Method                    370 (3)
        Defining a Generic Method to Build a       371 (2)
        Binary Tree
      Variance and Generic Interfaces              373 (6)
        Covariant Interfaces                       375 (2)
        Contravariant Interfaces                   377 (2)
      Quick Reference                              379 (2)
    Enumerating Collections                        381 (14)
      Enumerating the Elements in a Collection     381 (8)
        Manually Implementing an Enumerator        383 (4)
        Implementing the IEnumerable Interface     387 (2)
      Implementing an Enumerator by Using an       389 (5)
      Iterator
        A Simple Iterator                          389 (2)
        Defining an Enumerator for the             391 (3)
        Tree<TItem> Class by Using an
        Iterator
      Quick Reference                              394 (1)
    Querying In-Memory Data by Using Query         395 (24)
    Expressions
      What Is Language Integrated Query?           395 (1)
      Using LINQ in a C# Application               396 (20)
        Selecting Data                             398 (2)
        Filtering Data                             400 (1)
        Ordering, Grouping, and Aggregating Data   401 (3)
        Joining Data                               404 (1)
        Using Query Operators                      405 (2)
        Querying Data in Tree<TItem>         407 (5)
        Objects
        LINQ and Deferred Evaluation               412 (4)
      Quick Reference                              416 (3)
    Operator Overloading                           419 (24)
      Understanding Operators                      419 (5)
        Operator Constraints                       420 (1)
        Overloaded Operators                       420 (2)
        Creating Symmetric Operators               422 (2)
      Understanding Compound Assignment            424 (1)
      Evaluation
      Declaring Increment and Decrement            425 (1)
      Operators
      Comparing Operators in Structures and        426 (1)
      Classes
      Defining Operator Pairs                      426 (1)
      Implementing Operators                       427 (7)
      Understanding Conversion Operators           434 (6)
        Providing Built-in Conversions             434 (1)
        Implementing User-Defined Conversion       435 (1)
        Operators
        Creating Symmetric Operators, Revisited    436 (1)
        Writing Conversion Operators               437 (3)
      Quick Reference                              440 (3)
  Part IV Building Windows Presentation
  Foundation Applications
    Introducing Windows Presentation Foundation    443 (34)
      Creating a WPF Application                   443 (15)
        Building the WPF Application               444 (14)
      Adding Controls to the Form                  458 (12)
        Using WPF Controls                         458 (8)
        Changing Properties Dynamically            466 (4)
      Handling Events in a WPF Form                470 (6)
        Processing Events in Windows Forms         471 (5)
      Quick Reference                              476 (1)
    Gathering User Input                           477 (32)
      Menu Guidelines and Style                    477 (1)
      Menus and Menu Events                        478 (13)
        Creating a Menu                            478 (6)
        Handling Menu Events                       484 (7)
      Shortcut Menus                               491 (4)
        Creating Shortcut Menus                    491 (4)
      Windows Common Dialog Boxes                  495 (3)
        Using the SaveFileDialog Class             495 (3)
      Improving Responsiveness in a WPF            498 (10)
      Application
      Quick Reference                              508 (1)
    Performing Validation                          509 (26)
      Validating Data                              509 (1)
        Strategies for Validating User Input       509 (1)
      An Example---Order Tickets for Events        510 (21)
        Performing Validation by Using Data        511 (16)
        Binding
        Changing the Point at Which Validation     527 (4)
        Occurs
      Quick Reference                              531 (4)
  Part V Managing Data
    Querying Information in a Database             535 (30)
      Querying a Database by Using ADO.NET         535 (14)
        The Northwind Database                     536 (1)
        Creating the Database                      536 (2)
        Using ADO.NET to Query Order Information   538 (11)
      Querying a Database by Using LINQ to SQL     549 (15)
        Defining an Entity Class                   549 (2)
        Creating and Running a LINQ to SQL Query   551 (2)
        Deferred and Immediate Fetching            553 (1)
        Joining Tables and Creating                554 (4)
        Relationships
        Deferred and Immediate Fetching            558 (1)
        Revisited
        Defining a Custom DataContext Class        559 (1)
        Using LINQ to SQL to Query Order           560 (4)
        Information
      Quick Reference                              564 (1)
    Displaying and Editing Data by Using the       565 (34)
    Entity Framework and Data Binding
      Using Data Binding with the Entity           566 (17)
      Framework
      Using Data Binding to Modify Data            583 (13)
        Updating Existing Data                     583 (1)
        Handling Conflicting Updates               584 (3)
        Adding and Deleting Data                   587 (9)
      Quick Reference                              596 (3)
  Part VI Building Professional Solutions with
  Visual Studio 2010
    Introducing the Task Parallel Library          599 (50)
      Why Perform Multitasking by Using            600 (2)
      Parallel Processing?
        The Rise of the Multicore Processor        601 (1)
      Implementing Multitasking in a Desktop       602 (26)
      Application
        Tasks, Threads, and the ThreadPool         603 (1)
        Creating, Running, and Controlling Tasks   604 (4)
        Using the Task Class to Implement          608 (9)
        Parallelism
        Abstracting Tasks by Using the Parallel    617 (7)
        Class
        Returning a Value from a Task              624 (4)
      Using Tasks and User Interface Threads       628 (4)
      Together
      Canceling Tasks and Handling Exceptions      632 (14)
        The Mechanics of Cooperative               633 (8)
        Cancellation
        Handling Task Exceptions by Using the      641 (4)
        AggregateException Class
        Using Continuations with Canceled and      645 (1)
        Faulted Tasks
      Quick Reference                              646 (3)
    Performing Parallel Data Access                649 (34)
      Using PLINQ to Parallelize Declarative       650 (6)
      Data Access
        Using PLINQ to Improve Performance         650 (5)
        While Iterating Through a Collection
        Specifying Options for a PLINQ Query       655 (1)
        Canceling a PLINQ Query                    656 (1)
      Synchronizing Concurrent Imperative Data     656 (25)
      Access
        Locking Data                               659 (2)
        Synchronization Primitives in the Task     661 (7)
        Parallel Library
        Cancellation and the Synchronization       668 (1)
        Primitives
        The Concurrent Collection Classes          668 (2)
        Using a Concurrent Collection and a        670 (11)
        Lock to Implement Thread-Safe Data
        Access
      Quick Reference                              681 (2)
    Creating and Using a Web Service               683 (34)
      What Is a Web Service?                       684 (1)
        The Role of Windows Communication          684 (1)
        Foundation
      Web Service Architectures                    684 (4)
        SOAP Web Services                          685 (2)
        REST Web Services                          687 (1)
      Building Web Services                        688 (27)
        Creating the ProductInformation SOAP       689 (8)
        Web Service
        SOAP Web Services, Clients, and Proxies    697 (1)
        Consuming the ProductInformation SOAP      698 (6)
        Web Service
        Creating the ProductDetails REST Web       704 (7)
        Service
        Consuming the ProductDetails REST Web      711 (4)
        Service
      Quick Reference                              715 (2)
Appendix Interoperating with Dynamic Languages     717 (10)
Index                                              727
 

Teach yourself Visual C# 2010 one step at a time. Ideal for developers with fundamental programming skills, this practical tutorial features learn-by-doing exercises that demonstrate how, when, and why to use the features of the C# rapid application development environment. You ll learn how to use Microsoft Visual Studio(r) 2010 and Microsoft .NET Framework 4.0; develop a solid, fundamental understanding of C# language features; and then get to work creating actual components and working applications for the Windows(r) operating system. You ll also delve into data management technologies and Web-based applications.