Course (5-4) MS Visual C#

zoom

pre 1 of 1 next

Location: New York - Map

Date posted: June 21, 2013

Price: Please contact

Ad ID: 91864

Views: 12

Reply by email

close X
  • 1. Welcome to C#
    • 1.1. Beginning Programming with the Visual Studio 2010 Environment
    • 1.2. Writing Your First Program
    • 1.3. Using Namespaces
    • 1.4. Creating a Graphical Application
    • 1.5. Chapter 1 Quick Reference
  • 2. Working with Variables, Operators, and Expressions
    • 2.1. Understanding Statements
    • 2.2. Using Identifiers
      • 2.2.1. Identifying Keywords
    • 2.3. Using Variables
      • 2.3.1. Naming Variables
      • 2.3.2. Declaring Variables
    • 2.4. Working with Primitive Data Types
      • 2.4.1. Unassigned Local Variables
      • 2.4.2. Displaying Primitive Data Type Values
    • 2.5. Using Arithmetic Operators
      • 2.5.1. Operators and Types
      • 2.5.2. Examining Arithmetic Operators
      • 2.5.3. Controlling Precedence
      • 2.5.4. Using Associativity to Evaluate Expressions
      • 2.5.5. Associativity and the Assignment Operator
    • 2.6. Incrementing and Decrementing Variables
      • 2.6.1. Prefix and Postfix
    • 2.7. Declaring Implicitly Typed Local Variables
  • 3. Writing Methods and Applying Scope
    • 3.1. Creating Methods
      • 3.1.1. Declaring a Method
      • 3.1.2. Returning Data from a Method
      • 3.1.3. Calling Methods
      • 3.1.4. Specifying the Method Call Syntax
    • 3.2. Applying Scope
      • 3.2.1. Defining Local Scope
      • 3.2.2. Defining Class Scope
      • 3.2.3. Overloading Methods
    • 3.4. Writing Methods
    • 3.5. Using Optional Parameters and Named Arguments
      • 3.5.1. Defining Optional Parameters
      • 3.5.2. Passing Named Arguments
      • 3.5.3. Resolving Ambiguities with Optional Parameters and Named Arguments
  • 4 Using Decision Statements
    • 4.1. Declaring Boolean Variables
    • 4.2. Using Boolean Operators
      • 4.2.1. Understanding Equality and Relational Operators
      • 4.2.2. Understanding Conditional Logical Operators
      • 4.2.3. Short-Circuiting
      • 4.2.4. Summarizing Operator Precedence and Associativity
    • 4.5. Using if Statements to Make Decisions
      • 4.5.1. Understanding if Statement Syntax
      • 4.5.2. Using Blocks to Group Statements
      • 4.5.3. Cascading if Statements
    • 4.6. Using switch Statements
      • 4.6.1. Understanding switch Statement Syntax
      • 4.6.2. Following the switch Statement Rules
  • 5. Using Compound Assignment and Iteration Statements
    • 5.1. Using Compound Assignment Operators
    • 5.2. Writing while Statements
    • 5.3. Writing for Statements
      • 5.3.1. Understanding for Statement Scope
    • 5.4. Writing do Statements
  • 6. Managing Errors and Exceptions
    • 6.1. Coping with Errors
    • 6.2. Trying Code and Catching Exceptions
      • 6.2.1. Unhandled Exceptions
      • 6.2.2. Using Multiple catch Handlers
      • 6.2.3. Catching Multiple Exceptions
    • 6.3. Using Checked and Unchecked Integer Arithmetic
      • 6.3.1. Writing Checked Statements
      • 6.3.2. Writing Checked Expressions
    • 6.4. Throwing Exceptions
    • 6.5. Using a finally Block
  • 7. Creating and Managing Classes and Objects
    • 7.1. Understanding Classification
    • 7.2. The Purpose of Encapsulation
    • 7.3. Defining and Using a Class
    • 7.4. Controlling Accessibility
      • 7.4.1. Working with Constructors
      • 7.4.2. Overloading Constructors
    • 7.5. Understanding static Methods and Data
      • 7.5.1. Creating a Shared Field
      • 7.5.2. Creating a static Field by Using the const Keyword
      • 7.5.3. Static Classes
      • 7.5.4. Anonymous Classes
  • 8. Understanding Values and References
    • 8.1. Copying Value Type Variables and Classes
    • 8.2. Understanding Null Values and Nullable Types
      • 8.2.1. Using Nullable Types
      • 8.2.2. Understanding the Properties of Nullable Types
    • 8.3. Using ref and out Parameters
      • 8.3.1. Creating ref Parameters
      • 8.3.2. Creating out Parameters
    • 8.4. How Computer Memory Is Organized
      • 8.4.1. Using the Stack and the Heap
    • 8.5. The System.Object Class
    • 8.6. Boxing
    • 8.7. Unboxing
    • 8.8. Casting Data Safely
      • 8.8.1. The is Operator
      • 8.8.2. The as Operator
  • 9. Creating Value Types with Enumerations and Structures
    • 9.1. Working with Enumerations
      • 9.1.1. Declaring an Enumeration
      • 9.1.2. Using an Enumeration
      • 9.1.3. Choosing Enumeration Literal Values
    • 9.2. Choosing an Enumeration’s Underlying Type
      • 9.2.1. Working with Structures
      • 9.2.2. Declaring a Structure
      • 9.2.3. Understanding Structure and Class Differences
      • 9.2.4. Declaring Structure Variables
      • 9.2.5. Understanding Structure Initialization
  • 10. Using Arrays and Collections
    • 10.1. What Is an Array?
      • 10.1.1. Declaring Array Variables
      • 10.1.2. Creating an Array Instance
      • 10.1.3. Initializing Array Variables
      • 10.1.4. Creating an Implicitly Typed Array
      • 10.1.5. Accessing an Individual Array Element
      • 10.1.6. Iterating Through an Array
      • 10.1.7. Copying Arrays
      • 10.1.8. Using Multidimensional Arrays
      • 10.1.9. Using Arrays to Play Cards
    • 10.2. What Are Collection Classes?
      • 10.2.1. The ArrayList Collection Class
      • 10.2.2. The Queue Collection Class
      • 10.2.3. The Stack Collection Class
      • 10.2.4. The Hashtable Collection Class
      • 10.2.5. The SortedList Collection Class
      • 10.2.6. Using Collection Initializers
      • 10.2.7. Comparing Arrays and Collections
      • 10.2.8. Using Collection Classes to Play Cards
  • 11. Understanding Parameter Arrays
    • 11.1. Using Array Arguments
      • 11.1.1. Declaring a params Array
      • 11.1.2. Using params object[ ]
      • 11.1.3. Using a params Array
    • 11.2. Comparing Parameters Arrays and Optional Parameters
  • 12. Working with Inheritance
    • 12.1. What Is Inheritance?
    • 12.2. Using Inheritance
      • 12.2.1. Calling Base Class Constructors
      • 12.2.2. Assigning Classes
      • 12.2.3. Declaring new Methods
      • 12.2.4. Declaring Virtual Methods
      • 12.2.5. Declaring override Methods
      • 12.2.6. Understanding protected Access
    • 12.3. Understanding Extension Methods
  • 13. Creating Interfaces and Defining Abstract Classes
    • 13.1. Understanding Interfaces
      • 13.1.1. Defining an Interface
      • 13.1.2. Implementing an Interface
      • 13.1.3. Referencing a Class Through Its Interface
      • 13.1.4. Working with Multiple Interfaces
      • 13.1.5. Explicitly Implementing an Interface
      • 13.1.6. Interface Restrictions
      • 13.1.7. Defining and Using Interfaces
    • 13.2. Abstract Classes
      • 13.2.1. Abstract Methods
    • 13.3. Sealed Classes
      • 13.3.1. Sealed Methods
      • 13.3.2. Implementing and Using an Abstract Class
  • 14. Using Garbage Collection and Resource Management
    • 14.1. The Life and Times of an Object
      • 14.1.1. Writing Destructors
      • 14.1.2. Why Use the Garbage Collector?
      • 14.1.3. How Does the Garbage Collector Work?
      • 14.1.4. Recommendations
    • 14.2. Resource Management
      • 14.2.1. Disposal Methods
      • 14.2.2. Exception-Safe Disposal
      • 14.2.3. The using Statement
      • 14.2.4. Calling the Dispose Method from a Destructor
    • 14.3. Implementing Exception-Safe Disposal
  • 15. Implementing Properties to Access Fields
    • 15.1. Implementing Encapsulation by Using Methods
    • 15.2. What Are Properties?
      • 15.2.1. Using Properties
      • 15.2.2. Read-Only Properties
      • 15.2.3. Write-Only Properties
      • 15.2.4. Property Accessibility
    • 15.3. Understanding the Property Restrictions
    • 15.4. Declaring Interface Properties
      • 15.4.1. Using Properties in a Windows Application
    • 15.5. Generating Automatic Properties
    • 15.6. Initializing Objects by Using Properties
  • 16. Using Indexers
    • 16.1. What Is an Indexer?
      • 16.1.1. An Example That Doesn’t Use Indexers
      • 16.1.2. The Same Example Using Indexers
      • 16.1.3. Understanding Indexer Accessors
      • 16.1.4. Comparing Indexers and Arrays
    • 16.2. Indexers in Interfaces
    • 16.3. Using Indexers in a Windows Application
  • 17. Interrupting Program Flow and Handling Events
    • 17.1. Declaring and Using Delegates
      • 17.1.1. The Automated Factory Scenario
      • 17.1.2. Implementing the Factory Without Using Delegates
      • 17.1.3. Implementing the Factory by Using a Delegate
      • 17.1.4. Using Delegates
    • 17.2. Lambda Expressions and Delegates
      • 17.2.1. Creating a Method Adapter
      • 17.2.2. Using a Lambda Expression as an Adapter
      • 17.2.3. The Form of Lambda Expressions
    • 17.3. Enabling Notifications with Events
      • 17.3.1. Declaring an Event
      • 17.3.2. Subscribing to an Event
      • 17.3.3. Unsubscribing from an Event
      • 17.3.4. Raising an Event
    • 17.4. Understanding WPF User Interface Events
    • 17.5. Using Events
  • 18. Introducing Generics
    • 18.1. The Problem with objects
    • 18.2. The Generics Solution
      • 18.2.1. Generics vs . Generalized Classes
      • 18.2.2. Generics and Constraints
    • 18.3. Creating a Generic Class
      • 18.3.1. The Theory of Binary Trees
      • 18.3.2. Building a Binary Tree Class by Using Generics
    • 18.4. Creating a Generic Method
      • 18.4.1. Defining a Generic Method to Build a Binary Tree
    • 18.5. Variance and Generic Interfaces
      • 18.5.1. Covariant Interfaces
      • 18.5.2. Contravariant Interfaces
  • 19. Enumerating Collections
    • 19.1. Enumerating the Elements in a Collection
      • 19.1.1. Manually Implementing an Enumerator
      • 19.1.2. Implementing the IEnumerable Interface
    • 19.3. Implementing an Enumerator by Using an Iterator
      • 19.3.1. A Simple Iterator
      • 19.3.2. Defining an Enumerator for the Tree<TItem> Class
      • 19.3.3. by Using an Iterator
  • 20. Querying In-Memory Data by Using Query Expressions
    • 20.1. What Is Language Integrated Query?
    • 20.2. Using LINQ in a C# Application
      • 20.2.1. Selecting Data
      • 20.2.2. Filtering Data
      • 20.2.3. Ordering, Grouping, and Aggregating Data
      • 20.2.4. Joining Data
      • 20.2.5. Using Query Operators
      • 20.2.6. Querying Data in Tree<TItem> Objects
      • 20.2.7. LINQ and Deferred Evaluation
  • 21. Operator Overloading
    • 21.1. Understanding Operators
      • 21.1.1. Operator Constraints
      • 21.1.2. Overloaded Operators
      • 21.1.3. Creating Symmetric Operators
    • 21.2. Understanding Compound Assignment Evaluation
    • 21.3. Declaring Increment and Decrement Operators
    • 21.4. Comparing Operators in Structures and Classes
    • 21.5. Defining Operator Pairs
    • 21.6. Implementing Operators
    • 21.7. Understanding Conversion Operators
      • 21.7.1. Providing Built-in Conversions
      • 21.7.2. Implementing User-Defined Conversion Operators
      • 21.7.3. Creating Symmetric Operators, Revisited
      • 21.7.4. Writing Conversion Operators
  • 22. Introducing Windows Presentation Foundation
    • 22.1. Creating a WPF Application
      • 22.1.1. Building the WPF Application
    • 22.2. Adding Controls to the Form
      • 22.2.1. Using WPF Controls
      • 22.2.2. Changing Properties Dynamically
    • 22.3. Handling Events in a WPF Form
      • 22.3.1. Processing Events in Windows Forms
  • 23. Gathering User Input
    • 23.1. Menu Guidelines and Style
    • 23.2. Menus and Menu Events
      • 23.2.1. Creating a Menu
      • 23.2.2. Handling Menu Events
    • 23.3. Shortcut Menus
      • 23.3.1. Creating Shortcut Menus
    • 23.4. Windows Common Dialog Boxes
      • 23.4.1. Using the SaveFileDialog Class
    • 23.5. Improving Responsiveness in a WPF Application
  • 24. Performing Validation
    • 24.1. Validating Data
      • 24.1.1. Strategies for Validating User Input
    • 24.2. An Example—Order Tickets for Events
      • 24.2.1. Performing Validation by Using Data Binding
      • 24.2.2. Changing the Point at Which Validation Occurs
  • 25. Querying Information in a Database
    • 25.1. Querying a Database by Using ADO .NET
      • 25.1.1. The Northwind Database
      • 25.1.2. Creating the Database
      • 25.1.3. Using ADO .NET to Query Order Information
    • 25.2. Querying a Database by Using LINQ to SQL
      • 25.2.1. Defining an Entity Class
      • 25.2.2. Creating and Running a LINQ to SQL Query
      • 25.2.3. Deferred and Immediate Fetching
      • 25.2.4. Joining Tables and Creating Relationships
      • 25.2.5. Deferred and Immediate Fetching Revisited
      • 25.2.6. Defining a Custom DataContext Class
      • 25.2.7. Using LINQ to SQL to Query Order Information
  • 26. Displaying and Editing Data by Using the Entity Framework and Data Binding
    • 26.1. Using Data Binding with the Entity Framework
    • 26.2. Using Data Binding to Modify Data
      • 26.2.1. Updating Existing Data
      • 26.2.2. Handling Conflicting Updates
      • 26.2.3. Adding and Deleting Data
  • 27. Introducing the Task Parallel Library
    • 27.1. Why Perform Multitasking by Using Parallel Processing?
      • 27.1.1. The Rise of the Multicore Processor
    • 27.2. Implementing Multitasking in a Desktop Application
      • 27.2.1. Tasks, Threads, and the ThreadPool
      • 27.2.2. Creating, Running, and Controlling Tasks
      • 27.2.3. Using the Task Class to Implement Parallelism
      • 27.2.4. Abstracting Tasks by Using the Parallel Class
      • 27.2.5. Returning a Value from a Task
    • 27.3. Using Tasks and User Interface Threads Together
    • 27.4. Canceling Tasks and Handling Exceptions
      • 27.4.1. The Mechanics of Cooperative Cancellation
      • 27.4.2. Handling Task Exceptions by Using the AggregateException Class
      • 27.4.3. Using Continuations with Canceled and Faulted Tasks
  • 28. Performing Parallel Data Access
    • 28.1. Using PLINQ to Parallelize Declarative Data Access
      • 28.1.1. Using PLINQ to Improve Performance While Iterating Through a Collection
      • 28.1.2. Specifying Options for a PLINQ Query
      • 28.1.3. Canceling a PLINQ Query
    • 28.2. Synchronizing Concurrent Imperative Data Access
      • 28.2.1. Locking Data
      • 28.2.2. Synchronization Primitives in the Task Parallel Library
      • 28.2.3. Cancellation and the Synchronization Primitives
      • 28.2.4. The Concurrent Collection Classes
      • 28.2.5. Using a Concurrent Collection and a Lock to Implement Thread-Safe Data Access
  • 29. Creating and Using a Web Service
    • 29.1. What Is a Web Service?
      • 29.1.1. The Role of Windows Communication Foundation
    • 29.2. Web Service Architectures
      • 29.2.1. SOAP Web Services
      • 29.2.2. REST Web Services
    • 29.3. Building Web Services
      • 29.3.1. Creating the ProductInformation SOAP Web Service
      • 29.3.2. SOAP Web Services, Clients, and Proxies
      • 29.3.3. Consuming the ProductInformation SOAP Web Service
      • 29.3.4. Creating the ProductDetails REST Web Service
      • 29.3.5. Consuming the ProductDetails REST Web Service

Online LIVE Training Programming Course offered by INCAPROG ONLINE - www.incaprog.com - contacto@incaprog.com - Phone : (954) 727-3141

  • Share this ad: pictute pictute pictute pictute
  • Print: pictute
  • Add to favorites: pictute
  • Report: pictute