Introducing Visual C# 2010 1st Edition by Adam Freeman – Ebook PDF Instant Download/Delivery. 1430231726, 9781430231721
Full download Introducing Visual C# 2010 1st Edition after payment
Product details:
ISBN 10: 1430231726
ISBN 13: 9781430231721
Author: Adam Freeman
If you’re new to C# programming, this book is the ideal way to get started. Respected author Adam Freeman guides you through the C# language by carefully building up your knowledge from fundamental concepts to advanced features. The book gradually builds up your knowledge, using the concepts you have already grasped to support those that come next. You will explore all the core areas of the C# language and the .NET Framework on which it runs. Particular attention is paid to the creation of Web and Windows applications and data access—danger zones where novice programmers often go awry in their early coding attempts. Introducing Visual C# 2010 is a comprehensive primer. Even if you have no previous programming experience, you can have confidence in the fact that you’ll be able to build well constructed web and Windows applications of your own once you have finished reading this book.
Introducing Visual C# 2010 1st Table of contents:
PART 1 Getting Started
Chapter 1 Introduction
Who Should Read This Book?
What Is Covered in This Book?
What Do You Need to Read This Book?
What Is the Structure of This Book?
What Is in Each Chapter?
Getting the Example Code
Finding More Information
The MSDN C# Programming Guide
Online Forums
Other Books
Summary
Chapter 2 Getting Ready
Installing the Software
Installing Visual Studio 2010
Installing SQL Server 2008
Installing the Silverlight Tools
Downloading the Sample Code and Data
Creating Your First C# Project
Creating the Project
Editing the Code
Compiling and Running the Program
Features That I Use Before Explaining Them
The using statements
The namespace statement
The class statement
The Main method
The Code Comments
The Console.WriteLine and Console.ReadLine methods
Summary
Chapter 3 Understanding C# and the .NET Framework
C# and the .NET Framework at a Glance
Introducing C#
Introducing the .NET Framework
Introducing the Common Language Runtime
Introducing the Class Library
The Relationship between C# and the .NET Framework
Using C# Code Files
Understanding Assemblies
The Key Features of C# and the .NET Framework
Understanding Object-Orientation
Understanding Type Safety
Understanding Automatic Memory Management
Understanding the Just-In-Time Compiler
Understanding Parallel Processing
Understanding Unmanaged/Native Code Support
Understanding the .NET Technology Spectrum
Understanding ASP.NET
Understanding LINQ
Understanding the Task Parallel Library
Understanding User Interfaces
Understanding ADO.NET
Understanding the Windows Communication Foundation
Understanding .NET Cross-Platform Support
Summary
PART 2 The C# Language
Chapter 4 C# Fundamentals and Keyword Reference
Language Fundamentals
A Simple C# Program
C# Syntax
Identifiers
Keywords
Literals
Operators
Punctuators
Statements
Comments
Types
Value Types
Reference Types
Definite Assignment and Null References
Common Programming Tasks
Assigning Values
Making Comparisons
Performing Selections
Using an if Statement
Using a switch Statement
Iterating Data Items
Using a for Loop
Using a foreach Loop
Using a do…while Loop
Using a while Loop
Keyword and Operator Reference
Type Keywords
bool
byte, sbyte
char
class
decimal, double, float
delegate
dynamic
enum
interface
object
string
struct
short, ushort, int, uint, long, ulong
void
var
Modifiers
public, protected, private, internal
abstract
const
event
in, out
override
readonly
sealed
static
virtual
Selection Keywords
if, else
switch, case, default
Iterator Keywords
for
foreach
do, while
Jump Keywords
break
continue
goto
return
Exception Handling Keywords
throw
try, catch, finally
Arithmetic Overflow Keywords
checked, unchecked
Synchronization Keywords
lock
Parameter Keywords
params
ref
out
Namespace Keywords
namespace
using
Literal Keywords
null
true, false
Object Keywords
is, as
new
typeof
LINQ Keywords
Other Keywords
base
get, set, value
global
implicit, explicit
operator
partial
using
this
yield
Operators[ ] Operator
( ) Operator
Dot (.) Operator
:: Operator
+, -, *, /, % Operators
==, !=, >, >=, <, <= Operators
++, +=, –, -= Operators
&&, || Operators
&, |, ^, ~, <> Operators
=> Operator
=, +=, -=, *=, /=, %=, &=, >>=, <<=, ^= Operators
Summary
Chapter 5 Numeric and Boolean Types
Numeric Types
Using Numeric Literals
Using Literal Suffixes
Using Literal Prefixes
Implicit and Explicit Numeric Type Conversions
Using Overflow Checking
Using Struct Members
Common Members
Using Type-Specific Members
Using Numeric Operators
Arithmetic Operators
Unary Operators
Relational Operators
Logical Operators
Assignment Operators
Working with Very Large Integer Values
The Boolean Type
Using Boolean Literals
Using Boolean Results
Using Struct Members
Summary
Chapter 6 Classes and Objects
Creating a Basic Class
Adding Features to a Class
Adding Fields
Adding Methods
Adding a Constructor
Creating Objects from Classes
Using Objects
Reading and Modifying Fields
References to Common Objects
Using Static Fields
Calling Methods
Class Inheritance
Understanding Inheritance
Overriding Methods
Inheriting Derivations
Understanding Encapsulation
Understanding Polymorphism
Casting Objects and Type Checking
Implicit vs. Explicit Casting
Type Conversion Exceptions
Avoiding Explicit Cast Exceptions
Testing an Object’s Type
Casting Without Exceptions
Boxing and Unboxing
Using Nested Classes
Using Class Modifiers
Creating Static Classes
Creating Abstract Classes
Creating Sealed Classes
Creating Partial Classes
Using Access Modifiers
Summary
Chapter 7 Fields
Defining and Using Fields
Defining Fields
Initializing Fields
Reading and Updating Fields
Working Directly with Field Values
Allowing Other Classes to Read and Modify Properties
Exposing Properties with Field Values
Understanding Reference Type Fields
The Fourth Stage of the Life Cycle
Applying Field Modifiers
Creating Static Fields
Creating Read-Only Fields
Using the const keyword
Using the readonly Keyword
Applying Access Modifiers
Hiding Base Class Fields
Using the volatile Keyword
Summary
Chapter 8 Properties, Indexers, and Operators
Creating a Property
Creating a Field-Backed Property
Using a Property
Creating an Automatically Implemented Property
Creating an Asymmetric Property
Creating a Computed Property
Mapping a Property Type to a Field Type
Using Access Modifiers
Using Other Modifiers
Using the virtual and override Modifiers
Using the abstract Modifier
Using the sealed Keyword
Using the static Keyword
Creating an Indexer
Using Multiple Indexers
Creating a Validating Indexer
Creating an Indexer with Multiple Arguments
Creating Custom Operators
Creating Custom Unary Operators
Creating Custom Binary Operators
Creating Custom Conversion Operators
Summary
Chapter 9 Methods
Creating and Using a Simple Method
Defining the Method Name
Defining the Result Type
Defining the Parameters
Defining the Modifiers
Defining the Method Body
Using the Methods
Understanding Parameters
Using Value Parameters
Using Reference Parameters
Using Output Parameters
Using Parameter Arrays
Using Optional Parameters
Using Named Parameters
Understanding Method Bodies
Using Local Variables
Naming Variables
Understanding Variable Scope and Lifetime
Using Method Results
Understanding Method Modifiers
Using Access Modifiers
Creating Static Methods
Creating Virtual Methods
Creating Sealed Methods
Creating Abstract Methods
Overloading Methods
Hiding and Overriding Methods
Hiding Methods
Overriding Methods
Sealing Methods
Understanding Method Specialization
Special Methods
The Main Method
Constructors
Using the Default Constructor
Initializing Properties and Fields at Construction
Overloading Constructors
Calling Base Class Constructors
Controlling Access to Constructors
Creating Copy Constructors
Using Static Constructors
Creating Factory Methods
Destructors
Iterator Blocks
Using the yield Keyword
Exposing Field Iterators
Using Multiple yield Statements
Using Named Iterator Blocks
Partial Methods
Abstract Methods
Extension Methods
Summary
Chapter 10 Delegates, Events, and Anonymous Methods
Using Delegates
Using Delegates for Callbacks
Multicasting with Delegates
Delegating Selectively
Interrogating Delegates
Using Events
Defining and Publishing EventHandler Pattern Events
Creating Nongeneric Events
Creating Events Without Custom Data
Applying Modifiers to Events
Using Action and Func Delegates
Using Action Delegates
Using Func Delegates
Anonymous Methods
Capturing Outer Variables
Lambda Expressions
Summary
Chapter 11 Namespaces
Consuming Namespaces
Using Fully Qualified Names
Importing Namespaces
Creating Namespaces
Nesting Namespaces
Logically Nesting Namespaces
Spreading Namespaces Across Files
Adding Types to Existing Namespaces
Disambiguating Namespaces and Types
Disambiguation with Fully Qualified Names
Disambiguating with Aliases
Aliasing Namespaces
Resolving Type or Namespace Hiding
Summary
Chapter 12 Interfaces, Structs, and Enums
Using Interfaces
Defining and Using a Simple Interface
Defining an Interface
Implementing an Interface
Using an Interface
Specifying Interface Members
Specifying Methods
Specifying Properties
Specifying an Event
Specifying an Indexer
Deriving Interfaces
Deriving from Multiple Base Interfaces
Defining a Partial Interface
Implementing Interfaces
Implementing Multiple Interfaces
Explicitly Implementing an Interface
Inheriting Interface Implementations
Implementing an Interface in an Abstract Class
Using Structs
Defining and Instantiating a Struct
Implementing Interfaces
Differences Between Structs and Classes
Base Structs and Inheritance
Defining Fields
Defining a Struct Constructor
Copying a Struct
Using an Enum
Defining an Enum
Using an Enum
Using Underlying Types and Numeric Values
Combining Enum Values
Summary
Chapter 13 Arrays
Defining and Initializing Arrays
Getting and Setting Array Values
Using Array Initializers
Enumerating Arrays
Enumerating with a for Loop
Enumerating with a foreach Loop
Enumerating Using IEnumerator and IEnumerator
Breaking from Enumerations
Using System.Array Members
Sorting Arrays
Processing All of the Elements in an Array
Resizing and Copying an Array
Finding Items in an Array
Using Arrays with LINQ
Using Arrays as Collections
Using Multidimensional Arrays
Using Rectangular Arrays
Getting and Setting Rectangular Array Values
Using Rectangular Array Initializers
Enumerating a Rectangular Array
Creating Rectangular Arrays with Additional Dimensions
Using Jagged Arrays
Getting and Setting Jagged Array Values
Using Jagged Array Initializers
Enumerating a Jagged Array
Summary
Chapter 14 Exceptions
Handling Exceptions
Using try Statements and catch Clauses
Handling Different Exception Types
Using Specific catch Clauses
Using General catch Clauses
Omitting catch Clauses
Nesting try Statements
Using Exception Members
Using finally Clauses
Throwing Exceptions
Rethrowing Exceptions
Creating and Throwing Custom Exceptions
Throwing Meaningful Exceptions
Mapping One Exception Type to Another
Creating Exception Chains
Aggregating Exceptions
Summary
Chapter 15 Generic and Anonymous Types
Using Generic Types
Defining a Generic Class
Creating Objects from Generic Classes
Implementing and Using Generic Class Members
Defining Multiple Parameter Types
Casting from Parameterized Types
Constraining Parameterized Types
Applying Multiple Constrains to a Parameterized Type
Constraining Multiple Parameterized Types
Defining a Method-Specific Parameterized Type
Deriving from a Generic Base Class
Inheriting Type Deferral
Specifying Parameterized Types
Creating Generic Interfaces
Creating Generic Structs
Type Variance
Covariance
Contravariance
Combining Contravariance and Covariance
Using the default Keyword
Using Anonymous Types
Summary
Chapter 16 Strings and Characters
Working with Characters
Expressing Characters Using Literals
Performing Operations on Characters
Using Struct Members
Using Strings
Expressing Strings Using String Literals
Using String Escape Sequences and Verbatim Literals
Performing Operations on Strings
Comparing Strings
Combining Strings
Reading Individual Characters
Enumerating a String
Using Strings in a switch Statement
Using Regular Expressions
Using Class Members
Manipulating Strings
Searching Strings
Other Class Members
Using the StringBuilder Class
Creating a StringBuilder Object
Using a StringBuilder Object
Using the Append and Insert Methods
Using the StringBuilder Indexer
Formatting Strings
Using Composite Formatting
Other Composite Formatting Methods
Specifying Alignment
Escaping Braces
Formatting Types
Using a Format Component
Creating String Representations of Custom Types
Performing Custom Composite Formatting
Summary
Chapter 17 Attributes
Using Attributes
Applying Attributes with Parameters
Testing for an Attribute
Testing for an Attribute Applied to a Class
Testing for an Attribute Applied to a Field
Testing for an Attribute Applied to a Property
Testing for an Attribute Applied to a Method
Creating a Custom Attribute
Using a Custom Attribute
Defining Properties in a Custom Attribute
Controlling How a Custom Attribute Can Be Used
Controlling Attribute Inheritance
Summary
Chapter 18 Garbage Collection
Explicitly Running the Garbage Collector
Implementing a Destructor
Destructors vs. Finalizers
Problems with Destructors
Performance Impact
Uncertain Execution
Uncertain Ordering
Using Disposal
Using Weak References
Summary
PART 3 The .NET Class Library
Chapter 19 Collections
The ICollection Interface
Generic Lists
The IList Interface
The List Collection
Adding, Retrieving, and Removing Items
Finding List Items
Sorting List Items
Processing Items
Other List Members
The LinkedList Collection
Adding, Retrieving, and Removing Items
Finding List Items
The SortedList Collection
Adding, Retrieving, and Removing Items
Other SortedList Members
Generic Dictionaries
The IDictionary Interface
The KeyValuePair Structure
The Dictionary Collection
Adding, Retrieving, and Removing Items
Other Dictionary Members
The SortedDictionary Collection
Generic Sets
The ISet Interface
The HashSet Collection
The SortedSet Collection
Generic Queues and Stacks
The Queue Collection
The Stack Collection
Other Generic Collection Interfaces
The IComparer Interface
The IEqualityComparer Interface
Treating Arrays as Collections
Creating Constrained Collections
Read-Only Lists
Other Read-Only Collections
Legacy Collections
Summary
Chapter 20 Files, Streams, and IO
Working with Files and Directories
Using the System.IO.Directory Class
Enumerating Files and Directories
Getting and Setting Information for a File or Directory
Changing the Current Working Directory
Using the FileInfo and DirectoryInfo Classes
Using the FileInfo Class
Using the DirectoryInfo Class
Using the System.IO.File Class
Using the File Convenience Methods
Using the Stream, Reader, and Writer Methods
Using the System.IO.Path Class
Monitoring for Changes
Filtering the Monitored Files and Directories
Filtering the Triggers for a Change Event
Working with Streams, Readers, and Writers
Using Streams
Using the System.IO.Stream Class (in Detail)
Using Base Streams
Using Pass-Through Streams
Using Readers and Writers
Reading and Writing Binary Data
Reading and Writing Textual Data
Summary
Chapter 21 Networking & WCF
Requesting Data
Using WebClient Members to Configure a Request
Using WebClient Members to Retrieve Data
Getting the WebClient Response Headers
Using WebClient Events
Programming with Sockets
Creating a Simple TCP Client & Server
Creating the Server
Creating the Client
Writing a Parallel Server
The Windows Communication Foundation
Creating the WCF Server
Creating the Service Contract
Creating the WCF Client
Other Useful Network Classes
Writing a Simple Web Server
Using Connectionless Networking
Using the Domain Name System
Summary
Chapter 22 Time & Dates
Measuring Small Amounts of Time
Working with Periods of Time
Creating and Using TimeSpan Values
Performing Operations on TimeSpan Values
Formatting TimeSpan Strings
Creating Custom TimeSpan Format Strings
Working with Particular Dates and Times
Creating and Using DateTime Values
Performing Operations on DateTime Values
Formatting DateTime Strings
Creating Custom DateTime Format Strings
Summary
Chapter 23 Serialization
Using Binary Serialization
Serializing Graphs of Objects
Serializing Multiple Objects to a Single Stream
Selectively Serializing Fields
Using Serialization Callbacks
Version Tolerance
Adding Tolerance for Specific Changes
Using SOAP Serialization
Version Tolerance
Serializing Generic Objects
Using XML Serialization
Selectively Serializing Fields
Mapping Members to Elements and Attributes
Changing the Name for Attributes and Elements
Using Data Contract Serialization
Preparing a Class for Data Contract Serialization
Generating Portable XML
Generating .NET-specific XML
Generating JSON
Summary
Chapter 24 Serialization
Understanding Single- and Multi-Threaded Execution
Getting Started with Tasks
Creating a Task
Starting a Task
Waiting for a Task
Getting Results from Tasks
Passing Parameters to a Task
Getting the Status of a Task
Using the Status Properties
Canceling Tasks
Checking and Throwing in a Single Statement
Cancelling Multiple Tasks
Handling Task Exceptions
Handling an Exception in a Task Body
Handling an Exception from a Trigger Method
Handling Exceptions from Multiple Tasks
Dealing with Exceptions using Task Properties
Using a Custom Exception Escalation Policy
Chaining Tasks Together
Creating a Simple Continuation
Getting Details of the Antecedent
Providing a Continuation Result
Creating Chains of Continuations
Creating Selective Continuations
Sharing Data between Tasks
Understanding a Critical Region
Creating a Critical Region
Avoiding Synchronization
Using Concurrent Collections
Summary
Chapter 25 Asynchronous Methods and Parallel Loops
Using Asynchronous Methods
Using Pre-Built Asynchronous Methods
Asynchronously Calling Any Method
Waiting for an Asynchronous Method to Complete
Mixing Asynchronous Methods and Tasks
Using Parallel Loops
Creating a Parallel ForEach Loop
Creating a Parallel For Loop
Breaking and Stopping Parallel Loops
Summary
Chapter 26 Other Useful Features and Classes
Converting Between Types
Returning Multiple Results from Methods Using Tuples
Aliasing Generic Types
Using Nullable Types
Using the Null-Coalescing Operator
Working with the Console
Reading from and Writing to the Console
Making the Console Beep
Modifying the Appearance of the Console
Generating Random Numbers
Converting Strings to and from Bytes
Getting Environment Information
Performing Math Operations
Using Conditional Compilation
Using Visual Studio to Define Symbols
Conditionally Compiling Methods
Checking Network Connectivity
Listening for Connectivity Changes
Summary
PART 4 Data and Databases
Chapter 27 LINQ to Objects
Performing a Simple LINQ Query
Understanding LINQ to Objects Data Sources
Enumerating Results Manually
Using Results as Data Sources
Understanding Query Results
The Range Variable Type
The Result Type
Explicitly Specifying the Range Variable Type
Letting the Compiler Infer Types
Performing LINQ Operations
Filtering Data
Projecting Data
Projecting a Single Member
Projecting Anonymous Types
Projecting Derived Data
Ordering Data
Grouping Data
Grouping Using a Boolean Value
Grouping Using an Anonymous Type
Querying Grouped Data
Using Method Syntax
Understanding Deferred Execution
Reusing Queries
Referring to Variables
Forcing Immediate Execution
Converting Query Results
Using Legacy Collections as LINQ Data Sources
Explicitly Specifying the Range Variable Type
Using Cast and OfType Extension Methods
Performing Advanced LINQ Operations
Aggregating Data
Joining Data
Creating Combinations of Data
Creating Additional Range Variables
Summary
Chapter 28 Parallel LINQ
Performing a Parallel LINQ Query
Understanding PLINQ Result Ordering
Preserving Order in a PLINQ query
Forcing Parallel Execution
Performing Queries without Results
Summary
Chapter 29 LINQ to XML
Using the LINQ XML Classes
Creating XML Declaratively
Using Arbitrary Types to Create XElements
Creating Other XML Node Types
Creating Valid XML Documents
Populating an XElement or XDocument with an IEnumerable
Reading and Writing XML Files
Saving XML
Loading XML
Processing XML Declaratively
Filtering Elements by Name
Finding All Descendants
Modifying XML
Using LINQ to XML Queries
Querying XML for Data
Creating XML from LINQ Queries
Create Objects from XML
Modifying and Transforming XML Data
Adding Elements to XML
Creating a CSV File from XML
Creating XML from CSV Data
Changing and Deleting Elements
Sorting XML
Grouping XML
Using Parallel LINQ to Process XML
Summary
Chapter 30 LINQ to Entities
Getting Ready
Preparing the Database
Creating the Model
Using LINQ to Entities
Using the Data Model Context
Using Table Properties and Row Objects
Understanding the IQueryable Interface
Enumerating the Results
Navigating Using Foreign Key Relationships
Querying Using Navigation Properties
Using Navigation Data Efficiently
Performing Common Database Operations
Querying Data
Compiling Queries
Querying Views
Querying Stored Procedures
Inserting Data into the Database
Inserting Attached Objects
Updating Data in the Database
Deleting Data
Enabling Concurrency Checking
Summary
Chapter 31 LINQ to DataSet
Connecting to and Querying a Database
Setting Up the Database
Creating a Connection to the Database
Storing Connection Strings
Executing a SQL Query
Understanding the DataSet Class
Enumerating Results with DataTable and DataRow Objects
Querying DataSets with LINQ
Perform Joins on a DataSet
Comparing Data
Querying for Data Intersects
Subtracting Results
Performing Database Operations Using Cached Data
Inserting Data
Modifying Data
Deleting Data
Summary
PART 5 User Interfaces
Chapter 32 Windows Forms
Building a Stand-Alone Window Forms Program
Creating the Project
Adding the Controls
Setting the Control Properties
Configuring the Labels
Configuring the TextBoxes and NumericUpDowns
Configuring the Button
Adding the MenuStrip and StatusStrip
Setting the Control Names
Setting the Tab Order
Wiring the Controls
Wiring the Quit Menu
Wiring the TextBoxes
Wiring the Button
Setting the Icon
Testing the Program
Using Windows Forms Data Binding
Creating the Project and Creating the Data Model
Creating and Using the Object Data Source
Formatting the Grid Control
Loading the Data
Wiring the Save Button
Testing the Program
Two Program Variations
Filtering the Data with LINQ
Displaying Data Fields
Windows 7 UI Integration
Using Aero Glass
Summary
Chapter 33 Windows Presentation Foundation
Building a Stand-Alone WPF Program
Creating the Project
Adding the Controls
Setting the Control Properties
Configuring the Label Controls
Configuring the TextBox Controls
Configuring the TextBlock Control
Configuring the Button
Adding the StatusBar Item
Adding the StatusBar Item
Adding the Menu Item
Setting the Tab Order
Wiring the Controls
Wiring the Quit Menu
Wiring the TextBox Controls
Wiring the Button
Managing the Focus
Focusing on the First Control
Selecting the TextBox Text on Focus
Setting the Program Icon and Window Name
Testing the Program
Using WPF Data Binding
Formatting the DataGrid Control
Loading the Data
Wiring the Button
Testing the Program
Using WPF-Specific Features
Using WPF Animations
Creating the Project
Adding the Animation
Testing the Animation
Combining Multiple Animations
Using WPF Commands
Creating the Project
Configuring the Button Controls
Adding and Configuring the MenuItem Control
Binding the Command
Selectively Activating the Command
Using Commands to Set Control Content
Summary
Chapter 34 ASP.NET
Building a Web Forms Program
Creating the Project
Adding the Controls
Setting the Control Properties
Configuring the Labels
Configuring the TextBox Controls
Configuring the Button
Setting the Tab Order
Wiring the Button Control
Setting the Focus
Testing the Program
Using Web Forms Data Binding
Create the Project and the Entity Data Model
Adding the Web Form
Creating the Web Forms Data Source
Adding the GridView Control
Testing the Program
Using ASP.NET Dynamic Data
Creating the Project
Creating the Entity Data Model
Registering the Data Model
Testing the Program
Customizing a Dynamic Data Application
Changing the Name of a Table
Changing the Name and Visibility of a Column
Selecting Tables to Be Displayed
Customizing the Display Template
Summary
Chapter 35 Silverlight
Creating the Swimming Calculator
Creating the Project
Defining the Layout
Adding Grid Columns
Adding the StackPanel Controls
Adding the TextBox Controls
Adding the Label Controls
Adding the TextBlock Control
Adding the Button Control
Adjusting the Layout
Wiring the Button
Adding a Child Window
Using a WCF RIA Service
Creating the Project
Creating the Data Model
Creating the Domain Service Class
Creating the Silverlight Client
Adding the Data
Configuring the DataGrid Control
Configuring the ComboBox Control
Wiring the ComboBox Control
Testing the Application
Using Silverlight Out-of-Browser Support
Configuring the Out-of-Browser Support
Using a Silverlight Program Out-of-Browser
Making Installation Part of the Interface
Using Other Out-of-Browser Features
Summary
PART 6 Advanced Topics
Chapter 36 Windows Integration
Using the Windows Event Log
Reading an Event Log
Writing to an Event Log
Creating the Event Source
Writing Events
Using Elevated Privileges
Creating a Windows Service
Creating the Service Class
Adding the Service Functionality
Adding the Service Installer
Add the MSI Installer
Installing the Service
Creating the Client
Using the Windows Registry
Searching the Registry
Reading and Modifying the Registry
Summary
Chapter 37 Cryptography and Security
Encrypting and Decrypting Data
Creating and Using Encryption Keys
Encrypting Data
Decrypting Data
Using the Windows Data Protection API
Using Hash Codes
Generating a Hash Code
Verifying a Hash Code
Generating Secure Random Numbers
Working Securely with Strings
Summary
Chapter 38 Testing and Debugging
Using the Debug and Trace Classes
Using the Debug Class
Making Assertions
Disabling Debug Statements
Using Debug Listeners
Other Debug Methods
Using the Trace Class
Using Static Code Analysis
Selecting the Code Analysis Rules
Performing Static Analysis
Dealing with a Rule Violation
Suppressing a Single Occurrence
Suppressing Every Occurrence
Using Code Contracts
People also search for Introducing Visual C# 2010 1st:
microsoft visual c# 2017 an introduction to object-oriented programming pdf
microsoft visual c# 2017 an introduction to object-oriented programming
microsoft visual c# an introduction to object-oriented programming pdf
microsoft visual c# an introduction to object-oriented programming
visual studio c# 2010
You may also like…
