Data Binding with Windows Forms 2.0
Addison-Wesley Educational Publishers Inc (Verlag)
978-0-321-26892-1 (ISBN)
- Keine Verlagsinformationen verfügbar
- Artikel merken
“Brian Noyes’ writing style easily captures your attention as he elaborates on all aspects of data binding in his book. He has a refreshingly clear and crisp delivery as he starts each chapter with a simple tour of each topic, and then leads you into practical concerns for sound practices and extensibility opportunities. Most importantly, as Brian explains approaches to data-binding architecture, patterns of usage, the value of data sets, binding controls and the rest, he always describes how he reaches his recommendations on the topic. This book is perfect for newcomers to .NET 2.0, but also for those that have some experience. Anyone who cares about data in their applications (okay, that should be almost everyone) is guaranteed to learn something new and useful by reading Brian’s book.”
—Michele Leroux Bustamante, IDesign chief architect, Microsoft regional director, and MVP “Brian has saved me a lot of time. I’m writing The Hitchhiker’s Guide to Visual Studio and SQL Server 2005 (7th Edition) and I’m not going to have to cover data binding nearly as deeply because Brian has done it for me. His book gets right to the meat of the subject and makes data binding look easy. I was also pleased to see that the book focuses on the misunderstood and under-applied Windows Forms architecture. It’s a must-read for anyone trying to make their application more interactive and to leverage the new Visual Studio 2005 technology. I’m planning to point my readers to this resource when they need an in-depth treatment of data binding.”
—William Vaughn, president, Beta V Corporation “Data binding has finally come of age in Windows applications. Back in the Visual Studio 6.0 days, I ignored data binding completely and wrote my own repetitive code to encapsulate my business logic. With Visual Studio 2005, we finally have a robust and compelling data-binding technology. To ignore it today would make you inefficient and put you behind the curve. Brian delivers a clear and concise discussion of a core topic of development for Windows today. A combination of an easy-to-follow conversational yet technical tone, excellent examples, and solid explanations make this a must-read for any developer writing for Windows or learning to write for Windows.”
—Stephen Forte, chief technical officer, Corzen Inc. “This book provides a clear, readable, and in-depth treatment of data binding, with detailed discussions of best practices in the presentation and use of data. Brian communicates his knowledge on the mechanics of data binding to give the low-level understanding that makes all the difference when building sophisticated applications and troubleshooting difficult problems. Effective data binding can enormously reduce the amount of code in your applications and will allow new levels of sophistication in your development. Read this book.”
—Jonathan Cogley, chief executive officer, Thycotic, ASPInsider, and C# MVP “The .NET Framework 2.0, Visual Studio .NET 2005, and Windows Forms 2.0 incorporate the most powerful data-binding platform yet, and absolutely need a book like this to expose it. Brian’s extensive data-binding knowledge and experience shine through as he comprehensively explores its many facets, starting with the fundamentals before tackling a wide variety of real-world scenarios. I’ve always thought a data-binding book was necessary, and I’m glad Brian found the time to write his.”
—Michael Weinhardt, freelance author and application developer “ Data Binding with Windows Forms 2.0 earns a gold star and a prized place in my development book library. Brian is an exceptional teacher of technology, best practices, and technique. He continues to educate at every presentation I attend; his book carries that quality to paper. I found this book to be highly informative and full of all the important steps and examples necessary to learn this technology. In this book, Brian demonstrates a firm grasp on the concepts and I really enjoy his efforts to promote best practices at every chance. Definitively a cover-to-cover read.”
—Randy Hayes, president, Expert Network Solutions, Inc. “Brian’s direct and well-organized presentation makes this much misunderstood topic finally understandable.”
—Sahil Malik, author of Pro ADO.NET 2.0 and C# MVP Data binding is the most important part of many business applications—and one of the most difficult things to understand. Data Binding with Windows Forms 2.0 is the first book to focus on this crucial area of development. It will quickly get you up to speed on binding data sources to Windows Forms components. The book contains clear examples in C# that work with SQL Server 2000 and SQL Server 2005. Visual Basic .NET examples are available on the book’s Web site.
Brian Noyes, leading consultant and speaker on .NET programming, teaches you both the theory and practice of data binding and provides numerous samples ready to run in Visual Studio 2005.
From his in-depth coverage, you’ll learn how to
Use Visual Studio 2005 to generate a data-bound application from a database
Use the new Visual Studio 2005 typed data set designer, and how and why to use typed data sets and typed data adapters
Perform simple and complex binding of data to controls, and how to use the .NET 2.0 BindingSource
Use the Binding object for simple binding with automatic formatting, and how to handle binding events
Generate bound controls with the Visual Studio Designer, and how to use Data Sources
Present data with the new DataGridView control, and how to implement advanced features of the DataGridView
Implement custom data-bound controls in Windows Forms
Create custom business objects and collections that are suitable for use in data binding
Implement validation and error handling at the Windows Forms and data-binding levels
Implement data binding with ASP.NET 2.0 and the upcoming Windows Presentation Foundation (Avalon) technologies
Brian Noyes is a software architect, trainer, writer, and speaker with IDesign (www.idesign.net), a premier .NET architecture and design consulting and training company. He has been developing software systems for more than fifteen years, speaks at many major software conferences around the world, and writes for a variety of software journals and magazines.
Foreword xxi Preface xxiii Acknowledgments xxxv About the Author xxxvii Chapter 1: Building Data-Bound Applications with Windows Forms 1 What Is Data Binding? 2
Your First Data-Bound Windows Forms 2.0 Application 3
Data-Binding Landscape 14
Data Sources 15
Data Objects and Collections 16
DataSets or Not, That Is the Question... 18
Data-Bound Controls 20
Layered Application Architecture 21
What Is a Smart Client? 27
Where Are We? 28
Chapter 2: Working with Typed Data Sets and Table Adapters 31 A Quick Review of DataSets 31
The Quest for Type Safety 34
Typed Data Set Internals 37
Creating Typed Data Sets 41
Creating Typed Data Sets with the Data Set Designer 42
Typed Data Set-Generated Code 49
Introduction to Table Adapters 52
Filling and Updating a Typed Data Set with a Table Adapter 56
Connection Management 58
Adding Transaction Support to a Table Adapter 62
Adding Helper Data Access Methods 66
Basing Table Adapters on Stored Procedures or Views 67
Adding Queries to Table Adapters 69
Creating Typed Data Sets with Command Line Tools 77
Using Typed Data Sets in Your Code 78
Where Are We? 79
Chapter 3: Introducing Data Binding in Windows Forms 81 The 40,000-Foot View of Data Binding 81
Binding Data Collections to a Grid 86
Binding Data Collections to Multi-Valued Controls 88
Binding Data to Individual Controls on a Form 90
Data Paths Within Data Sources 92
Synchronizing Data Between Controls 96
Smarter Data Containment 97
Paging Through Data 99
Master-Details Data Binding 104
Updating Data Sources Through Data Binding 106
Where Are We? 108
Chapter 4: Binding Controls to Data Sources 111 Getting to Know the BindingSource Component 111
Simple Data Binding with Binding Sources 112
Chaining Binding Sources for Master-Details Data Binding 116
Navigating Data Through a Binding Source 121
Manipulating Data Through a Binding Source 122
Using a Binding Source as a Data Storage Container 124
Filling a Binding Source with a Data Reader 126
Sorting, Searching, and Filtering Presented Data with a Binding Source 128
Monitoring the Data with Events 131
Restricting Changes to the Data 133
Underneath the Covers of Data Binding for Complex Types 134
Binding an Image Column to a PictureBox Control 141
Binding a DateTime Column to a DateTimePicker 142
Binding a DateTime Column to a TextBox 144
Binding a Numeric Column to a TextBox 145
Automatic Formatting and Parsing Summary 147
Going Beyond Built-In Type Conversion with Binding Events 148
Handling the Format Event 154
Handling the Parse Event 156
Completing the Editing Process 157
Making the User’s Life Easier with AutoComplete 160
Data Binding Lifecycle 162
Smarter Child-Parent Data Binding 163
Binding to Multiple Copies of Data 165
Updating Parent Data-Bound Controls from Child Data-Bound Controls 168
Synchronizing Many-to-Many Related Collections 172
Where Are We? 176
Chapter 5: Generating Bound Controls with the Visual Studio Designer 177 Working with the Data Sources Window 177
Adding Data Sources to a Project 179
Choosing the Type of Data Source 180
Adding a Database Data Source 181
Adding a Web Service Data Source 185
Adding an Object Data Source 186
Generating Bound Controls from Data Sources 189
Selecting the Bound Control Type 196
Customizing the Bound Control Types 196
Binding Existing Controls to Data Sources 199
Behind the Scenes: Designer Code and Data Sources Files 202
Other Designer Data-Binding Code Generation 205
Setting Control Data Binding Through the Properties Window 206
Generating Data Bindings with Smart Tags 210
Generating Master-Details Data-Bound Controls with the Designer 214
Where Are We? 216
Chapter 6: Presenting Data with the DataGridView Control 217 DataGridView Overview 218
Basic Data Binding with the DataGridView 219
Controlling Modifications to Data in the Grid 221
Programmatic DataGridView Construction 222
Custom Column Content with Unbound Columns 226
Displaying Computed Data in Virtual Mode 233
Using the Built-In Column Types 241
Built-In Header Cells 255
Handling Grid Data Edits 256
Automatic Column Sizing 259
Column and Row Freezing 262
Using the Designer to Define Grids 263
Column Reordering 266
Defining Custom Column and Cell Types 269
Utilizing Cell-Oriented Grid Features 277
Formatting with Styles 281
Where Are We? 284
Chapter 7: Understanding Data-Binding Interfaces 285 What Does Data Binding Have to Do with Interfaces? 286
The IEnumerable and IEnumerator Interfaces: Supporting Iteration Through Collections 289
The ICollection Interface: Controlling Access to a Collection 295
The IList Interface: Enabling Data Binding 298
The IListSource Interface: Exposing Collections of Collections 303
Property Descriptors: Allowing Dynamic Data Item Information Discovery 305
The ITypedList Interface: Exposing Data-Binding Properties 307
The IBindingList Interface: Providing Rich Binding Support 310
The IBindingListView Interface: Supporting Advanced Sorting and Filtering 323
The ICancelAddNew Interface: Supporting Transactional Inserts in a Collection 325
The IRaiseItemChangedEvents Interface: Providing Item Modification Notifications on Collections 327
The IEditableObject Interface: Supporting Transactional Item Modifications 328
The INotifyPropertyChanged Interface: Publishing Item Change Notifications 329
The ICustomTypeDescriptor Interface: Exposing Custom Type Information 332
The ISupportInitialize Interface: Supporting Designer Initialization 334
The IDataErrorInfo Interface: Providing Error Information 330
The ISupportInitializeNotification Interface: Supporting Interdependent Component Initialization 337
The ICurrencyManagerProvider Interface: Exposing a Data Container’s CurrencyManager 341
Where Are We? 341
Chapter 8: Implementing Custom Data-Bound Controls 343 Extending Framework Data-Bound Controls 344
Creating a Grouped Column DataGridView 345
Using Custom Controls 350
The User Control Test Container 352
Developing Data-Bound Container Controls 353
Building a Filtered Grid Control 354
Adding Data-Binding Capability to a Custom Control 357
Supporting Designer Initialization of Data Binding 359
Specifying Binding Properties on a Control 360
Supporting Delayed Initialization with ISupportInitialize 362
Dynamically Determining the Properties of a Data Source 367
Autocompleting Input in a TextBox Control 371
Autosizing Columns in the Grid 375
Winding Up the Filtered Grid Example 376
Building a Custom Data-Bound Control from Scratch 379
Building a Data-Bound Charting Control for Decision Support 379
Coding a Data-Bound Custom Control 384
Adding Editing Support to a Custom Data Bound Control 391
Where Are We? 397
Chapter 9: Implementing Custom Data-Bound Business Objects and Collections 399 Defining and Working with Data-Bound Business Objects 400
Defining and Working with Data-Bound Business Object Collections 405
.NET Framework Generic Collection Classes 406
The CustomBusinessObjects Example 408
Setting the Textual Data-Binding Behavior of Custom Objects 415
Supporting Transacted Object Editing with IEditableObject 416
Supporting Object Edit Notifications with Property Change Events 420
Supporting Object Edit Notifications with INotifyPropertyChanged 423
Using BindingList to Create Rich Object Collections 424
Creating a Custom Collection Type Based on BindingList 426
Managing Transacted Additions to a Collection 439
Raising Item Changed Events 441
Adding IBindingListView Functionality 443
Binding to Business Objects Through the Data Sources Window 453
Where Are We? 455
Chapter 10: Validating Data Input and Handling Errors 457 Windows Forms Validation 458
Handling Validation Events 459
DataGridView Validation Events 462
Validation Up the Control Hierarchy 463
Displaying Validation Errors with the ErrorProvider Control 464
DataGridView Error Displays 467
DataGridView DataError Event 468
Controlling Validation Behavior with the AutoValidate Property 471
Validation down the Control Hierarchy 472
Extended Validation Controls 474
Capturing Data Errors on Data Sets 475
Providing Error Information from Custom Objects with IDataErrorInfo 479
Data Concurrency Resolution 483
Where Are We? 484
Appendix A: Binding to Data in ASP.NET 487 ASP.NET Page Processing Basics 489
Data Binding in ASP.NET 1.X 490
Data-Binding Overview in ASP.NET 2.0 498
Data Sources 499
Data-Binding Expressions 508
GridView Control 509
DetailsView Control 512
FormView Control 514
Master-Details Binding 515
Hierarchical Binding 518
Where Are We? 519
Appendix B: Binding Data in WinFx Applications 521 WinFx UI Programming and Capabilities Overview 522
Writing a Simple WinFx Application 525
WinFx Data Binding 101 532
Data Contexts and Data Sources 536
What About XAML? 537
Binding a Collection to a Grid with Templates 541
Control Styling in WinFx 543
Where Are We? 545
Appendix C: Programming Windows Forms Applications 547 Your First Windows Forms Data Application 548
Creating Windows Forms Applications with Visual Studio 554
Windows Forms Designer-Generated Code (New in 2.0) 563
A Brief Tour of the Windows Forms Architecture 567
The Dawn of .NET Execution—The Main Method 570
Handling Control Events 574
Displaying Other Forms 576
Containing Forms Within a Parent Form 577
Common Data Display Controls 578
Creating a Custom User Control 586
Laying Out Controls on a Form 589
Setting Tab Order 596
Command and Control of Your Windows Forms Applications (New in 2.0) 598
Where Are We? 600
Appendix D: Accessing Data with ADO.NET 601 Relational Data Access 603
The Ubiquitous DataSet 607
Loading Data Sets from a File 609
Creating a Data Set Programmatically 611
Loading Data Sets from a Database 613
Loading a DataTable with a DataReader 619
Master-Details DataSets 621
Retrieving Data with Stored Procedures 623
Updating the Database Using Data Sets 624
Handling Concurrency 628
Updating with Data Sets and Stored Procedures 632
Searching Data Sets 637
Merging Data from Multiple Data Sets 639
Working with Data Views 641
Working with Transactions 643
Scoping Transactions with System.Transactions 647
Client-Side Transactions 650
Data Set and Data Adapter Events 651
Reading Data into Business Objects 654
XML Data Access 658
Working with the XmlDataDocument Class 659
Working with the XPathDocument Class 663
Loading Data into an XPathDocument 664
Querying XML Data 665
Navigating an XML Document 667
Where Are We? 670
Index 671
| Erscheint lt. Verlag | 26.1.2006 |
|---|---|
| Reihe/Serie | Microsoft Windows Development Series |
| Verlagsort | New Jersey |
| Sprache | englisch |
| Maße | 177 x 236 mm |
| Gewicht | 1020 g |
| Themenwelt | Mathematik / Informatik ► Informatik ► Netzwerke |
| Informatik ► Programmiersprachen / -werkzeuge ► NET Programmierung | |
| ISBN-10 | 0-321-26892-X / 032126892X |
| ISBN-13 | 978-0-321-26892-1 / 9780321268921 |
| Zustand | Neuware |
| Haben Sie eine Frage zum Produkt? |
aus dem Bereich
