Download PDF Data Binding with Windows Forms 2.0: Programming Smart Client Data Applications with .NET, by Brian Noyes
The Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes has the tendency to be fantastic reading book that is understandable. This is why this book Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes ends up being a preferred book to review. Why do not you really want turned into one of them? You can appreciate reviewing Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes while doing other tasks. The existence of the soft data of this book Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes is kind of obtaining experience effortlessly. It consists of just how you must save the book Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes, not in shelves of course. You could save it in your computer tool as well as gadget.
Data Binding with Windows Forms 2.0: Programming Smart Client Data Applications with .NET, by Brian Noyes
Download PDF Data Binding with Windows Forms 2.0: Programming Smart Client Data Applications with .NET, by Brian Noyes
Utilize the sophisticated innovation that human creates today to find guide Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes quickly. However initially, we will certainly ask you, how much do you enjoy to check out a book Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes Does it constantly till coating? For what does that book review? Well, if you actually like reading, attempt to check out the Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes as one of your reading collection. If you only reviewed guide based on demand at the time and incomplete, you need to attempt to such as reading Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes first.
Maintain your method to be right here as well as read this resource completed. You could take pleasure in browsing the book Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes that you really describe obtain. Here, getting the soft data of the book Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes can be done quickly by downloading and install in the web link resource that we offer right here. Certainly, the Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes will be all yours quicker. It's no need to get ready for guide Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes to obtain some days later on after acquiring. It's no need to go outside under the warms at center day to go to the book shop.
This is a few of the benefits to take when being the participant as well as obtain guide Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes right here. Still ask exactly what's different of the other website? We offer the hundreds titles that are created by advised writers and publishers, worldwide. The link to buy and also download and install Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes is additionally extremely easy. You might not discover the complicated site that order to do more. So, the means for you to get this Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes will be so very easy, will not you?
Based on the Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes information that we provide, you might not be so confused to be right here and also to be member. Obtain currently the soft file of this book Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes and also save it to be yours. You saving can lead you to stimulate the convenience of you in reading this book Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes Even this is kinds of soft documents. You can truly make better opportunity to obtain this Data Binding With Windows Forms 2.0: Programming Smart Client Data Applications With .NET, By Brian Noyes as the advised book to review.
“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
- Sales Rank: #1317732 in Books
- Published on: 2006-01-22
- Released on: 2006-01-12
- Original language: English
- Number of items: 1
- Dimensions: 8.70" h x 1.60" w x 7.00" l, 2.25 pounds
- Binding: Paperback
- 736 pages
From the Back Cover
"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 toUse Visual Studio 2005 to generate a data-bound application from a databaseUse the new Visual Studio 2005 typed data set designer, and how and why to use typed data sets and typed data adaptersPerform simple and complex binding of data to controls, and how to use the .NET 2.0 BindingSourceUse the Binding object for simple binding with automatic formatting, and how to handle binding eventsGenerate bound controls with the Visual Studio Designer, and how to use Data SourcesPresent data with the new DataGridView control, and how to implement advanced features of the DataGridViewImplement custom data-bound controls in Windows FormsCreate 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 levelsImplement data binding with ASP.NET 2.0 and the upcoming Windows Presentation Foundation (Avalon) technologies
About the Author
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.
Excerpt. � Reprinted by permission. All rights reserved.
When I first started discussing this book with the editors at Addison-Wesley, I was a little skeptical. My gut reaction was, “Will anyone need a whole book focused on data binding?” I mean, Windows Forms is just GUI stuff, right? You drag this, you drop that, you hook up a few event handlers, and you move on to build the rest of your enterprise application—all the middle-tier goo that ties your head in knots.
As I thought more about it, I realized that a significant percentage of the work that people do in Windows Forms applications is centered around data binding, and most of the problems developers encounter are related to getting data-binding scenarios to work correctly. Add to that the multitude of new capabilities in Windows Forms 2.0 and Visual Studio 2005 related to data binding, and I quickly became convinced that this book would be a good idea. Hopefully you will agree after you have finished reading it.
Data binding is a powerful capability that has finally matured in Windows Forms 2.0 through the capabilities in the .NET Framework classes, combined with the rich designer support provided by Visual Studio 2005. By using data binding properly, you can save yourself from writing a lot of unnecessary code, provide your users a rich interactive experience for working with data that functions well, and produce code that is easy to maintain. To get it working correctly across a variety of use cases, you need to know more than how to set a few properties on controls—you need to understand what is going on under the hood, especially if you want tosupport complex scenarios that require going beyond the basic capabilities of the data-binding components in the .NET Framework.
Due to the growth of smart client architecture, Windows Forms applications are becoming more prominent in business systems. Web browser-based applications leave a lot to be desired; they cannot support many of today’s common scenarios. They don’t harness the capabilities of the client machine, and they are constrained by the request-response model of browser-based applications and the connectivity issues that surround them. So the importance of being able to code complex data application scenarios in Windows Forms is growing, and luckily the capabilities in .NET services are rapidly maturing to keep pace.
Who Should Read This Book?The primary audience for this book is intermediate to advanced Windows Forms developers who want to learn about the new data-binding features in Windows Forms 2.0 and refine their coding practices for data-bound applications. This book dives deep into advanced features of the data-binding mechanisms in Windows Forms, data-bound controls, working with data sources, and creating custom data-bound objects and collections. If you spend a significant amount of time working with data in Windows Forms applications, then this book is for you.
If you are a beginner Windows Forms developer, this book will help you quickly learn how to support data binding. Many of the features in Windows Forms 2.0 take developers through wizards and designer features that are helpful for beginning programmers, and you will learn about those features in this book. In addition, Appendixes C and D are geared for beginner programmers to get up to speed on the basics of Windows Forms and data access.
ConventionsDeveloping applications is more about tools and less about code. However, there is a lot of code in this book, and I have adopted some common conventions to help make things easier. References to classes, variables, namespaces, and other artifacts that manifest themselves in code are in a monospace font; this helps you distinguish an instance of the DataSet class from a conceptual discussion of data sets. Short code listings are presented inline within the text using a different monospace font.
Longer listings use a similar font, but are identified with listing numbers, for example, Listing 4.1. Within code listings, bold highlights particularly relevant portions of the code, especially “evolving code.” When I remove details that aren’t relevant to a discussion, you’ll see a comment with an ellipsis (//...). This means that more code is needed to complete the example or more code generated by the designer exists, but you don’t need it to understand the concept. On occasion, explanatory comments show context.
I use a conversational tone to discuss the kinds of objects you deal with in data-binding scenarios, for example, when describing the DataSet class in this book. However, much of the time when discussing data sets I am not talking about an instance of a DataSet class, but of an instance of a derived typed DataSet class. Although it would still be technically correct to refer to that class as a DataSet because it “is a” DataSet through inheritance, I find it annoying when too many words are called out as a code artifacts. So, when something really is a code artifact and can only be discussed correctly in that context, it’s set in the monospace font. I favor the terms data set, datatable, and table adapter when discussing concepts surrounding those types of objects, and reserve DataSet, DataTable, and CustomersTableAdapter for citing a specific class type or instance, and the capabilities defined by that code artifact.
Discussing components and controls can also be confusing, depending on how precise you want to be with your language. Technically, all controls in Windows Forms are components, because the Control class derives from the Component class. Many of the concepts surrounding data binding apply to both components, such as the BindingSource component discussed in depth in this book, and controls, such as a DataGridView control. Unfortunately, many people think of components as nonvisual objects that are used by your form and controls as objects that have a visual rendering on your forms. To avoid having to say controls and components ad nauseam, when I discuss a concept that applies to both nonvisual components and controls, I simply say components. So when you see components, think “this applies to controls as well, because they inherit from components.”
System RequirementsThis book was written with the code base of .NET 2.0 and Visual Studio 2005 over the course of Beta 1, several Community Technical Previews, and ultimately Beta 2. The code presented in this book runs with Beta 2. I worked closely with the Windows Client product team at Microsoft, and there are no feature changes planned between Beta 2 and product release. However, some minor syntax may change between production and the release of .NET 2.0. If they do affect the code or concepts, I will provide corrections through the Web site for the book (www.softinsight.com/databindingbook), as well as updated code that will run on Visual Studio 2005 once it is released.
If you plan to run the samples available on the book’s Web site, or the walkthroughs and code listings in the book, you will need Visual Studio 2005 installed on your machine, and you will need access to a SQL Server 2000 or 2005 database server on which the Northwind sample database has been installed. Additionally, you will need to have permissions on that database to create new databases for some of the samples.
There are multiple versions of Visual Studio 2005 to choose from. All of the features discussed in this book even work in the Express versions of Visual Studio 2005, which are free. You can develop all of the samples in this book in Visual C# 2005 Express or Visual Basic 2005 Express with SQL Server 2005 Express, but because Express versions of Visual Studio don’t support data connections using server paths (they only support file path-based connections to SQL Express databases), you will have to create the sample databases and data in SQL Express, and then alter the connection strings and the way you set up connections based in Express.
The samples and scripts included in the book assume you are working on a machine with a standard, professional, or enterprise version of Visual Studio 2005 installed, along with a default instance of either SQL Server 2000 or 2005 on your local machine. To run the samples without that configuration will require modifying the connection string settings for all of the samples that run against a database. The modifications needed are discussed on the book’s Web site, and the differences in connection strings are highlighted in many places in the sample code.
Additionally, Northwind doesn’t ship with SQL Server 2005, but is available as a separate installable download that will work with SQL Server 2005 from MSDN Downloads at www.microsoft.com/downloads/details.aspx? FamilyID=06616212-0356-46A0-8DA2-EEBC53A68034&displaylang=en. The download provides scripts and MDF files that can be attached to SQL Server 2005 or used with SQL Server 2005 Express.
Choice of LanguageI chose to write this book in C#. The download code is available in both C# and Visual Basic code. It is a fact of life that there will continue to be a mix of C# and Visual Basic available in articles, books, and samples for a long time to come. Even though I prefer C# myself, I am not a language bigot and feel Visual Basic is a solid choice for developers who have a strong background in earlier versions of Visual Basic.
I firmly believe that to be an effective .NET developer, you need to be able to read code from either language, even if you spend most of your time with one. If you aren’t already comfortable reading C# code, I encourageyou to use this opportunity to get comfortable reading it. It will expand your horizons in terms of the amount of reference material that is available to you, it may help you in your job, and it will give you bragging rights over the many silly and close-minded C# developers who cannot read Visual Basic.
Coding StandardsYes, I have coding standards, and you should too. It is as simple as that, but unfortunately not done nearly enough by development organizations. Coding standards are an important tool in making sure that code is bug free, but they are even more essential for making sure that your code base is maintainable. Code written by one developer on your team should look like the code written by all the other developers so that it can be maintained and extended if necessary. Code reviews go hand-in-hand with your coding standard and are also something that should be a regular part of your development process.
We have an excellent coding standard at IDesign, which can be downloaded from our site at www.idesign.net. You can use as is, or you can use it to develop your own coding standard. Our standard includes a lot of information that goes beyond simple syntax; it has a lot of best practices for .NET development and design.
For the code presented in this book, I used the IDesign coding standard for naming member variables, properties, methods, and event handlers. Any member of a class, whether just a variable or a control on a form, is given a prefix of m_ and PascalCasing is used for the rest of the name. This is different from the Microsoft standard (which varies somewhat across different product teams), and that is okay. You can use whatever standard you want, as long as you are consistent. I won’t go into the arguments and justifications of coding standard here, but I want to short-circuit any complaints or e-mails that might result.
You will see code snippets where this convention isn’t followed (when I am discussing designer-generated code), because the naming conventions generated by the designer differ from our coding standard. So when discussing the raw code generated by the designer, I will demonstrate theway they generate the code; when I am writing code or focusing on other aspects of the code, I will rename the things generated by the designer to comply with IDesign coding standard.
Code First Versus Design Features FirstOne of the hardest decisions I had to make when writing this book was the order in which to present the concepts: Should I start by discussing code that you can write by hand to get things working in an application, or should I start by walking through all the different combinations of design features in Visual Studio that will write the code for you?
You can get a lot of data binding done through a combination of drag-and-drop interactions in the Visual Studio designer and by setting properties for objects on a form in the Properties window and other windows. When coding production applications, the Visual Studio designer is where you will start 90 percent of the time. Ultimately, those interactions are just having the designer write the code so that you don’t have to. This allows applications to be written much faster and helps figure out how to get data-binding scenarios working even if you don’t really understand the code that is being generated.
If this book’s goal were to cover more introductory level concepts across a wider scope of topics, then sticking to the designer with a little bit of code explanation would be sufficient. However, my goal is to provide a deep technical tutorial on all aspects of Windows Forms data binding for developers who want to tackle complex scenarios that go beyond the designers. Whenever you thoroughly want to understand what is going on, you need to really think about things at the code level, not at the level where the designer, wizards, and windows in Visual Studio are doing magic things for you.
As a result, I chose to tackle things from a code-first perspective. As you progress through the book, for most common scenarios there are ways to get the Visual Studio designers to write most or all of the code for you. But to maintain that code and to go beyond those common scenarios, you also need to be able to write that code by hand (if need be), and know what all the right pieces and parts are to hook together. The chapters are arrangedto first introduce a concept and to show you the raw code that enables you to get that concept working. Then, if there’s a corresponding designer way of getting that code written, that’s covered next.
For example, Chapters 3 and 4 describe data-binding mechanisms in Windows Forms and how to write the code to hook up controls to data sources. Then Chapter 5 shows how to use the Data Sources window to write a lot of that code for you. If you find it easier to learn by seeing things through the designer first and then unraveling the code, you might want to read the chapters and sections focused on the designer features first, and then return to previous sections to understand the code that was written on your behalf.
Northwind—The Database That Will Never DieTo show examples of data binding, you need some data to work with. One approach is to create new databases with new data in them to use in examples. While that may provide more interesting data for the samples, it has the downside of requiring you to learn a new schema and to set up those data sources on your machine to try out the demos. Because most interesting data usually belongs to someone, to avoid having to worry about copyrights and permissions to use the data, I created some sample databases for a few simple examples, but most of the examples use the tried-and-true Northwind database that is installed as part of the samples for SQL Server 2000 with a typical install. Also, through some downloadable scripts from Microsoft, you can get a Northwind instance installed on SQL Server 2005 or SQL Express 2005 as well. See the book’s Web site for detailed instructions on how to do that.
Although many people are bored with Northwind (I count myself in that crowd), it does have the advantage of familiarity, and it is ubiqui-tously available and can be added easily as long as you have SQL Server. If you are already familiar with Northwind, you know about the Customers, Orders, and Order Details tables; if you aren’t, you can learn this fairly simple schema easily.
Overview of the BookThis book starts with some background in peripheral concepts surrounding data binding: how data-bound Windows Forms applications fit into the big-ger picture of distributed application architecture, particularly smart clients. It then delves into the new data-binding features in Windows Forms 2.0 and more advanced topics. The following is an overview of each chapter.
Chapter 1, Building Data-Bound Applications with Windows Forms, introduces the concepts of data binding, along with a quick walkthrough sample using the designer to generate a data-binding application. The data application architecture lays the groundwork for the other pieces to create a rich and robust data application.
Chapter 2, Working with Typed Data Sets and Table Adapters, shows how to use the new Visual Studio 2005 typed data set designer to generate most of the data access code needed in applications through simple drag-and-drop and wizard operations in the designer. It discusses the benefits of typed data sets, how to create and use them, and how to create and use typed table adapters to fill and update those data sets. It also covers how to use table adapters to perform ad hoc and custom queries.
Chapter 3, Introducing Data Binding in Windows Forms, starts delving into coding mechanisms in Windows Forms for data binding. It demonstrates how to perform simple and complex binding of data to controls, and introduces BindingSource, one of the most important data-binding tools available in .NET 2.0.
Chapter 4, Binding Controls to Data Sources, builds on Chapter 3, further peeling back the layers on the use of the BindingSource component, and includes detailed coverage of using the Binding object for simple binding with automatic formatting and for handling binding events.
Chapter 5, Generating Bound Controls with the Visual Studio Designer, introduces the designer features for generating data-binding code: drag-and-drop operations, wizards, and property grid interactions. It covers the Data Sources window in detail and the associated wizards.
Chapter 6, Presenting Data with the DataGridView Control, provides in-depth coverage of the DataGridView control, a rich tabular control for Windows Forms that is new in .NET 2.0. The chapter steps through basic usage as well as advanced scenarios and describes customizing the contentof cells, implementing cell-oriented grids, handling grid events, as well as many other features of the grid.
Chapter 7, Understanding Data-Binding Interfaces, discusses the many interfaces involved in making the data-binding process work, and shows you which interfaces you need to implement when and what is involved. This chapter will help cement your understanding of the real mechanisms that drive data binding.
Chapter 8, Implementing Custom Data-Bound Controls, shows how to implement custom controls in Windows Forms for rendering data and what is required at the control level to use the data-binding interfaces exposed by data collections and objects. It also discusses additional things to consider when creating data-bound controls.
Chapter 9, Implementing Custom Data-Bound Business Objects and Collections, covers how to create custom business objects and collections that you can use in data binding. It discusses implementing appropriate interfaces, and shows samples and how they get used. It provides detailed coverage of the BindingList generic class, which makes creating custom collections of data objects a snap.
Chapter 10, Validating Data Input and Handling Errors, describes validation mechanisms in Windows Forms and how to properly harness those mechanisms. It discusses error handling at the form and data-binding levels, along with strategies for managing concurrency violations.
Appendix A, Binding to Data in ASP.NET, gives a quick introduction to ASP.NET data binding for developers who will have to write both Windows and Web applications.
Appendix B, Binding Data in WinFx Applications, looks at the data-binding mechanisms in WinFx, the next generation presentation subsystem for Windows, so you can compare it to Windows Forms data binding.
Appendix C, Programming Windows Forms Applications, introduces the fundamentals of building Windows Forms applications. Written for beginning Windows Forms programmers, it will make the rest of the applications in the book understandable. It isn’t intended to be a comprehensive lesson on all aspects of Windows Forms programming, just the essentials.
Appendix D, Accessing Data with ADO.NET, is a comprehensive overview of performing data access with ADO.NET. It covers many concepts, including retrieving and updating data with data sets and data readers, working with stored procedures, and managing transactions, as well as how to work with XML as a data source in .NET.
Sample Download Code and UpdatesYou can download all of the sample code used in this book at www.softinsight.com/databindingbook. I will also post any changes, corrections, and updates relevant to the book at that location, and will post instructions on how to modify the sample code to run on the Express versions of Visual Studio and SQL Server 2005.
You can also find links to all of the above at the book’s page on Addison-Wesley’s site at www.awprofessional.com/title/032126892X.
032126892XP12222005
Most helpful customer reviews
20 of 21 people found the following review helpful.
More than just data binding
By Jack D. Herrington
This book is about so much more than data binding. I'm not sure why they titled it this way. The book is really about forms from start to finish, including what is new in the 2.0 framework. It's an excellent work on proper forms programming and data flow. I highly recommend this book for anyone doing a lot of Windows forms work.
18 of 20 people found the following review helpful.
Good Book, but Mistitled
By A regular guy
This book is an excellent introduction to Windows Forms in .NET 2.0, but is really not titled correctly. In particular, the subtitle "Programming Smart Client Data Applications with .NET" is blatantly misleading considering:
1. Offline data access (or disconnected mode usage), by definition a core component of smart clients, is covered for a total of 3 sentences in this book.
2. Other relevant smart client topics, such as ClickOnce deployment, are either addressed in the single "What is a smart client?" section (one page!) or ignored altogether.
I'm giving this book 4 stars because it really is a great book for those venturing into building Windows Forms 2.0 applications (also touching relevant topics like ASP.NET, WinFX and XAML), but the title should have ignored any reference to smart clients altogether. If you're a developer looking for a great resource for building apps in VS.NET 2005, this is the book for you. If you're looking for a smart client resource like I was, this is not it.
21 of 24 people found the following review helpful.
As long as you only want to bind to a data base.
By Amazon Customer
This book (as the title suggests) is strongly geared towards data binding in the context of "Smart Clients." From this book, I take "Smart Client" to mean that you are only showing tabular data directly from databases. He spends 80% of the book talking about binding to data bases with the DataGridView control. Because of this, other aspects of data binding are neglected.
After reading this book, I still had no idea how to create custom properties on a control that can be bound to with simple data binding (use the Bindable attribute, which isn't even mentioned in the book).
He does not sufficiently cover writing controls that want to use non-list data or the interfaces that non-list data objects must implement to be bound to controls.
In the end, this book is just a big example of how to use data binding, as long as you want to do exactly what is done in the samples (bind tabular data to grid views). Very little useful information that can be used to do anything outside this narrow pattern is provided.
UPDATE: I wish I could drop my rating to 2 stars. Every time I try and use this book, I'm infuriated by the lack of any useful information.
Data Binding with Windows Forms 2.0: Programming Smart Client Data Applications with .NET, by Brian Noyes PDF
Data Binding with Windows Forms 2.0: Programming Smart Client Data Applications with .NET, by Brian Noyes EPub
Data Binding with Windows Forms 2.0: Programming Smart Client Data Applications with .NET, by Brian Noyes Doc
Data Binding with Windows Forms 2.0: Programming Smart Client Data Applications with .NET, by Brian Noyes iBooks
Data Binding with Windows Forms 2.0: Programming Smart Client Data Applications with .NET, by Brian Noyes rtf
Data Binding with Windows Forms 2.0: Programming Smart Client Data Applications with .NET, by Brian Noyes Mobipocket
Data Binding with Windows Forms 2.0: Programming Smart Client Data Applications with .NET, by Brian Noyes Kindle
