book

Microsoft® Visual C#® 2012 Step by Step

Name: Microsoft® Visual C#® 2012 Step by Step
Author: John Sharp
ISBN: 9780735679375

by John Sharp

December 2012

Beginner to intermediate

844 pages

25h 38m

English

Microsoft Press

Read now

Unlock full access

Microsoft® Visual C#® 2012 Step by Step
Dedication
Introduction
Who Should Read This BookWho Should Not Read This BookOrganization of This BookFinding Your Best Starting Point in This BookConventions and Features in This BookSystem RequirementsCode SamplesInstalling the Code SamplesUsing the Code SamplesAcknowledgmentsErrata and Book SupportWe Want to Hear from YouStay in Touch
I. Introducing Microsoft Visual C# and Microsoft Visual Studio 2012
1. Welcome to C#
Beginning Programming with the Visual Studio 2012 EnvironmentWriting Your First ProgramUsing NamespacesCreating a Graphical ApplicationExamining the Windows Store AppExamining the WPF ApplicationAdding Code to the Graphical ApplicationSummaryChapter 1 Quick Reference
2. Working with Variables, Operators, and Expressions
Understanding StatementsUsing IdentifiersIdentifying KeywordsUsing VariablesNaming VariablesDeclaring VariablesWorking with Primitive Data TypesUnassigned Local VariablesDisplaying Primitive Data Type ValuesUsing Arithmetic OperatorsOperators and TypesExamining Arithmetic OperatorsControlling PrecedenceUsing Associativity to Evaluate ExpressionsAssociativity and the Assignment OperatorIncrementing and Decrementing VariablesPrefix and PostfixDeclaring Implicitly Typed Local VariablesSummaryChapter 2 Quick Reference
3. Writing Methods and Applying Scope
Creating MethodsDeclaring a MethodReturning Data from a MethodCalling MethodsSpecifying the Method Call SyntaxApplying ScopeDefining Local ScopeDefining Class ScopeOverloading MethodsWriting MethodsUsing Optional Parameters and Named ArgumentsDefining Optional ParametersPassing Named ArgumentsResolving Ambiguities with Optional Parameters and Named ArgumentsSummaryChapter 3 Quick Reference
4. Using Decision Statements
Declaring Boolean VariablesUsing Boolean OperatorsUnderstanding Equality and Relational OperatorsUnderstanding Conditional Logical OperatorsShort-CircuitingSummarizing Operator Precedence and AssociativityUsing if Statements to Make DecisionsUnderstanding if Statement SyntaxUsing Blocks to Group StatementsCascading if StatementsUsing switch StatementsUnderstanding switch Statement SyntaxFollowing the switch Statement RulesSummaryChapter 4 Quick Reference
5. Using Compound Assignment and Iteration Statements
Using Compound Assignment OperatorsWriting while StatementsWriting for StatementsUnderstanding for Statement ScopeWriting do StatementsSummaryChapter 5 Quick Reference
6. Managing Errors and Exceptions
Coping with ErrorsTrying Code and Catching ExceptionsUnhandled ExceptionsUsing Multiple catch HandlersCatching Multiple ExceptionsPropagating ExceptionsUsing Checked and Unchecked Integer ArithmeticWriting Checked StatementsWriting Checked ExpressionsThrowing ExceptionsUsing a finally BlockSummaryChapter 6 Quick Reference

II. Understanding the C# Object Model
7. Creating and Managing Classes and Objects
Understanding ClassificationThe Purpose of EncapsulationDefining and Using a ClassControlling AccessibilityWorking with ConstructorsOverloading ConstructorsUnderstanding static Methods and DataCreating a Shared FieldCreating a static Field by Using the const KeywordUnderstanding static ClassesAnonymous ClassesSummaryChapter 7 Quick Reference
8. Understanding Values and References
Copying Value Type Variables and ClassesUnderstanding Null Values and Nullable TypesUsing Nullable TypesUnderstanding the Properties of Nullable TypesUsing ref and out ParametersCreating ref ParametersCreating out ParametersHow Computer Memory Is OrganizedUsing the Stack and the HeapThe System.Object ClassBoxingUnboxingCasting Data SafelyThe is OperatorThe as OperatorSummaryChapter 8 Quick Reference
9. Creating Value Types with Enumerations and Structures
Working with EnumerationsDeclaring an EnumerationUsing an EnumerationChoosing Enumeration Literal ValuesChoosing an Enumeration’s Underlying TypeWorking with StructuresDeclaring a StructureUnderstanding Structure and Class DifferencesDeclaring Structure VariablesUnderstanding Structure InitializationCopying Structure VariablesSummaryChapter 9 Quick Reference
10. Using Arrays
Declaring and Creating an ArrayDeclaring Array VariablesCreating an Array InstancePopulating and Using an ArrayCreating an Implicitly Typed ArrayAccessing an Individual Array ElementIterating Through an ArrayPassing Arrays as Parameters and Return Values for a MethodCopying ArraysUsing Multidimensional ArraysCreating Jagged ArraysSummaryChapter 10 Quick Reference
11. Understanding Parameter Arrays
Overloading: A RecapUsing Array ArgumentsDeclaring a params ArrayUsing params object[ ]Using a params ArrayComparing Parameter Arrays and Optional ParametersSummaryChapter 11 Quick Reference
12. Working with Inheritance
What Is Inheritance?Using InheritanceThe System.Object Class RevisitedCalling Base Class ConstructorsAssigning ClassesDeclaring new MethodsDeclaring virtual MethodsDeclaring override MethodsUnderstanding protected AccessUnderstanding Extension MethodsSummaryChapter 12 Quick Reference
13. Creating Interfaces and Defining Abstract Classes
Understanding InterfacesDefining an InterfaceImplementing an InterfaceReferencing a Class Through Its InterfaceWorking with Multiple InterfacesExplicitly Implementing an InterfaceInterface RestrictionsDefining and Using InterfacesAbstract ClassesAbstract MethodsSealed ClassesSealed MethodsImplementing and Using an Abstract ClassSummaryChapter 13 Quick Reference
14. Using Garbage Collection and Resource Management
The Life and Times of an ObjectWriting DestructorsWhy Use the Garbage Collector?How Does the Garbage Collector Work?RecommendationsResource ManagementDisposal MethodsException-Safe DisposalThe using Statement and the IDisposable InterfaceCalling the Dispose Method from a DestructorImplementing Exception-Safe DisposalSummaryChapter 14 Quick Reference
III. Defining Extensible Types with C#
15. Implementing Properties to Access Fields
Implementing Encapsulation by Using MethodsWhat Are Properties?Using PropertiesRead-Only PropertiesWrite-Only PropertiesProperty AccessibilityUnderstanding the Property RestrictionsDeclaring Interface PropertiesReplacing Methods with PropertiesGenerating Automatic PropertiesInitializing Objects by Using PropertiesSummaryChapter 15 Quick Reference
16. Using Indexers
What Is an Indexer?An Example That Doesn’t Use IndexersThe Same Example Using IndexersUnderstanding Indexer AccessorsComparing Indexers and ArraysIndexers in InterfacesUsing Indexers in a Windows ApplicationSummaryChapter 16 Quick Reference
17. Introducing Generics
The Problem with the object TypeThe Generics SolutionGenerics vs. Generalized ClassesGenerics and ConstraintsCreating a Generic ClassThe Theory of Binary TreesBuilding a Binary Tree Class by Using GenericsCreating a Generic MethodDefining a Generic Method to Build a Binary TreeVariance and Generic InterfacesCovariant InterfacesContravariant InterfacesSummaryChapter 17 Quick Reference
18. Using Collections
What Are Collection Classes?The List<T> Collection ClassThe LinkedList<T> Collection ClassThe Queue<T> Collection ClassThe Stack<T> Collection ClassThe Dictionary<TKey, TValue> Collection ClassThe SortedList<TKey, TValue> Collection ClassThe HashSet<T> Collection ClassUsing Collection InitializersThe Find Methods, Predicates, and Lambda ExpressionsComparing Arrays and CollectionsUsing Collection Classes to Play CardsSummaryChapter 18 Quick Reference
19. Enumerating Collections
Enumerating the Elements in a CollectionManually Implementing an EnumeratorImplementing the IEnumerable InterfaceImplementing an Enumerator by Using an IteratorA Simple IteratorDefining an Enumerator for the Tree<TItem> Class by Using an IteratorSummaryChapter 19 Quick Reference
20. Decoupling Application Logic and Handling Events
Understanding DelegatesExamples of Delegates in the .NET Framework Class LibraryThe Automated Factory ScenarioImplementing the Factory Control System Without Using DelegatesImplementing the Factory by Using a DelegateDeclaring and Using DelegatesLambda Expressions and DelegatesCreating a Method AdapterThe Forms of Lambda ExpressionsEnabling Notifications with EventsDeclaring an EventSubscribing to an EventUnsubscribing from an EventRaising an EventUnderstanding User Interface EventsUsing EventsSummaryChapter 20 Quick Reference
21. Querying In-Memory Data by Using Query Expressions
What Is Language-Integrated Query?Using LINQ in a C# ApplicationSelecting DataFiltering DataOrdering, Grouping, and Aggregating DataJoining DataUsing Query OperatorsQuerying Data in Tree<TItem> ObjectsLINQ and Deferred EvaluationSummaryChapter 21 Quick Reference
22. Operator Overloading
Understanding OperatorsOperator ConstraintsOverloaded OperatorsCreating Symmetric OperatorsOperators and Language InteroperabilityUnderstanding Compound Assignment EvaluationDeclaring Increment and Decrement OperatorsComparing Operators in Structures and ClassesDefining Operator PairsImplementing OperatorsUnderstanding Conversion OperatorsProviding Built-in ConversionsImplementing User-Defined Conversion OperatorsCreating Symmetric Operators, RevisitedWriting Conversion OperatorsSummaryChapter 22 Quick Reference
IV. Building Professional Windows 8 Applications with C#
23. Improving Throughput by Using Tasks
Why Perform Multitasking by Using Parallel Processing?The Rise of the Multicore ProcessorImplementing Multitasking with the .NET FrameworkTasks, Threads, and the ThreadPoolCreating, Running, and Controlling TasksUsing the Task Class to Implement ParallelismAbstracting Tasks by Using the Parallel ClassWhen Not to Use the Parallel ClassCanceling Tasks and Handling ExceptionsThe Mechanics of Cooperative CancellationUsing Continuations with Canceled and Faulted TasksSummaryChapter 23 Quick Reference
24. Improving Response Time by Performing Asynchronous Operations
Implementing Asynchronous MethodsDefining Asynchronous Methods: The ProblemDefining Asynchronous Methods: The SolutionDefining Asynchronous Methods That Return ValuesAsynchronous Methods and the Windows Runtime APIsUsing PLINQ to Parallelize Declarative Data AccessUsing PLINQ to Improve Performance While Iterating Through a CollectionCanceling a PLINQ QuerySynchronizing Concurrent Access to DataLocking DataSynchronization Primitives for Coordinating TasksCancelling SynchronizationThe Concurrent Collection ClassesUsing a Concurrent Collection and a Lock to Implement Thread-Safe Data AccessSummaryQuick Reference
25. Implementing the User Interface for a Windows Store App
What Is a Windows Store App?Using the Blank App Template to Build a Windows Store AppImplementing a Scalable User InterfaceImplementing a Tabular Layout with a Grid ControlAdapting the Layout by Using the Visual State ManagerApplying Styles to a User InterfaceSummaryChapter 25 Quick Reference
26. Displaying and Searching for Data in a Windows Store App
Implementing the Model-View-ViewModel PatternDisplaying Data by Using Data BindingModifying Data by Using Data BindingUsing Data Binding with a ComboBox ControlCreating a ViewModelAdding Commands to a ViewModelWindows 8 ContractsImplementing the Search ContractNavigating to a Selected ItemStarting an Application from the Search CharmSummaryChapter 26 Quick Reference
27. Accessing a Remote Database in a Windows Store App
Retrieving Data from a DatabaseCreating an Entity ModelCreating and Using a Data ServiceInserting, Updating, and Deleting Data in a DatabasePerforming Insert, Update, and Delete Operations Through a WCF Data ServiceReporting Errors and Updating the User InterfaceSummaryChapter 27 Quick Reference
A. About the Author
Index
About the Author
Copyright

Content preview from Microsoft® Visual C#® 2012 Step by Step

Chapter 18. Using Collections

After completing this chapter, you will be able to

Explain the functionality provided in the different collection classes available with the .NET Framework.
Create type-safe collections.
Populate a collection with a set of data.
Manipulate and access the data items held in a collection.
Search a list-oriented collection for matching items by using a predicate.

Chapter 10, introduced you to arrays for holding sets of data. Arrays are very useful in this respect, but they have their limitations. Arrays provide only limited functionality; it is not easy to increase or reduce the size of an array, and neither is it a simple matter to sort the data held in an array, for example. Another issue is that arrays only really provide ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780735679375Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Microsoft® Visual C#® 2012 Step by Step

by John Sharp

Chapter 18. Using Collections

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.