Troelsen Pro VB 2008 and the .NET 3.5 Platform

3rd ed
ISBN: 978-1-4302-0200-4
Verlag: Apress
Format: PDF
Kopierschutz: 1 - PDF Watermark

E-Book, Englisch, 1377 Seiten

This book provides a complete A-to-Z reference for using VB with the .NET 2.0 platform and the .NET 3.0 extensions. It contains new chapters that explore the interactions between the existing framework and the new extensions, offering readers an edge when they evaluate and implement .NET 3.0 for the first time. To provide even more support, the book comes with a bonus CD that provides over 500 pages of carefully selected additional content to help broaden a reader's understanding of both .NET 2.0 and .NET 3.0.

Andrew Troelsen is a partner, trainer, and consultant at Intertech Inc., and is a leading authority on both .NET and COM. His book Pro C# 2005 and the .NET 2.0 Platform won the prestigious 2003 Referenceware Excellence Award and is in its third edition. Also of note are his earlier five-star treatment of traditional COM in the bestselling Developer's Workshop to COM and ATL mirrored in his book, COM and .NET Interoperability, and his top-notch investigation of VB .NET in Visual Basic .NET and the .NET Platform: An Advanced Guide. Troelsen has a degree in mathematical linguistics and South Asian studies from the University of Minnesota, and is a frequent speaker at numerous .NET-related conferences. He currently lives in Minneapolis with his wife, Amanda, and spends his free time investigating .NET and waiting for the Wild to win the Stanley Cup. You can check out his blog at AndrewTroelsen.blogspot.com.

Autoren/Hrsg.

Troelsen, Andrew

Inhaltsverzeichnis

1;Contents at a Glance;5
2;Contents;7
3;About the Author;20
3.1;About the Technical Reviewer;20
4;Acknowledgments;21
5;Introduction and Welcome;22
5.1;We’re a Team, You and I;23
5.2;Who Should Read This Book?;23
5.3;An Overview of This Book;24
5.4;Obtaining This Book’s Source Code;31
5.5;Obtaining Updates for This Book;31
5.6;Contacting Me;31
6;Introducing Visual Basic 2008 and the . NET Platform;32
6.1;The Philosophy of .NET;33
6.1.1;Understanding the Previous State of Affairs;33
6.1.2;The . NET Solution;36
6.1.3;Introducing the Building Blocks of the . NET Platform ( the CLR, CTS, and CLS);36
6.1.4;What Visual Basic 2008 Brings to the Table;37
6.1.5;Additional . NET- Aware Programming Languages;39
6.1.6;An Overview of . NET Assemblies;40
6.1.7;Understanding the Common Type System;46
6.1.8;Understanding the Common Language Specification;49
6.1.9;Understanding the Common Language Runtime;51
6.1.10;The Assembly/ Namespace/ Type Distinction;52
6.1.11;Using ildasm. exe;57
6.1.12;Using Lutz Roeder’s Reflector;60
6.1.13;Deploying the . NET Runtime;60
6.1.14;The Platform- Independent Nature of . NET;61
6.1.15;Summary;62
6.2;Building Visual Basic 2008 Applications;64
6.2.1;The Role of the . NET Framework 3.5 SDK;64
6.2.2;The VB 2008 Command- Line Compiler ( vbc. exe);65
6.2.3;Building VB 2008 Applications Using vbc. exe;66
6.2.4;Working with vbc. exe Response Files;69
6.2.5;Building . NET Applications Using SharpDevelop;72
6.2.6;Building . NET Applications Using Visual Basic 2008 Express;75
6.2.7;Building . NET Applications Using Visual Studio 2008;76
6.2.8;The Role of the Visual Basic 6.0 Compatibility Assembly;88
6.2.9;A Partial Catalog of Additional . NET Development Tools;90
6.2.10;Summary;90
7;Core VB Programming Constructs;91
7.1;VB 2008 Programming Constructs, Part I;92
7.1.1;The Role of the Module Type;92
7.1.2;The Role of the Main Method;96
7.1.3;An Interesting Aside: Some Additional Members of the System. Environment Class;99
7.1.4;The System. Console Class;100
7.1.5;System Data Types and VB Shorthand Notation;104
7.1.6;Understanding the System. String Type;110
7.1.7;Narrowing ( Explicit) and Widening ( Implicit) Data Type Conversions;116
7.1.8;Building Visual Basic 2008 Code Statements;121
7.1.9;VB 2008 Flow- Control Constructs;123
7.1.10;VB 2008 Iteration Constructs;126
7.1.11;Summary;129
7.2;VB 2008 Programming Constructs, Part II;130
7.2.1;Defining Subroutines and Functions;130
7.2.2;Understanding Member Overloading;138
7.2.3;Array Manipulation in VB 2008;140
7.2.4;Understanding VB 2008 Enumerations;147
7.2.5;Introducing the VB 2008 Structure Type;153
7.2.6;Summary;155
7.3;Designing Encapsulated Class Types;156
7.3.1;Introducing the VB 2008 Class Type;156
7.3.2;Understanding Class Constructors;160
7.3.3;The Role of the Me Keyword;164
7.3.4;Understanding the Shared Keyword;169
7.3.5;Defining the Pillars of OOP;175
7.3.6;Visual Basic 2008 Access Modifiers;178
7.3.7;The First Pillar: VB 2008’s Encapsulation Services;181
7.3.8;Understanding Constant Data;188
7.3.9;Understanding Read- Only Fields;190
7.3.10;Understanding Partial Type Definitions;191
7.3.11;Documenting VB 2008 Source Code via XML;192
7.3.12;Visualizing the Fruits of Our Labor;197
7.3.13;Summary;198
7.4;Understanding Inheritance and Polymorphism;199
7.4.1;The Basic Mechanics of Inheritance;199
7.4.2;Revising Visual Studio 2008 Class Diagrams;203
7.4.3;The Second Pillar: The Details of Inheritance;204
7.4.4;Programming for Containment/ Delegation;210
7.4.5;The Third Pillar: VB 2008’s Polymorphic Support;213
7.4.6;Understanding Base Class/ Derived Class Casting Rules;224
7.4.7;The Master Parent Class: System. Object;226
7.4.8;Summary;232
7.5;Understanding Structured Exception Handling;233
7.5.1;Ode to Errors, Bugs, and Exceptions;233
7.5.2;The Role of . NET Exception Handling;234
7.5.3;The Simplest Possible Example;236
7.5.4;Configuring the State of an Exception;240
7.5.5;System- Level Exceptions ( System. SystemException);244
7.5.6;Application- Level Exceptions ( System. ApplicationException);245
7.5.7;Processing Multiple Exceptions;248
7.5.8;The Finally Block;252
7.5.9;Who Is Throwing What?;253
7.5.10;The Result of Unhandled Exceptions;254
7.5.11;Debugging Unhandled Exceptions Using Visual Studio 2008;254
7.5.12;Blending VB6 Error Processing and Structured Exception Handling;256
7.5.13;Summary;256
7.6;Understanding Object Lifetime;258
7.6.1;Classes, Objects, and References;258
7.6.2;The Basics of Object Lifetime;259
7.6.3;The Role of Application Roots;262
7.6.4;Understanding Object Generations;264
7.6.5;The System. GC Type;265
7.6.6;Building Finalizable Objects;268
7.6.7;Building Disposable Objects;271
7.6.8;Building Finalizable and Disposable Types;273
7.6.9;Summary;276
8;Advanced VB Programming Constructs;277
8.1;Working with Interface Types;278
8.1.1;Understanding Interface Types;278
8.1.2;Defining Custom Interfaces;280
8.1.3;Implementing an Interface;282
8.1.4;Interacting with Types Supporting Interfaces;285
8.1.5;Resolving Name Clashes with the Implements Keyword;291
8.1.6;Building Enumerable Types ( IEnumerable and IEnumerator);296
8.1.7;Building Comparable Objects ( IComparable);303
8.1.8;Using Interfaces As a Callback Mechanism;308
8.1.9;Summary;312
8.2;Collections, Generics, and Nullable Data Types;313
8.2.1;The Nongeneric Types of System. Collections;313
8.2.2;System. Collections. Specialized Namespace;320
8.2.3;Understanding Boxing and Unboxing Operations;320
8.2.4;Type Safety and Strongly Typed Collections;324
8.2.5;The System. Collections. Generic Namespace;329
8.2.6;Understanding Nullable Data Types and the System. Nullable( Of T) Generic Type;332
8.2.7;Creating Generic Methods;335
8.2.8;Creating Generic Structures ( or Classes);338
8.2.9;Creating a Custom Generic Collection;339
8.2.10;Creating Generic Interfaces;345
8.2.11;Creating Generic Delegates;346
8.2.12;Summary;348
8.3;Delegates, Events, and Lambdas;349
8.3.1;Understanding the . NET Delegate Type;349
8.3.2;The Simplest Possible Delegate Example;353
8.3.3;Retrofitting the Car Type with Delegates;356
8.3.4;Understanding ( and Using) Events;361
8.3.5;Defining a “ Prim- and- Proper” Event;367
8.3.6;Defining Strongly Typed Events;369
8.3.7;Customizing the Event Registration Process;370
8.3.8;Visual Basic Lambda Expressions;374
8.3.9;Summary;379
8.4;Operator Overloading and Custom Conversion Routines;381
8.4.1;Understanding Operator Overloading;381
8.4.2;The Details of Value Types and Reference Types;387
8.4.3;Creating Custom Conversion Routines;396
8.4.4;Defining Implicit Conversion Routines;399
8.4.5;The VB DirectCast Keyword;400
8.4.6;Summary;403
8.5;VB 2008–Specific Language Features;404
8.5.1;Understanding Implicit Data Typing;404
8.5.2;Understanding Extension Methods;412
8.5.3;Understanding Object Initializer Syntax;420
8.5.4;Understanding Anonymous Types;424
8.5.5;Summary;429
8.6;An Introduction to LINQ;430
8.6.1;Understanding the Role of LINQ;430
8.6.2;A First Look at LINQ Query Expressions;433
8.6.3;LINQ and Generic Collections;438
8.6.4;LINQ and Nongeneric Collections;440
8.6.5;The Internal Representation of LINQ Query Operators;441
8.6.6;Investigating the VB LINQ Query Operators;445
8.6.7;LINQ Queries: An Island unto Themselves?;453
8.6.8;Summary;454
9;Programming with .NET Assemblies;455
9.1;Introducing .NET Assemblies;456
9.1.1;The Role of . NET Assemblies;456
9.1.2;Understanding the Format of a . NET Assembly;458
9.1.3;Constructing Custom . NET Namespaces;462
9.1.4;Building and Consuming a Single- File Assembly;467
9.1.5;Building and Consuming a Multifile Assembly;476
9.1.6;Understanding Private Assemblies;479
9.1.7;Understanding Shared Assemblies;485
9.1.8;Consuming a Shared Assembly;490
9.1.9;Configuring Shared Assemblies;492
9.1.10;Understanding Publisher Policy Assemblies;496
9.1.11;Understanding the < codeBase> Element;497
9.1.12;The System. Configuration Namespace;499
9.1.13;Summary;500
9.2;Type Reflection, Late Binding, and Attribute- Based Programming;501
9.2.1;The Necessity of Type Metadata;501
9.2.2;Understanding Reflection;505
9.2.3;Building a Custom Metadata Viewer;508
9.2.4;Dynamically Loading Assemblies;512
9.2.5;Reflecting on Shared Assemblies;514
9.2.6;Understanding Late Binding;516
9.2.7;Understanding Attributed Programming;518
9.2.8;Building Custom Attributes;523
9.2.9;Assembly- Level ( and Module- Level) Attributes;525
9.2.10;Reflecting on Attributes Using Early Binding;527
9.2.11;Reflecting on Attributes Using Late Binding;528
9.2.12;Putting Reflection, Late Binding, and Custom Attributes in Perspective;529
9.2.13;Building an Extendable Application;529
9.2.14;Summary;534
9.3;Processes, AppDomains, and Object Contexts;535
9.3.1;Reviewing Traditional Win32 Processes;535
9.3.2;Interacting with Processes Under the . NET Platform;537
9.3.3;Understanding . NET Application Domains;544
9.3.4;Understanding Object Context Boundaries;549
9.3.5;Summarizing Processes, AppDomains, and Context;553
9.3.6;Summary;554
9.4;Building Multithreaded Applications;555
9.4.1;The Process/ AppDomain/ Context/ Thread Relationship;555
9.4.2;A Brief Review of the . NET Delegate;557
9.4.3;The Asynchronous Nature of Delegates;559
9.4.4;Invoking a Method Asynchronously;560
9.4.5;The System. Threading Namespace;565
9.4.6;The System. Threading. Thread Class;566
9.4.7;Programmatically Creating Secondary Threads;569
9.4.8;The Issue of Concurrency;574
9.4.9;Programming with Timer Callbacks;580
9.4.10;Understanding the CLR ThreadPool;582
9.4.11;The Role of the BackgroundWorker Component;583
9.4.12;Summary;587
9.5;.NET Interoperability Assemblies;588
9.5.1;The Scope of . NET Interoperability;588
9.5.2;A Simple Example of . NET to COM Interop;589
9.5.3;Investigating a . NET Interop Assembly;592
9.5.4;Understanding the Runtime Callable Wrapper;595
9.5.5;The Role of COM IDL;597
9.5.6;Late Binding to the CoCalc Coclass;603
9.5.7;Building a More Interesting VB6 COM Server;604
9.5.8;Examining the Interop Assembly;607
9.5.9;Understanding COM to . NET Interoperability;610
9.5.10;The Role of the CCW;612
9.5.11;The Role of the . NET Class Interface;613
9.5.12;Building Your . NET Types;614
9.5.13;Generating the Type Library and Registering the . NET Types;617
9.5.14;Examining the Exported Type Information;618
9.5.15;Building a Visual Basic 6.0 Test Client;619
9.5.16;Summary;620
10;Introducing the .NET Base Class Libraries;621
10.1;File and Directory Manipulation;622
10.1.1;Exploring the System. IO Namespace;622
10.1.2;The Directory( Info) and File( Info) Types;623
10.1.3;Working with the DirectoryInfo Type;624
10.1.4;Working with the Directory Type;628
10.1.5;Working with the DriveInfo Class Type;629
10.1.6;Working with the FileInfo Class;630
10.1.7;Working with the File Type;633
10.1.8;The Abstract Stream Class;635
10.1.9;Working with StreamWriters and StreamReaders;638
10.1.10;Working with StringWriters and StringReaders;641
10.1.11;Working with BinaryWriters and BinaryReaders;642
10.1.12;Programmatically “ Watching” Files;644
10.1.13;Performing Asynchronous File I/ O;646
10.1.14;Summary;647
10.2;Introducing Object Serialization;648
10.2.1;Understanding Object Serialization;648
10.2.2;Configuring Objects for Serialization;651
10.2.3;Choosing a Serialization Formatter;652
10.2.4;Serializing Objects Using the BinaryFormatter;654
10.2.5;Serializing Objects Using the SoapFormatter;655
10.2.6;Serializing Objects Using the XmlSerializer;656
10.2.7;Persisting Collections of Objects;659
10.2.8;Customizing the Serialization Process;660
10.2.9;Summary;666
10.3;ADO.NET Part I: The Connected Layer;667
10.3.1;A High- Level Definition of ADO. NET;667
10.3.2;Understanding ADO. NET Data Providers;669
10.3.3;Additional ADO. NET Namespaces;672
10.3.4;The Types of the System. Data Namespace;672
10.3.5;Abstracting Data Providers Using Interfaces;677
10.3.6;Creating the AutoLot Database;679
10.3.7;The ADO. NET Data Provider Factory Model;685
10.3.8;Understanding the Connected Layer of ADO. NET;691
10.3.9;Working with Data Readers;696
10.3.10;Building a Reusable Data Access Library;698
10.3.11;Creating a Console UI – Based Front End;706
10.3.12;Asynchronous Data Access Using SqlCommand;711
10.3.13;An Introduction to Database Transactions;712
10.3.14;Summary;717
10.4;ADO.NET Part II: The Disconnected Layer;718
10.4.1;Understanding the Disconnected Layer of ADO. NET;718
10.4.2;Understanding the Role of the DataSet;719
10.4.3;Working with DataColumns;722
10.4.4;Working with DataRows;724
10.4.5;Working with DataTables;728
10.4.6;Binding DataTable Objects to User Interfaces;733
10.4.7;Filling DataSet/ DataTable Objects Using Data Adapters;743
10.4.8;Revisiting AutoLotDAL. dll;746
10.4.9;Navigating Multitabled DataSet Objects;749
10.4.10;The Data Access Tools of Visual Studio 2008;755
10.4.11;Decoupling Autogenerated Code from the UI Layer;766
10.4.12;Summary;769
10.5;Programming with the LINQ APIs;771
10.5.1;The Role of LINQ to ADO. NET;771
10.5.2;Programming with LINQ to DataSet;772
10.5.3;Programming with LINQ to SQL;777
10.5.4;Generating Entity Classes Using sqlmetal. exe;782
10.5.5;Building Entity Classes Using Visual Studio 2008;788
10.5.6;Programming with LINQ to XML;791
10.5.7;The Integrated XML Support of Visual Basic 2008;793
10.5.8;Programmatically Creating XML Elements;795
10.5.9;Programmatically Creating XML Documents;797
10.5.10;Generating Documents from LINQ Queries;799
10.5.11;Loading and Parsing XML Content;800
10.5.12;Navigating an In- Memory XML Document;801
10.5.13;Summary;806
10.6;Introducing Windows Communication Foundation;807
10.6.1;A Potpourri of Distributed Computing APIs;807
10.6.2;The Role of WCF;813
10.6.3;Investigating the Core WCF Assemblies;816
10.6.4;The Visual Studio WCF Project Templates;817
10.6.5;The Basic Composition of a WCF Application;819
10.6.6;The ABCs of WCF;820
10.6.7;Building a WCF Service;825
10.6.8;Hosting the WCF Service;828
10.6.9;Building the WCF Client Application;836
10.6.10;Using the WCF Service Library Project Template;838
10.6.11;Hosting the WCF Service As a Windows Service;841
10.6.12;Invoking a Service Asynchronously;845
10.6.13;Designing WCF Data Contracts;847
10.6.14;Summary;853
10.7;Introducing Windows Workflow Foundation;854
10.7.1;Defining a Business Process;854
10.7.2;The Building Blocks of WF;855
10.7.3;WF Assemblies, Namespaces, and Projects;861
10.7.4;Building a Simple Workflow- Enabled Application;863
10.7.5;Examining the WF Engine Hosting Code;867
10.7.6;Invoking Web Services Within Workflows;870
10.7.7;Building a Reusable WF Code Library;884
10.7.8;A Brief Word Regarding Custom Activities;889
10.7.9;Summary;890
11;Desktop Applications with Windows Forms;892
11.1;Introducing Windows Forms;893
11.1.1;Overview of the System. Windows. Forms Namespace;893
11.1.2;Working with the Windows Forms Types;895
11.1.3;The Role of the Application Class;897
11.1.4;The Anatomy of a Form;900
11.1.5;The Functionality of the Control Class;901
11.1.6;The Functionality of the Form Class;906
11.1.7;Building Windows Applications with Visual Studio 2008;910
11.1.8;Working with MenuStrips and ContextMenuStrips;915
11.1.9;Working with StatusStrips;923
11.1.10;Working with ToolStrips;929
11.1.11;Building an MDI Application;934
11.1.12;Summary;937
11.2;Rendering Graphical Data with GDI+;938
11.2.1;A Survey of the GDI+ Namespaces;938
11.2.2;An Overview of the System. Drawing Namespace;939
11.2.3;The System. Drawing Utility Types;940
11.2.4;Understanding the Graphics Class;942
11.2.5;Understanding Paint Sessions;944
11.2.6;The GDI+ Coordinate Systems;948
11.2.7;Defining a Color Value;952
11.2.8;Manipulating Fonts;954
11.2.9;Survey of the System. Drawing. Drawing2D Namespace;962
11.2.10;Working with Pens;962
11.2.11;Working with Brushes;966
11.2.12;Rendering Images;972
11.2.13;Dragging and Hit Testing the PictureBox Control;974
11.2.14;Understanding the Windows Forms Resource Format;982
11.2.15;Summary;990
11.3;Programming with Windows Forms Controls;991
11.3.1;The World of Windows Forms Controls;991
11.3.2;Adding Controls to Forms by Hand;992
11.3.3;Adding Controls to Forms Using Visual Studio 2008;994
11.3.4;Working with the Basic Controls;995
11.3.5;Configuring the Tab Order;1011
11.3.6;Setting the Form’s Default Input Button;1012
11.3.7;Working with More Exotic Controls;1012
11.3.8;Building Custom Windows Forms Controls;1030
11.3.9;Testing the CarControl Type;1036
11.3.10;Building a Custom CarControl Form Host;1037
11.3.11;The Role of the System. ComponentModel Namespace;1038
11.3.12;Building Custom Dialog Boxes;1042
11.3.13;Dynamically Positioning Windows Forms Controls;1047
11.3.14;Summary;1051
12;Desktop Applications with WPF;1052
12.1;Introducing Windows Presentation Foundation and XAML;1053
12.1.1;The Motivation Behind WPF;1053
12.1.2;The Various Flavors of WPF Applications;1056
12.1.3;Investigating the WPF Assemblies;1059
12.1.4;Building a ( XAML- Free) WPF Application;1066
12.1.5;Additional Details of the Application Type;1069
12.1.6;Additional Details of the Window Type;1071
12.1.7;Building a ( XAML- Centric) WPF Application;1076
12.1.8;Transforming Markup into a . NET Assembly;1080
12.1.9;Separation of Concerns Using Code- Behind Files;1084
12.1.10;The Syntax of XAML;1086
12.1.11;Building WPF Applications Using Visual Studio 2008;1097
12.1.12;Processing XAML at Runtime: SimpleXamlPad. exe;1101
12.1.13;The Role of Microsoft Expression Blend;1105
12.1.14;Summary;1107
12.2;Programming with WPF Controls;1108
12.2.1;A Survey of the WPF Control Library;1108
12.2.2;Declaring Controls in XAML;1111
12.2.3;Understanding the Role of Dependency Properties;1113
12.2.4;Understanding Routed Events;1117
12.2.5;Working with Button Types;1121
12.2.6;Working with CheckBoxes and RadioButtons;1125
12.2.7;Working with the ListBox and ComboBox Types;1128
12.2.8;Working with Text Areas;1134
12.2.9;Controlling Content Layout Using Panels;1136
12.2.10;Building a Window’s Frame Using Nested Panels;1146
12.2.11;Understanding WPF Control Commands;1152
12.2.12;Understanding the WPF Data Binding Model;1155
12.2.13;Data Conversion Using IValueConverter;1158
12.2.14;Binding to Custom Objects;1161
12.2.15;Binding UI Elements to XML Documents;1166
12.2.16;Summary;1170
12.3;WPF 2D Graphical Rendering, Resources, and Themes;1171
12.3.1;The Philosophy of WPF Graphical Rendering Services;1171
12.3.2;Exploring the Shape- Derived Types;1179
12.3.3;Working with WPF Brushes;1181
12.3.4;Working with WPF Pens;1184
12.3.5;Exploring the Drawing- Derived Types;1185
12.3.6;The Role of UI Transformations;1189
12.3.7;Understanding WPF’s Animation Services;1191
12.3.8;Understanding the WPF Resource System;1199
12.3.9;Defining and Applying Styles for WPF Controls;1202
12.3.10;Altering a Control’s UI Using Templates;1211
12.3.11;Summary;1215
13;Building Web Applications with ASP. NET;1216
13.1;Building ASP.NET Web Pages;1217
13.1.1;The Role of HTTP;1217
13.1.2;Understanding Web Applications and Web Servers;1218
13.1.3;The Role of HTML;1221
13.1.4;The Role of Client- Side Scripting;1226
13.1.5;Submitting the Form Data ( GET and POST);1228
13.1.6;Building a Classic ASP Page;1229
13.1.7;Problems with Classic ASP;1231
13.1.8;The ASP. NET Namespaces;1232
13.1.9;The ASP. NET Web Page Code Model;1233
13.1.10;Details of an ASP. NET Website Directory Structure;1244
13.1.11;The ASP. NET Page Compilation Cycle;1245
13.1.12;The Inheritance Chain of the Page Type;1248
13.1.13;Interacting with the Incoming HTTP Request;1249
13.1.14;Interacting with the Outgoing HTTP Response;1252
13.1.15;The Life Cycle of an ASP. NET Web Page;1254
13.1.16;The Role of the web. config File;1258
13.1.17;Summary;1261
13.2;ASP.NET Web Controls, Themes, and Master Pages;1262
13.2.1;Understanding the Nature of Web Controls;1262
13.2.2;The System. Web. UI. Control Type;1264
13.2.3;Key Members of the System. Web. UI. WebControls. WebControl Type;1268
13.2.4;Categories of ASP. NET Web Controls;1268
13.2.5;Building an ASP. NET Website;1270
13.2.6;The Role of the Validation Controls;1286
13.2.7;Working with Themes;1290
13.2.8;Summary;1296
13.3;ASP.NET State Management Techniques;1297
13.3.1;The Issue of State;1297
13.3.2;ASP. NET State Management Techniques;1299
13.3.3;Understanding the Role of ASP. NET View State;1300
13.3.4;The Role of the Global. asax File;1303
13.3.5;Understanding the Application/ Session Distinction;1305
13.3.6;Working with the Application Cache;1310
13.3.7;Maintaining Session Data;1315
13.3.8;Understanding Cookies;1318
13.3.9;The Role of the < sessionState> Element;1321
13.3.10;Understanding the ASP. NET Profile API;1324
13.3.11;Summary;1330
14;Index;1331