|
|
|
|
| LEADER |
10375nmm a2200517 u 4500 |
| 001 |
EB001935144 |
| 003 |
EBX01000000000000001098046 |
| 005 |
00000000000000.0 |
| 007 |
cr||||||||||||||||||||| |
| 008 |
210123 ||| eng |
| 020 |
|
|
|a 073563470X
|
| 020 |
|
|
|a 9780735624306
|
| 020 |
|
|
|a 0735635005
|
| 020 |
|
|
|a 9780735634701
|
| 020 |
|
|
|a 0735624305
|
| 050 |
|
4 |
|a QA76.73.C154
|
| 100 |
1 |
|
|a Sharp, John
|
| 245 |
0 |
0 |
|a Microsoft Visual C♯ 2008 step by step
|c John Sharp
|
| 246 |
3 |
1 |
|a Visual C♯ 2008
|
| 260 |
|
|
|a Redmond, Wash.
|b Microsoft Press
|c 2008
|
| 300 |
|
|
|a xxviii, 666 pages
|b illustrations
|
| 505 |
0 |
|
|a Handling Conflicting Updates -- Adding and Deleting Data -- Quick Reference -- VI. Building Web Applications -- Managing State -- Understanding ASP.NET -- Creating Web Applications with ASP.NET -- Understanding Server Controls -- Creating and Using a Theme -- Applying a Theme -- Quick Reference -- 28. Understanding Web Forms Validation Controls -- Validating Data in the Web Browser -- Implementing Client Validation -- Quick Reference -- 29. Protecting a Web Site and Accessing Data with Web Forms -- Implementing Forms-Based Security -- Querying and Displaying Data -- Displaying Customer and Order History Information -- Paging Data -- Editing Data -- Navigating Between Forms -- Quick Reference -- 30. Creating and Using a Web Service -- What Is the Web Services Description Language? -- Nonfunctional Requirements of Web Services -- The Role of Windows Communication Foundation -- Building a Web Service -- Web Services, Clients, and Proxies -- Talking SOAP: The Easy Way -- Consuming the ProductsService Web Service -- Quick Reference
|
| 505 |
0 |
|
|a Writing Checked Expressions -- Throwing Exceptions -- Using a finally Block -- Quick Reference -- II. Understanding the C# Language -- The Purpose of Encapsulation -- Defining and Using a Class -- Controlling Accessibility -- Working with Constructors -- Understanding static Methods and Data -- Creating a static Field by Using the const Keyword -- Quick Reference -- 8. Understanding Values and References -- Understanding Null Values and Nullable Types -- Understanding the Properties of Nullable Types -- Using ref and out Parameters -- Creating out Parameters -- How Computer Memory Is Organized -- The System.Object Class -- Boxing -- Unboxing -- Casting Data Safely -- The as Operator -- Quick Reference -- 9. Creating Value Types with Enumerations and Structures -- Using an Enumeration -- Choosing Enumeration Literal Values -- Choosing an Enumerationamp -- s Underlying Type -- Working with Structures -- Understanding Structure and Class Differences -- Declaring Structure Variables -- Understanding Structure Initialization -- Copying Structure Variables -- Quick Reference -- 10. Using Arrays and Collections -- Creating an Array Instance -- Initializing Array Variables -- Accessing an Individual Array Element -- Iterating Through an Array -- Copying Arrays -- What Are Collection Classes? -- The Queue Collection Class -- The Stack Collection Class -- The Hashtable Collection Class -- The SortedList Collection Class -- Comparing Arrays and Collections -- Using Collection Classes to Play Cards -- Quick Reference -- 11. Understanding Parameter Arrays -- Using params object[ ] -- Using a params Array -- Quick Reference -- 12. Working with Inheritance -- Using Inheritance -- Calling Base Class Constructors -- Assigning Classes -- Declaring new Methods -- Declaring Virtual Methods -- Declaring override Methods -- Understanding protected Access
|
| 505 |
0 |
|
|a Understanding Extension Methods -- Quick Reference -- 13. Creating Interfaces and Defining Abstract Classes -- Interface Restrictions -- Referencing a Class Through Its Interface -- Working with Multiple Interfaces -- Abstract Classes -- Sealed Classes -- Implementing an Extensible Framework -- Summarizing Keyword Combinations -- Quick Reference -- 14. Using Garbage Collection and Resource Management -- Why Use the Garbage Collector? -- How Does the Garbage Collector Work? -- Recommendations -- Resource Management -- Exception-Safe Disposal -- The using Statement -- Calling the Dispose Method from a Destructor -- Making Code Exception-Safe -- Quick Reference -- III. Creating Components -- What Are Properties? -- Read-Only Properties -- Write-Only Properties -- Property Accessibility -- Understanding the Property Restrictions -- Declaring Interface Properties -- Generating Automatic Properties -- Initializing Objects by Using Properties -- Quick Reference -- 16. Using Indexers -- The Bitwise and Shift Operators -- The Same Example Using Indexers -- Understanding Indexer Accessors -- Comparing Indexers and Arrays -- Indexers in Interfaces -- Using Indexers in a Windows Application -- Quick Reference -- 17. Interrupting Program Flow and Handling Events -- Implementing the Factory Without Using Delegates -- Implementing the Factory by Using a Delegate -- Using Delegates -- Lambda Expressions and Delegates -- Using a Lambda Expression as an Adapter -- The Form of Lambda Expressions -- Enabling Notifications with Events -- Subscribing to an Event -- Unsubscribing from an Event -- Understanding WPF User Interface Events -- Quick Reference -- 18. Introducing Generics -- The Generics Solution -- Generics and Constraints -- Creating a Generic Class -- Building a Binary Tree Class by Using Generics -- Creating a Generic Method -- Quick reference
|
| 505 |
0 |
|
|a 19. Enumerating Collections -- Implementing the IEnumerable Interface -- Implementing an Enumerator by Using an Iterator -- Defining an Enumerator for the Treelt -- TItemgt -- Class by Using an Iterator -- Quick Reference -- 20. Querying In-Memory Data by Using Query Expressions -- Using LINQ in a C# Application -- Filtering Data -- Ordering, Grouping, and Aggregating Data -- Joining Data -- Using Query Operators -- Querying Data in Treelt -- TItemgt -- Objects -- LINQ and Deferred Evaluation -- Quick Reference -- 21. Operator Overloading -- Overloaded Operators -- Creating Symmetric Operators -- Understanding Compound Assignment -- Declaring Increment and Decrement Operators -- Defining Operator Pairs -- Implementing an Operator -- Understanding Conversion Operators -- Implementing User-Defined Conversion Operators -- Creating Symmetric Operators, Revisited -- Adding an Implicit Conversion Operator -- Quick Reference -- IV. Working with Windows Applications -- Adding Controls to the Form -- Changing Properties Dynamically -- Handling Events in a WPF Form -- Quick Reference -- 23. Working with Menus and Dialog Boxes -- Menus and Menu Events -- Handling Menu Events -- Shortcut Menus -- Windows Common Dialog Boxes -- Quick Reference -- 24. Performing Validation -- An Example-Customer Information Maintenance -- Changing the Point at Which Validation Occurs -- Quick Reference -- V. Managing Data -- Creating the Database -- Using ADO.NET to Query Order Information -- Querying a Database by Using DLINQ -- Creating and Running a DLINQ Query -- Deferred and Immediate Fetching -- Joining Tables and Creating Relationships -- Deferred and Immediate Fetching Revisited -- Defining a Custom DataContext Class -- Using DLINQ to Query Order Information -- Quick Reference -- 26. Displaying and Editing Data by Using Data Binding -- Using DLINQ to Modify Data
|
| 505 |
0 |
|
|a Intro -- Microsoft® Visual C#® 2008 Step by Step -- Introduction -- Finding Your Best Starting Point in This Book -- Conventions and Features in This Book -- Other Features -- System Requirements -- Code Samples -- Using the Code Samples -- Uninstalling the Code Samples -- Support for This Book -- I. Introducing Microsoft Visual C# and Microsoft Visual Studio 2008 -- Writing Your First Program -- Using Namespaces -- Creating a Graphical Application -- Quick Reference -- 2. Working with Variables, Operators, and Expressions -- Using Identifiers -- Identifying Keywords -- Using Variables -- Declaring Variables -- Working with Primitive Data Types -- Using Arithmetic Operators -- Examining Arithmetic Operators -- Controlling Precedence -- Using Associativity to Evaluate Expressions -- Associativity and the Assignment Operator -- Incrementing and Decrementing Variables -- Declaring Implicitly Typed Local Variables -- Quick Reference -- 3. Writing Methods and Applying Scope -- Writing return Statements -- Calling Methods -- Specifying the Method Call Syntax -- Applying Scope -- Defining Class Scope -- Overloading Methods -- Writing Methods -- Quick Reference -- 4. Using Decision Statements -- Using Boolean Operators -- Understanding Conditional Logical Operators -- Summarizing Operator Precedence and Associativity -- Using if Statements to Make Decisions -- Using Blocks to Group Statements -- Cascading if Statements -- Using switch Statements -- Following the switch Statement Rules -- Quick Reference -- 5. Using Compound Assignment and Iteration Statements -- Writing while Statements -- Writing for Statements -- Writing do Statements -- Quick Reference -- 6. Managing Errors and Exceptions -- Trying Code and Catching Exceptions -- Using Multiple catch Handlers -- Catching Multiple Exceptions -- Using Checked and Unchecked Integer Arithmetic
|
| 653 |
|
|
|a Programmation visuelle
|
| 653 |
|
|
|a Visual programming (Computer science) / blmlsh
|
| 653 |
|
|
|a Visual programming (Computer science) / http://id.loc.gov/authorities/subjects/sh87006583
|
| 653 |
|
|
|a C# (Langage de programmation)
|
| 653 |
|
|
|a C♯ (Computer program language) / blmlsh
|
| 653 |
|
|
|a Microsoft Visual C♯ .NET (Computer software) / sears
|
| 653 |
|
|
|a Visual programming (Computer science) / fast
|
| 653 |
|
|
|a C# (Computer program language) / fast
|
| 653 |
|
|
|a C♯ (Computer language) / sears
|
| 653 |
|
|
|a C# (Computer program language) / http://id.loc.gov/authorities/subjects/sh2001001705
|
| 653 |
|
|
|a Microsoft Visual C# .NET / fast
|
| 653 |
|
|
|a Microsoft Visual C# .NET.
|
| 740 |
0 |
2 |
|a ITPro
|
| 041 |
0 |
7 |
|a eng
|2 ISO 639-2
|
| 989 |
|
|
|b OREILLY
|a O'Reilly
|
| 490 |
0 |
|
|a --step by step
|
| 856 |
4 |
0 |
|u https://learning.oreilly.com/library/view/~/9780735634701/?ar
|x Verlag
|3 Volltext
|
| 082 |
0 |
|
|a 500
|
| 082 |
0 |
|
|a 005.13/3
|
| 520 |
|
|
|a Covers the fundamentals of Visual C♯ and how to use it to build .NET-connected applications, covering topics including syntax, Web services, and operators
|