book

Programming Microsoft® ASP.NET 3.5

Name: Programming Microsoft® ASP.NET 3.5
Author: Dino Esposito
ISBN: 9780735625273

by Dino Esposito

February 2008

Intermediate to advanced

1152 pages

31h 15m

English

Microsoft Press

Read now

Unlock full access

Programming Microsoft ASP.NET 3.5
SPECIAL OFFER: Upgrade this ebook with O’Reilly
Acknowledgements
Introduction
Who Is This Book For?
System Requirements
Find Additional Content Online
The Companion Web Site
Support for This Book
Questions and Comments
I. Building an ASP.NET Page

1. The ASP.NET Programming Model
What's ASP.NET, Anyway?Programming in the Age of Web FormsEvent-Driven Programming over HTTPThe HTTP ProtocolThe HTTP RequestThe HTTP ResponseBuilding a Server-Side Abstraction LayerSubmitting FormsStructure of an ASP.NET PageA Sample ASP.NET PageQuick Review of the Code
The ASP.NET Component Model
A Model for Component InteractionThe runat AttributeWorking with Server-Side ControlsPagewide TagsUnknown TagsASP.NET Server ControlsHTML Server ControlsWeb Server Controls
The ASP.NET Development Stack
The Presentation LayerRich ControlsCustom ControlsAdaptive RenderingThe Page FrameworkPage EventsPage ScriptingPage PersonalizationPage StylingPage PrototypingThe HTTP Runtime EnvironmentSystem HTTP ModulesApplication ConfigurationApplication Services
The ASP.NET Provider Model
The Rationale Behind the Provider ModelExemplifying the Provider ModelBenefits of the Provider ModelA Quick Look at the ASP.NET ImplementationThe Provider ClassThe Configuration LayerThe Storage LayerAvailable Types of Providers
Conclusion
Just the Facts
2. Web Development in Microsoft Visual Studio 2008
Introducing Visual Studio 2008Visual Studio HighlightsNo IIS DependencyMultiple Ways to Access Web SitesProject Output Build OptionsCopying a Web ProjectSmarter Editing with Microsoft IntelliSenseVisual Studio 2008–Specific New FeaturesMultitarget ProjectsThe JavaScript DebuggerIntelliSense for JavaScriptCSS DesignerNew Language FeaturesExtension MethodsAutomatic PropertiesObject InitializersType Inference and Anonymous TypesLINQ Operators
Create an ASP.NET Web Site Project
Page Design FeaturesMaster PagesNested Master PagesContent PagesCode-Behind ClassesThe Toolbox of ControlsEditor's Special CapabilitiesCode RefactoringImport/Export of IDE FeaturesAdding Code to the ProjectDefining Event HandlersWriting Helper ClassesBuilding a Sample Shared ClassA Look at the web.config FileASP.NET Protected FoldersAdditional Application DirectoriesThe App_Code DirectoryThe Resource DirectoriesLinked Web ServicesAvailable ThemesBuild the ASP.NET ProjectDebugging FeaturesTesting the Application
Application Deployment
XCopy DeploymentCopying FilesBuilding a Setup ProjectWhat Else Do You Need to Do?Configuring the Runtime EnvironmentSite PrecompilationIn-Place PrecompilationPrecompilation for Deployment
Administering an ASP.NET Application
The Web Site Administration ToolMembership and Role ManagementApplication Settings ManagementSelecting and Configuring ProvidersEditing ASP.NET Configuration FilesA Visual Editor for web.config Files
Conclusion
Just the Facts
3. Anatomy of an ASP.NET Page
Invoking a PageThe Runtime MachineryIIS 5.0 Process ModelIIS 6.0 Process ModelRepresenting the Requested PagePartial Classes in ASP.NET ProjectsProcessing the RequestThe HttpRuntime ObjectThe Application FactoryThe HttpApplication ObjectThe Page FactoryThe Processing Directives of a PageThe @Page DirectiveThe @Assembly DirectiveThe @Import DirectiveThe @Implements DirectiveThe @Reference Directive
The Page Class
Properties of the Page ClassIntrinsic ObjectsWorker PropertiesContext PropertiesMethods of the Page ClassRendering MethodsControls-Related MethodsScript-Related MethodsEvents of the Page ClassThe Eventing ModelIntroducing the View StateThe Single Form ModelAsynchronous PagesThe Async AttributeThe AddOnPreRenderCompleteAsync MethodThe Significance of PreRenderCompleteBuilding a Sample Asynchronous PageThe RegisterAsyncTask MethodChoosing the Right Approach
The Page Life Cycle
Page SetupThe PreInit EventThe Init EventThe InitComplete EventView-State RestorationProcessing Posted DataThe PreLoad EventThe Load EventHandling Dynamically Created ControlsHandling the PostbackDetecting Control State ChangesExecuting the Server-Side Postback EventThe LoadComplete EventPage FinalizationThe PreRender EventThe PreRenderComplete EventThe SaveStateComplete EventGenerating the MarkupThe Unload Event
Conclusion
Just the Facts
4. ASP.NET Core Server Controls
Generalities of ASP.NET Server ControlsProperties of the Control ClassIdentifying a Server ControlNaming ContainersBinding ContainersVisibility of a Server ControlMethods of the Control ClassEvents of the Control ClassOther FeaturesAdaptive RenderingBrowser-Sensitive RenderingXHTML ComplianceThemeable ControlsControl StateInput Focus
HTML Controls
Generalities of HTML ControlsThe HtmlControl Base ClassWorking with HTML AttributesHierarchy of HTML ControlsHTML Container ControlsManaging Header InformationNavigating to a URLHandling Events on the ServerThe HtmlSelect ControlHTML TablesThe HtmlTextArea ControlHTML Input ControlsCommand ButtonsControlling ValidationDetecting State Changes of ControlsUploading FilesThe HtmlImage ControlLiteral Controls
Web Controls
Generalities of Web ControlsProperties of Web ControlsStyling Web ControlsManaging the Style of Web ControlsMethods of Web ControlsCore Web ControlsButton ControlsHyperLinksImages and Image ButtonsCheck Boxes and Radio ButtonsScrollable PanelsText ControlsHidden Fields and File UploadMiscellaneous Web ControlsThe AdRotator ControlThe Calendar ControlThe Xml ControlThe PlaceHolder ControlView Controls
Validation Controls
Generalities of Validation ControlsThe BaseValidator ClassAssociating Validators with Input ControlsGallery of ControlsThe CompareValidator ControlThe CustomValidator ControlThe RegularExpressionValidator ControlThe RangeValidator ControlThe RequiredFieldValidator ControlSpecial CapabilitiesDisplaying Error InformationThe ValidationSummary ControlEnabling Client ValidationValidation Groups
Conclusion
Just The Facts
5. Working with the Page
Programming with FormsThe HtmlForm ClassProperties of the HtmlForm ClassMethods of the HtmlForm ClassMultiple FormsUsing HTML FormsMultiple <form> Tags on a PageMultiple View and WizardsCross-Page PostingsPosting Data to Another PageThe @PreviousPageType DirectiveDetecting Cross-Page PostingsDealing with ValidationRedirecting Users to Another Page
Dealing with Page Errors
Basics of Error HandlingDefault Error PagesPage-Level Error HandlingGlobal Error HandlingRobust Error HandlingMapping Errors to PagesThe <customErrors> SectionUsing Custom Error PagesHandling Common HTTP ErrorsGetting Information About the Exception
ASP.NET Tracing
Tracing the Execution Flow in ASP.NETEnabling Page TracingEnabling Tracing ProgrammaticallyWriting Trace MessagesThe TraceContext ClassEmitting Trace MessagesTracing from External ClassesThe Trace Viewer
Page Personalization
Creating the User ProfileDefinition of the Data ModelThe User Profile Class RepresentationUsing Collection TypesUsing Custom TypesGrouping PropertiesInteracting with the PageCreating the Profile DatabaseWorking with Anonymous UsersAccessing Profile PropertiesPersonalization EventsMigrating Anonymous DataProfile ProvidersConfiguring Profile ProvidersStructure of AspNetDb.mdfCustom Profile Providers
Conclusion
Just The Facts
6. Rich Page Composition
Working with Master PagesAuthoring Rich Pages in ASP.NET 1.xWhat's Good About User ControlsWhat's Bad About User ControlsVisual InheritanceWriting a Master PageWhat's a Master Page, Anyway?The @Master DirectiveThe ContentPlaceHolder Container ControlSpecifying Default ContentWriting a Content PageThe Content ControlAttaching Pages to a MasterDevice-Specific MastersSetting the Title of a PageProcessing Master and Content PagesCompiling Master PagesServing the Page to UsersNested Master PagesProgramming the Master PageExposing Master PropertiesInvoking Properties on the MasterThe @MasterType DirectiveChanging the Master Page Dynamically
Working with Themes
Understanding ASP.NET ThemesWhat's a Theme, Anyway?Structure of a ThemeCustomization Themes vs. Style Sheet ThemesTheming Pages and ControlsEnabling Themes on a PageApplying SkinsTaking Control of ThemingTheming ControlsPutting Themes to WorkCSS vs. ThemesCreating a ThemeLoading Themes Dynamically
Working with Wizards
An Overview of the Wizard ControlStructure of a WizardWizard Styles and TemplatesThe Wizard's Programming InterfaceAdding Steps to a WizardTypes of Wizard StepsCreating an Input StepDefining the SidebarNavigating Through the WizardFiltering Page Navigation with EventsCanceling EventsFinalizing the Wizard
Conclusion
Just the Facts
II. Adding Data in an ASP.NET Site
7. ADO.NET Data Providers
.NET Data Access Infrastructure.NET Managed Data ProvidersBuilding Blocks of a .NET Data ProviderInterfaces of a .NET Data ProviderManaged Providers vs. OLE DB ProvidersData Sources You Access Through ADO.NETAccessing SQL ServerAccessing Oracle DatabasesUsing OLE DB ProvidersUsing ODBC DriversThe Provider Factory ModelInstantiating Providers ProgrammaticallyEnumerating Installed Data ProvidersDatabase-Agnostic Pages
Connecting to Data Sources
The SqlConnection ClassProperties of the SqlConnection ClassMethods of the SqlConnection ClassChanging PasswordsAccessing Schema InformationConnection StringsConfiguring Connection PropertiesConnection String BuildersStoring and Retrieving Connection StringsProtecting Connection StringsConnection PoolingConfiguring PoolingGetting and Releasing ObjectsDetecting Connections LeaksManaging Connection LifetimeClearing the Connection Pool
Executing Commands
The SqlCommand ClassProperties of the SqlCommand ClassMethods of the SqlCommand ClassWays to ExecuteADO.NET Data ReadersReading Data with the Data ReaderCommand BehaviorsClosing the ReaderAccessing Multiple Result SetsAsynchronous CommandsSetting Up Asynchronous CommandsNonblocking CommandsExecuting Parallel Commands in an ASP.NET PageNonblocking Data-Driven ASP.NET PagesWorking with TransactionsManaging Local Transactions as in ADO.NET 1.xIntroducing the TransactionScope ObjectDistributed Transactions with TransactionScopeEnlisting in a Distributed Transaction in ADO.NET 1.xSQL Server 2005–Specific EnhancementsSupport for CLR TypesSupport for XML as a Native TypeSQL Notifications and DependenciesMultiple Active Result Sets
Conclusion
Just The Facts
8. ADO.NET Data Containers
Data AdaptersThe SqlDataAdapter ClassProgramming the SQL Server Data AdapterFilling a DataSet Using a Data AdapterLoading OptionsThe Table-Mapping MechanismThe Column-Mapping MechanismMissing Mapping ActionMissing Schema ActionPrefilling the SchemaHow Batch Update WorksData Conflicts and Optimistic LockCommand Builders
In-Memory Data Container Objects
The DataSet ObjectReading Stored DataMerging DataSet ObjectsThe DataSet Commit ModelSerializing Contents to XMLSerialization and Remoting FormatThe DataTable ObjectPerforming ComputationsColumns of a TableRows of a TableTable ConstraintsData RelationsCreating a Data RelationPerforming Calculations on RelationsSerializing a Data RelationThe DataView ObjectNavigating the ViewFinding Rows
Conclusion
Just The Facts
9. The Data-Binding Model
Data Source-Based Data BindingFeasible Data SourcesADO.NET ClassesCollection-Based ClassesData-Binding PropertiesThe DataSource PropertyThe DataSourceID PropertyThe DataMember PropertyThe DataTextField PropertyThe DataValueField PropertyThe AppendDataBoundItems PropertyThe DataKeyField PropertyList ControlsThe DropDownList ControlThe CheckBoxList ControlThe RadioButtonList ControlThe ListBox ControlThe BulletedList ControlIterative ControlsThe Repeater ControlThe DataList ControlThe DataGrid Control
Data-Binding Expressions
Simple Data BindingBinding in ActionImplementation of Data-Binding ExpressionsThe DataBinder ClassThe Eval MethodA More Compact EvalGetting the Default Data ItemOther Data-Binding MethodsThe XPath MethodThe XPathSelect MethodThe Bind MethodUser-Defined Dynamic Expressions
Data Source Components
Overview of Data Source ComponentsA Click in the Life of DataGridA Click in the Life of GridViewInternals of Data Source ControlsData Source ViewsInteraction with Data-Bound ControlsHierarchical Data Source ViewsThe SqlDataSource ControlProgramming Interface of SqlDataSourceDeclarative ParametersConflicts DetectionCaching BehaviorThe AccessDataSource ClassWorking with an Access DatabaseUpdating an Access DatabaseThe ObjectDataSource ControlProgramming Interface of ObjectDataSourceImplementing Data RetrievalUsing ParametersCaching Data and Object InstancesSetting Up for PagingUpdating and Deleting DataConfiguring Parameters at RuntimeThe LinqDataSource ClassWhat's Linq-to-SQL, Anyway?The Goal of LinqDataSourceProgramming Interface of the LinqDataSource ControlEvents of the LinqDataSource ControlSelecting, Sorting, and Filtering DataWhen the Select Property Is Not EnoughLazy Loading and PrefetchUpdating DataLinqDataSource vs ObjectDataSource vs SqlDataSourceThe SiteMapDataSource ClassDisplaying Site Map InformationProgramming Interface of SiteMapDataSourceThe XmlDataSource ClassProgramming Interface of XmlDataSourceDisplaying XML DataTransforming XML Data
Conclusion
Just the Facts
10. The Linq-to-SQL Programming Model
LINQ In BriefLanguage-Integrated Tools for Data OperationsMaking Sense of LINQLinq-to-SQLLinq-to-XMLLinq-to-DataSetsLinq-to-ObjectsA Common Query SyntaxProjection OperatorsJoining and GroupingAggregationPartitioningIdentifying ElementsThe Mechanics of LINQThe Layers of LINQMapping to the Data SourceExecuting the Query
Working with SQL Server
The Data ContextCreating the Data ContextGenerating the CodeAnalyzing the Generated CodeExtensibility Methods in the Generated CodeQuerying for DataPreparing the QueryInside a Sample QueryFlat and Hierarchical ResultsDeferred Loading and PrefetchingPreloading DataLinq-to-SQL Query RestrictionsUpdating DataMaking Changes to the Data ContextAdding and Deleting ObjectsCross-Table UpdatesOptimistic ConcurrencyCustomizing Update OperationsOther FeaturesUsing TransactionsUsing Stored ProceduresUsing User-Defined Functions
Conclusion
Just the Facts
11. Creating Bindable Grids of Data
The DataGrid ControlThe DataGrid Object ModelProperties of the DataGrid ControlConstituent Elements of a DataGridData Source Rows and Displayed RowsEvents of the DataGrid ControlBinding Data to the GridData-Bound ColumnsHyperLink ColumnsButton ColumnsTemplated ColumnsWorking with the DataGridPaging Through the Data SourceSorting Columns of DataEditing Existing Rows
The GridView Control
The GridView Object ModelProperties of the GridView ControlEvents of the GridView ControlSimple Data BindingBinding Data to a GridView ControlConfiguring ColumnsBound FieldsButton FieldsHyperLink FieldsCheckBox FieldsImage FieldsTemplated FieldsPaging DataCodeless Data PagingMoving the Burden of Paging to the DALPaging AlgorithmsConfiguring the PagerSorting DataCodeless Data SortingMoving the Burden of Sorting to the DALGive Users FeedbackUsing Callbacks for Paging and SortingEditing DataIn-Place Editing and UpdatesDeleting Displayed RecordsInserting New RecordsAdvanced CapabilitiesExecuting an Operation on a Given RowSelecting a Given RowRow Customization
Conclusion
Just The Facts
12. Managing a List of Records
The ListView ControlThe ListView Object ModelProperties of the ListView ControlEvents of the ListView ControlCompared to Other View ControlsSimple Data BindingDefining the Layout of the ListBuilding a Tabular LayoutDefinition of the Overall LayoutDefinition of the Item TemplateUsing Alternate Rendering for Data ItemsReflecting On the Table LayoutBuilding a Flow LayoutDefinition of the Overall LayoutDefinition of the Item LayoutBuilding a Tiled LayoutGrouping ItemsUsing the Group Separator TemplateModifying the Group Item Count DynamicallyData-Driven Group TemplatesStyling the ListStyle PropertiesUsing Cascading Style Sheets
Working with the ListView Control
In-Place EditingDefining the Edit Item TemplateAdding Predefined Command ButtonsAdding Custom Command ButtonsConducting the UpdateDeleting an Existing RecordShowing a Message Box upon CompletionInserting New Data ItemsSetting Up the Insert Item TemplateTaking Full Control of the Insert TemplateAdding a Bit of ValidationSelecting an ItemTriggering the SelectionReleasing the SelectionPaging the List of ItemsThe DataPager ControlUsing the DataPager ControlConfiguring the Data Pager FieldsPageable ContainersSorting the List
Conclusion
Just the Facts
13. Managing Views of a Record
The DetailsView ControlThe DetailsView Object ModelProperties of the DetailsViewEvents of the DetailsViewSimple Data BindingBinding Data to a DetailsView ControlControlling the Displayed FieldsPaging Through Bound DataPaging via CallbacksCreating Master/Detail ViewsDrill Down into the Selected RecordCaching IssuesWorking with DataEditing the Current RecordDeleting the Current RecordInserting a New RecordTemplated FieldsAdding Validation SupportValidating Without Validators
The FormView Control
The FormView Object ModelMembers of the FormView ControlSupported TemplatesSupported OperationsBinding Data to a FormView ControlHeader, Footer, and PagerDisplaying DataThe Eval FunctionEditing DataThe Edit TemplateThe Bind FunctionThe Insert TemplateWhen the Function Is Not Supported
Conclusion
Just The Facts
III. ASP.NET Infrastructure
14. The HTTP Request Context
Initialization of the ApplicationProperties of the HttpApplication ClassApplication ModulesMethods of the HttpApplication ClassEvents of the HttpApplication Class
The global.asax File
Compiling global.asaxSyntax of global.asaxApplication DirectivesCode Declaration BlocksServer-Side <object> TagsServer-Side IncludesStatic PropertiesTracking Errors and Anomalies
The HttpContext Class
Properties of the HttpContext ClassMethods of the HttpContext ClassURL RewritingLoading Resources Programmatically
The Server Object
Properties of the HttpServerUtility ClassMethods of the HttpServerUtility ClassEmbedding Another Page's ResultsServer-Side RedirectionLate-Bound COM ObjectsThe Importance of AspCompat
The HttpResponse Object
Properties of the HttpResponse ClassSetting the Response Cache PolicySetting an Output FilterMethods of the HttpResponse ClassOutput Caching FeaturesLarge File Transmission
The HttpRequest Object
Properties of the HttpRequest ClassInformation About the RequestInformation from the ClientInformation About the ConnectionMethods of the HttpRequest ClassSaving the Request to DiskValidating Client Input
Conclusion
Just the Facts
15. ASP.NET State Management
The Application's StateProperties of the HttpApplicationState ClassMethods of the HttpApplicationState ClassState SynchronizationTradeoffs of Application StateMemory OccupationConcurrent Access to Data
The Session's State
The Session-State HTTP ModuleState Client ManagersCreating the HttpSessionState ObjectSynchronizing Access to the Session StateProperties of the HttpSessionState ClassMethods of the HttpSessionState Class
Working with a Session's State
Identifying a SessionGenerating the Session IDSession CookiesCookieless SessionsIssues with Cookieless SessionsCookieless Sessions and SecurityConfiguring the Session StateLifetime of a SessionThe Session_Start EventThe Session_End EventWhy Does My Session State Sometimes Get Lost?Persist Session Data to Remote ServersState Serialization and DeserializationStoring Session DataConfiguring the StateServer ProviderPersist Session Data to SQL ServerPerformance and RobustnessConfiguring Session State for SQL Server SupportCreating the SQL Server Data StoreReverting to the Hosting Identity
Customizing Session State Management
Building a Custom Session State ProviderDefining the Session State StoreLocking and ExpirationReplacing the Session Data DictionaryRegistering a Custom Session State ProviderGenerating a Custom Session IDThe Default BehaviorA Homemade Session ID Manager
The View State of a Page
The StateBag ClassView State PropertiesView State MethodsCommon Issues with View StateEncrypting and SecuringMachine Authentication CheckSize Thresholds and Page ThroughputProgramming Web Forms Without View StateDisabling View StateDetermining When to Disable View StateChanges in the ASP.NET View StateThe Serialization FormatThe Control StateProgramming the Control StateKeeping the View State on the ServerThe LosFormatter ClassThe ObjectStateFormatter ClassCreating a View-State-Less PageCreating a File-based State Persister
Conclusion
Just the Facts
16. ASP.NET Caching
Caching Application DataThe Cache ClassCache and Other State ObjectsProperties of the Cache ClassMethods of the Cache ClassAn Interior ViewWorking with the ASP.NET CacheInserting New Items in the CacheRemoving Items from the CacheTracking Item DependenciesDefining a Removal CallbackSetting the Item's PriorityControlling Data ExpirationPractical IssuesShould I Cache or Should I Fetch?Building a Wrapper Cache ObjectEnumerating Items in the CacheClearing the CacheCache SynchronizationPer-Request CachingDesigning a Custom DependencyWhat Cache Dependencies Cannot Do in ASP.NET 1.xExtensions to the CacheDependency Base ClassGetting Change NotificationsThe AggregateCacheDependency ClassA Cache Dependency for XML DataDesigning the XmlDataCacheDependency ClassImplementing the DependencyTesting the Custom DependencySQL Server Cache DependencyUnder the Hood of Database DependenciesEnabling Database DependenciesTaking Advantage of SQL Server DependenciesCache Dependencies in SQL Server 2005
Caching ASP.NET Pages
The @OutputCache DirectiveChoosing a Duration for the Page OutputChoosing a Location for the Page OutputAdding a Database Dependency to Page OutputThe HttpCachePolicy ClassProperties of the HttpCachePolicy ClassMethods of the HttpCachePolicy ClassServer Cache-Validation CallbackCaching Multiple Versions of a PageVary By ParametersDealing with Postback PagesVary By HeadersVary By Custom StringsCaching Portions of ASP.NET PagesWhat's a User Control, Anyway?Caching the Output of User ControlsVary by ControlsThe Shared AttributeFragment Caching in Cacheable PagesAdvanced Caching FeaturesCaching ProfilesPost-Cache Substitution
Conclusion
Just the Facts
17. ASP.NET Security
Where the Threats Come From
The ASP.NET Security Context
Who Really Runs My ASP.NET Application?IIS Thread Security ContextWorker Process Security ContextASP.NET Pipeline Security ContextChanging the Identity of the ASP.NET ProcessSetting the Process AccountImpersonating a Fixed IdentityImpersonating Through the Anonymous AccountPrivileges of the ASP.NET Default AccountThe Trust Level of ASP.NET ApplicationsThe <trust> SectionASP.NET PermissionsGranting Privileges Beyond the Trust LevelASP.NET Authentication MethodsWindows AuthenticationUsing ACLs to Authorize AccessPassport Authentication
Using Forms Authentication
Forms Authentication Control FlowCollecting Credentials Through LoginAuthenticating the UserSigning OutThe FormsAuthentication ClassProperties of the FormsAuthentication ClassMethods of the FormsAuthentication ClassConfiguration of Forms AuthenticationThe <forms> SectionCookie-Based Forms AuthenticationCookieless Forms AuthenticationOptions for Cookieless AuthenticationAdvanced Forms Authentication FeaturesApplications to Share Authentication CookiesExternal Applications to Authenticate UsersForms Authentication and Secured SocketsGeneral Security Issues
The Membership and Role Management API
The Membership ClassThe Programming Interface of the Membership ClassSetting Up Membership SupportValidating UsersManaging Users and PasswordsThe Membership ProviderThe ProviderBase ClassThe MembershipProvider ClassExtending the Provider's InterfaceA Custom Provider for ASP.NET 1.x CodeConfiguring a Membership ProviderManaging RolesThe Role Management APIThe Roles ClassThe Role Provider
Security-Related Controls
The Login ControlSetting Up the Login ControlThe Programming Interface of the ControlEvents of the ControlThe LoginName ControlThe LoginStatus ControlSetting Up the LoginStatus ControlThe Programming Interface of the ControlThe LoginView ControlThe Programming Interface of the ControlCreating a Login TemplateCreating Role-Based TemplatesThe PasswordRecovery ControlRequirements for Password RetrievalRetrieving a PasswordThe ChangePassword ControlUser AuthenticationPassword ChangeThe CreateUserWizard Control
Conclusion
Just the Facts
18. HTTP Handlers and Modules
Quick Overview of the IIS Extensibility APIThe ISAPI ModelIllustrious Children of the ISAPI ModelStructure of ISAPI ComponentsISAPI ExtensionsISAPI FiltersChanges in IIS 7.0A Unified Runtime EnvironmentManaged ISAPI Extensions and Filters
Writing HTTP Handlers
The IHttpHandler InterfaceMembers of the IHttpHandler InterfaceA Very Simple HTTP HandlerAn HTTP Handler for Quick Data ReportsBuilding a Query Manager ToolRegistering the HandlerRegistering the Handler with IIS 7.0The Picture Viewer HandlerDesigning the HTTP HandlerImplementing the HTTP HandlerServing Images More EffectivelyLoading Images from DatabasesServing Dynamically Generated ImagesWriting Copyright Notes on ImagesAdvanced HTTP Handler ProgrammingDeploying Handlers as ASHX ResourcesPrevent Access to Forbidden ResourcesShould It Be Reusable or Not?HTTP Handler FactoriesAsynchronous HandlersImplementing Asynchronous Handlers
Writing HTTP Modules
The IHttpModule InterfaceA Custom HTTP ModuleWiring Up EventsRegistering with the Configuration FileAccessing Other HTTP ModulesThe Page Refresh FeatureThe Rationale Behind Page Refresh OperationsOutline of the SolutionImplementation of the Solution
Conclusion
Just the Facts
IV. ASP.NET AJAX Extensions
19. Partial Rendering: The Easy Way to AJAX
The ASP.NET AJAX InfrastructureThe Hidden Engine of AJAXThe Classic Browser-Led ModelThe New Out-of-Band ModelThe Role of the HTML Document Object ModelFrom Dynamic HTML to the Standard DOMThe XMLHttpRequest ObjectUsing the XMLHttpRequest ObjectThe Microsoft AJAX JavaScript LibraryJavaScript Language ExtensionsObject-Oriented Extensions: NamespacesObject-Oriented Extensions: InheritanceObject-Oriented Extensions: InterfacesThe Application Core ComponentThe Network StackDOM EventsOther FacilitiesThe Script Manager ControlProperties of the ScriptManager ControlMethods of the ScriptManager ControlEvents of the ScriptManager ControlThe ScriptManagerProxy ControlScript Binding and LoadingHandling Debug and Release Script FilesLocalized ScriptsScript Globalization
Selective Page Updates with Partial Rendering
The UpdatePanel ControlThe UpdatePanel Control at a GlanceThe Programming Interface of the ControlPopulating the Panel ProgrammaticallyMaster Pages and Updatable RegionsUser Controls and Updatable RegionsOptimizing the Usage of the UpdatePanel ControlConfiguring for Conditional RefreshProgrammatic UpdatesUsing TriggersFull Postbacks from Inside Updatable PanelsPractical Steps for Adopting Updatable PanelsGiving Feedback to the UserThe UpdateProgress ControlComposing the Progress ScreenClient-Side Events for Richer FeedbackDisabling Visual Elements During UpdatesAborting a Pending UpdateLight and Shade of Partial RenderingIssues with Concurrent CallsIssues with Polling
The AJAX Control Toolkit
Enhancing Controls with ExtendersExtenders at a Glance: the TextBoxWatermark ControlCreating a New Extender ControlExtenders in the ACTControls in the ACTImproving the User Interface with Input ExtendersMotivation for Input FacilitiesThe Slider ExtenderThe NumericUpDown ExtenderThe FilteredTextBox ExtenderThe Calendar ExtenderThe MaskedEdit ExtenderThe AutoComplete ExtenderAdding Safe Popup Capabilities to Web PagesThe ModalPopup ExtenderThe PopupControl ExtenderThe HoverMenu ExtenderThe TabContainer Control
Conclusion
Just the Facts
20. AJAX-Enabled Web Services
Implementing the AJAX ParadigmMoving Away from Partial RenderingThe Flip Side of Partial RenderingThe ASP.NET AJAX Emerging ModelDesigning the –Client Layer of an ASP.NET AJAX ApplicationLimits of JavaScriptEnriching JavaScriptLimits of the HTML Markup LanguageWhat About AJAX-Specific Controls?Designing the –Server Layer of ASP.NET AJAX ApplicationsA Service-Oriented –Server-Side ArchitectureREST ServicesData SerializationJSON vs. XML
Web Services for ASP.NET AJAX Applications
Web Services as Application-Specific ServicesDefining the Remote APIImplementing the Contracted InterfacePublishing the ContractRemote Calls via Web ServicesCreating an AJAX Web ServiceThe ScriptService AttributeBlocking SOAP ClientsDefining Methods for a Web ServiceRegistering AJAX Web ServicesConfiguring ASP.NET Applications to Host AJAX Web ServicesConsuming AJAX Web ServicesThe Proxy ClassExecuting Remote CallsError HandlingGiving User FeedbackHandling TimeoutsConsiderations for AJAX-Enabled Web ServicesWhy Local Web Services?Why JSON-Based Web Services?Runtime Support for JSON-Based Web Services
WCF Services for ASP.NET AJAX Applications
Building a Simple WCF ServiceRewriting TimeService as a WCF ServiceRegistering the ServiceTesting the ServiceASP.NET Compatibility ModesBuilding a Less Simple ServiceThe Suggestions ServiceService Without ConfigurationData Contracts
Remote Calls via Page Methods
Introducing Page MethodsDefining a Page MethodEnabling Page MethodsWhy No Page Life Cycle?Consuming Page MethodsThe Proxy ClassExecuting Page MethodsPage Methods vs. AJAX-Enabled Services
Conclusion
Just the Facts
21. Silverlight and Rich Internet Applications
Silverlight Fast FactsVersions of SilverlightSilverlight 1.0Silverlight 2.0Silverlight and FlashProgrammabilityReach and AdoptionAudio/VideoAnimation and Graphics
Hosting Silverlight in Web Pages
The Silverlight EngineThe Silverlight ObjectThe Script-Behind FileEmbedding the Silverlight ObjectChecking the Installed VersionInstantiating the Silverlight ObjectInitialization of the Plug-inError HandlingDefining XAML ContentDownloading XAML DocumentsInline XAMLDynamically Generated XAMLThe XAML Syntax in SilverlightSyntax HighlightsThe Canvas ObjectGraphics and ShapesClipping and TransformingAnimationTextMultimedia
The Silverlight Object Model
Silverlight Programming FundamentalsReferencing ObjectsThe Silverlight Eventing ModelWriting Event HandlersAccessing Properties of XAML ElementsScripting and Animation TogetherResizing the Silverlight AreaIntroducing Silverlight 2.0The Visual Studio 2008 Template ProjectThe XAML Code-Behind ClassThe Object ModelReading and Writing PropertiesAccessing the HTML DOM
Conclusion
Just the Facts
SPECIAL OFFER: Upgrade this ebook with O’Reilly

Content preview from Programming Microsoft® ASP.NET 3.5

The ASP.NET Provider Model

There's a well-known design pattern behind the ASP.NET provider model—the strategy pattern. Defined, the strategy pattern indicates an expected behavior (say, sorting) that can be implemented through a variety of interchangeable algorithms (say, Quicksort or Mergesort). Each application then selects the algorithm that best fits while keeping the public, observable behavior and programming API intact.

The most notable feature of the strategy pattern is that it provides a way for an object, or an entire subsystem, to expose its internals so that a client can unplug the default implementation of a given feature and plug his own in. This is exactly what happens in ASP.NET for a number of services, including membership, roles, ...

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

ASP.NET 3.5 Website Programming: Problem-Design-Solution

Publisher Resources

ISBN: 9780735625273Catalog Page Errata

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Programming Microsoft® ASP.NET 3.5

by Dino Esposito

The ASP.NET Provider Model

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.