book

Programming Microsoft® ASP.NET 4

Name: Programming Microsoft® ASP.NET 4
Author: Dino Esposito
ISBN: 9780735660144

by Dino Esposito

February 2011

Intermediate to advanced

992 pages

32h 32m

English

Microsoft Press

Read now

Unlock full access

Programming Microsoft® ASP.NET 4
Dedication
Acknowledgments
Introduction
Who Should Read This Book?System RequirementsCode SamplesErrata & Book SupportWe Want to Hear from YouStay in Touch
I. The ASP.NET Runtime Environment
1. ASP.NET Web Forms Today
The Age of Reason of ASP.NET Web FormsThe Original StrengthsPage PostbacksThe View StateServer ControlsToday’s Perceived WeaknessesMore Control over HTMLSeparation Between Processing and RenderingLightweight PagesHow Much Is the Framework and How Much Is It You?The Page Controller PatternRevisiting the Page Controller PatternThe AJAX RevolutionMoving Away from Classic ASP.NETWhat’s a Paradigm Shift?The AJAX Paradigm ShiftThe Data-for-Data ModelWhat Web Do We Want for Developers?AJAX as a Built-in Feature of the WebSelective UpdatesDirect ScriptingASP.NET of the FutureASP.NET MVCASP.NET MVC HighlightsA Runtime for TwoControl over MarkupASP.NET MVC and SimplicityASP.NET Web PagesSmall, Simple, and SeamlessCode and View TogetherSummary
2. ASP.NET and IIS
The Web Server EnvironmentA Brief History of ASP.NET and IISThe Standalone ASP.NET Worker ProcessThe IIS Native Worker ProcessA Shared Pipeline of ComponentsThe Journey of an HTTP Request in IISEvents in the Request Life CycleASP.NET Request Processing in Integrated Pipeline ModeBuilding a Response for the RequestAdding Your Own Code to the PipelineSome New Features in IIS 7.5Autostarting Web ApplicationsApplication Pool Custom IdentitiesDeploying ASP.NET ApplicationsXCopy Deployment for Web SitesThe Copy Web Site Function of Visual Studio 2010Copying FilesBuilding a Setup ProjectPackaging Files and SettingsThe Web Deployment ToolBuilding a WDT PackagePropagating IIS SettingsWeb.config TransformationsSite PrecompilationIn-Place PrecompilationPrecompilation for DeploymentConfiguring IIS for ASP.NET ApplicationsRecycling PoliciesUnexpected RestartsOutput Caching SettingsApplication Warm-up and PreloadingBehavior of a Warmed-up Application PoolSetting Up the Application PoolSpecifying the Warm-up CodeSummary
3. ASP.NET Configuration
The ASP.NET Configuration HierarchyConfiguration FilesThe Tree of Configuration FilesThe Configuration SchemaSections and Section GroupsThe <location> SectionCentralized ConfigurationMachinewide SettingsUnmodifiable SettingsThe <system.web> SectionThe <anonymousIdentification> SectionThe <authentication> SectionThe <authorization> SectionThe <browserCaps> SectionThe <caching> SectionThe <customErrors> SectionThe <deployment> SectionThe <globalization> SectionThe <httpHandlers> SectionThe <httpModules> SectionThe <healthMonitoring> SectionThe <hostingEnvironment> SectionThe <httpCookies> SectionThe <httpRuntime> SectionThe <identity> SectionThe <machineKey> SectionThe <membership> SectionThe <pages> SectionThe <processModel> SectionThe <profile> SectionThe <roleManager> SectionThe <securityPolicy> SectionThe <sessionState>SectionThe <siteMap> SectionThe <trace> SectionThe <trust> SectionThe <urlMappings> SectionThe <webControls> SectionThe <xhtmlConformance> SectionOther Top-Level SectionsThe <appSettings> SectionThe <connectionStrings> SectionThe <configProtectedData> SectionThe <system.web.extensions> SectionThe <system.webServer> SectionManaging Configuration DataUsing the Configuration APIRetrieving Web Configuration SettingsRetrieving Application SettingsUpdating Application SettingsEncrypting a SectionUsing a Command-Line ToolUsing a Programmatic ApproachChoosing the Encryption ProviderCreating Custom Configuration SectionsSummary
4. HTTP Handlers, Modules, and Routing
Writing HTTP HandlersThe IHttpHandler InterfaceMembers of the IHttpHandler InterfaceA Very Simple HTTP HandlerRegistering the HandlerPreconditions for Managed HandlersHandlers Serving New Types of ResourcesThe Picture Viewer HandlerDesigning the HTTP HandlerImplementing the HTTP HandlerServing Images More EffectivelyLoading Images from DatabasesServing Dynamically Generated ImagesWriting Copyright Notes on ImagesControlling Images via an HTTP HandlerAdvanced HTTP Handler ProgrammingDeploying Handlers as ASHX ResourcesPrevent Access to Forbidden ResourcesShould It Be Reusable or Not?HTTP Handler FactoriesAsynchronous HandlersImplementing Asynchronous HandlersWriting HTTP ModulesThe IHttpModule InterfaceA Custom HTTP ModuleWiring Up EventsRegistering with the Configuration FileAccessing Other HTTP ModulesExamining a Real-World HTTP ModuleThe UrlRoutingModule ClassThe PostResolveRequestCache EventURL RoutingThe URL Routing EngineOriginal URL Rewriting APIURL Patterns and RoutesRouting in Web FormsDefining Routes for Specific PagesProgrammatic Access to Route ValuesStructure of RoutesPreventing Routing for Defined URLsSummary
II. ASP.NET Pages and Server Controls

5. Anatomy of an ASP.NET Page
Invoking a PageThe Runtime MachineryResource MappingsRepresenting the Requested PagePartial Classes in ASP.NET ProjectsProcessing the RequestThe HttpRuntime ClassThe Application FactoryThe HttpApplication ObjectThe Page FactoryThe Processing Directives of a PageThe @Page DirectiveThe @Assembly DirectiveThe @Import DirectiveThe @Implements DirectiveThe @Reference DirectiveThe Page ClassProperties 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 ApproachAsync-Compliant OperationsThe Page Life CyclePage 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 EventSummary
6. ASP.NET Core Server Controls
Generalities of ASP.NET Server ControlsProperties of the Control ClassIdentifying a Server ControlClient ID ModesASP.NET Control ContainersView State of ControlsVisibility of a Server ControlMethods of the Control ClassEvents of the Control ClassOther FeaturesAdaptive RenderingGetting CSS-Friendly HTMLBrowser-Sensitive RenderingThemeable ControlsHTML ControlsGeneralities of HTML ControlsThe HtmlControl Base ClassWorking with HTML AttributesHierarchy of HTML ControlsHTML Container ControlsManaging Header InformationLinking External CSS FilesManaging Meta InformationNavigating to a URLHandling Events on the ServerThe HtmlSelect ControlThe HtmlTextArea ControlHTML Input ControlsCommand ButtonsControlling ValidationDetecting State Changes of ControlsUploading FilesThe HtmlImage ControlWeb ControlsGeneralities 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 ButtonsText ControlsHidden Fields and File UploadMiscellaneous Web ControlsThe AdRotator ControlThe Calendar ControlThe Xml ControlThe PlaceHolder ControlView ControlsSummary
7. Working with the Page
Dealing with Errors in ASP.NET PagesBasics of Exception HandlingExceptions in ActionGuidelines for Exception HandlingBasics of Page Error HandlingDefault Error PagesPage-Level Error HandlingGlobal Error HandlingLogging ExceptionsRobust Error HandlingMapping Errors to PagesThe <customErrors> SectionUsing Custom Error PagesHandling Common HTTP ErrorsGetting Information About the ExceptionError ReportingFeatures of an Error Reporting SystemError Reporting ToolsSelf-Logging ExceptionsPage PersonalizationCreating the User ProfileDefinition of the Data Model in a Web Site ProjectThe User Profile Class RepresentationUsing Collection TypesUsing Custom TypesGrouping PropertiesDefinition of the Data Model in a WAP ProjectInteracting with the PageCreating the Profile DatabaseWorking with Anonymous UsersAccessing Profile PropertiesUser Profiles in ActionPersonalization EventsMigrating Anonymous DataProfile ProvidersConfiguring Profile ProvidersStructure of AspNetDb.mdfCustom Profile ProvidersPage LocalizationMaking Resources LocalizableGlobal and Local ResourcesUsing Resources: Declarative vs. ProgrammaticDealing with Global ResourcesDealing with Local ResourcesResources and CulturesSetting the Current Culture in .NET ApplicationsSetting the Current Culture in ASP.NET PagesChanging Culture on the FlyAdding Resources to PagesUsing Script FilesScripts at the Bottom of the PageUsing a Content Delivery NetworkReasons for Minifying a Script FileLocalized ScriptsUsing Cascading Style Sheets and ImagesGrouping Images into SpritesExternal References vs. Inline ContentSummary
8. Page Composition and Usability
Page Composition ChecklistWorking with Master PagesWhat’s a Master Page, Anyway?The @Master DirectiveThe ContentPlaceHolder Container ControlSpecifying Default ContentWriting a Content PageThe Content ControlContent Pages and Auxiliary ContentAttaching Pages to a MasterDevice-Specific MastersProcessing 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 DynamicallyStyling ASP.NET PagesWhat’s a Theme, Anyway?Structure of a ThemeTheming Pages and ControlsApplying SkinsTaking Control of ThemingLoading Themes DynamicallyPage Usability ChecklistCross-Browser RenderingDetecting Browser CapabilitiesBrowser Definition FilesBrowser Capabilities ProvidersSearch Engine OptimizationQuick SEO ChecklistSEO and ASP.NETTools for Measuring SEO LevelSite NavigationDefining Site Map InformationSite Map ProvidersThe SiteMap ClassThe SiteMapPath ControlConfiguring the Site MapUsing Multiple Site Map FilesSecuring ASP.NET Site MapsLocalizing Site Map InformationLocalizing the Site Navigation StructureTesting the PageTesting the Logic of the PageTesting the Client-Side Behavior of the PageTesting Posted DataSummary
9. ASP.NET Input Forms
Programming with FormsThe HtmlForm ClassProperties of the HtmlForm ClassMethods of the HtmlForm ClassMultiple FormsUsing HTML FormsNested HTML FormsMultiple Server <form> Tags on a PageMultiple View and WizardsCross-Page PostingsPosting Data to Another PageThe @PreviousPageType DirectiveDetecting Cross-Page PostingsRedirecting Users to Another PageValidation ControlsGeneralities of Validation ControlsThe BaseValidator ClassAssociating Validators with Input ControlsGallery of ControlsThe CompareValidator ControlThe CustomValidator ControlThe RegularExpressionValidator ControlThe RangeValidator ControlThe RequiredFieldValidator ControlSpecial CapabilitiesServer-Side ValidationDisplaying Error InformationMultiple Validators per ControlThe ValidationSummary ControlEnabling Client ValidationValidation GroupsDealing with Validation in Cross-Page PostsWorking with WizardsAn 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 WizardSummary
10. Data Binding
Foundation of the Data Binding ModelFeasible Data SourcesCollection ClassesADO.NET ClassesQueryable ObjectsData-Binding PropertiesThe DataSource PropertyThe DataSourceID PropertyThe DataMember PropertyThe DataTextField PropertyThe DataValueField PropertyThe AppendDataBoundItems PropertyThe DataKeyField PropertyData-Bound ControlsList ControlsThe DropDownList ControlThe CheckBoxList ControlThe RadioButtonList ControlThe ListBox ControlThe BulletedList ControlIterative ControlsThe Repeater ControlThe DataList ControlThe DataGrid ControlView ControlsThe DetailsView ControlThe FormView ControlThe GridView ControlThe ListView ControlData-Binding ExpressionsSimple Data BindingBinding in ActionImplementation of Data-Binding ExpressionsThe DataBinder ClassThe Eval MethodA More Compact EvalGetting the Default Data ItemManaging Tables of DataThe GridView’s Object ModelEvents of the GridView ControlBinding Data to the GridConfiguring ColumnsBound FieldsButton FieldsHyperlink FieldsCheck Box FieldsImage FieldsTemplated FieldsWorking with the GridViewPaging DataSorting DataEditing DataData Source ComponentsInternals of Data Source ControlsData Source ViewsHierarchical Data Source ViewsThe ObjectDataSource ControlProgramming Interface of ObjectDataSourceImplementing Data RetrievalUsing ParametersCaching Data and Object InstancesSetting Up for PagingUpdating and Deleting DataConfiguring Parameters at RuntimeSummary
11. The ListView Control
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 SheetsWorking with the ListView ControlIn-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 ListSummary
12. Custom Controls
Extending Existing ControlsChoosing a Base ClassInheriting from a Base ClassExtending a Base ClassA Richer HyperLink ControlDesigning a Usage ScenarioA Redirector for the HyperLink ControlBuilding Controls from ScratchBase Class and InterfacesControl vs. WebControlRelated InterfacesChoosing a Rendering StyleThe Render MethodBuilding the Control TreeThe SimpleGaugeBar ControlDefining the Object ModelImplementing the Object ModelSetting Up the RulerSetting Up the Control’s SiteRendering the SimpleGaugeBar ControlGenerating the HTML for a Custom ControlUsing Child Controls for RenderingThe Gauge in ActionBuilding a Data-Bound ControlKey FeaturesAdding Data-Bound PropertiesAdding a Data Item PropertyOverriding the PerformDataBinding MethodThe GaugeBar ControlMapping Data Source Fields to Control PropertiesThe GaugeBar’s Data Item ObjectData Item and View StateAd Hoc View-State ManagementGetting Bound DataBuilding a Composite Templated ControlGeneralities of Composite Data-Bound ControlsCreating a Hierarchy of Child ControlsThe Overloaded CreateChildControlsThe Control ItemThe BarChart ControlThe BarChart Item ObjectAdding Bound DataEvents of the BarChart ControlUsing the BarChart ControlAdding Template SupportTemplates and User ControlsDefining a Template PropertyDefining a Template ContainerSetting a Template PropertyRendering a TemplateSummary
III. Design of the Application
13. Principles of Software Design
The Big Ball of MudReasons for the MudLimited SkillsRequirements ChurnMembers TurnoverAlarming SymptomsMake a Change Here, Break the Code ThereEasier to Use Than to ReuseEasier to Work Around Than to FixUniversal Software PrinciplesCohesion and CouplingCohesion at a GlanceCoupling at a GlanceSeparation of ConcernsIdentifying the ConcernsModularityInformation HidingSOLID PrinciplesThe Single Responsibility PrincipleSRP Canonical ExampleSRP Real-World ConsiderationsThe Open/Closed PrincipleOCP Canonical ExampleOCP Real-World ConsiderationsLiskov’s Substitution PrincipleSubstitution Principle Canonical ExampleSubstitution Principle Real-World ConsiderationsThe Interface Segregation PrincipleInterface Segregation Canonical ExampleInterface Segregation Real-World ConsiderationsThe Dependency Inversion PrincipleDependency Inversion Canonical ExampleDependency Inversion Real-World ConsiderationsTools for Dependency InjectionManaged Extensibility Framework at a GlanceMEF vs. IoCShould You Choose MEF or an IoC?MEF in ActionUnity at a GlanceRegistering Types and InstancesResolving DependenciesDeclarative ConfigurationLifetime ManagersSummary
14. Layers of an Application
A Multitiered ArchitectureThe Overall DesignMethodologiesThe Business LayerDesign Patterns for the BLLThe Transaction Script PatternThe Table Module PatternThe Active Record PatternThe Domain Model PatternThe Application LogicThe Service Layer PatternWhen the Application Logic Is Deployed RemotelyExposing Entities to the Presentation LayerData Transfer ObjectsThe Data Access LayerImplementation of a DALDAL and the Table Module PatternDAL and the Active Record PatternDAL and the Domain Model PatternInterfacing the DALSupport for Multiple DatabasesThe Repository PatternUsing an Object/Relational MapperLINQ-to-SQLEntity FrameworkNHibernateO/RM Tools and SQL CodeBeyond Classic DatabasesGoing to the CloudMicrosoft Dynamics CRM 2011Schema-less StorageSummary
15. The Model-View-Presenter Pattern
Patterns for the Presentation LayerThe MVC PatternGeneralities of the MVC PatternRole of the ModelRole of the ViewRole of the ControllerWeb Forms and the MVC PatternThe MVP PatternGeneralities of the MVP PatternRole of the ModelRole of the ViewRole of the PresenterWeb Forms and the MVP PatternThe MVVM PatternGeneralities of the MVVM PatternWeb Forms and MVVMImplementing Model View PresenterAbstracting the ViewFrom Use-Cases to the ViewImplementing the InterfaceCreating the PresenterGetting a Presenter’s InstanceUsing the PresenterHow Does the Presenter Retrieve Data?Connecting the Presenter to the Service LayerPresenter in ActionSharing the Presenter with a Windows ApplicationNavigationThe Application Controller PatternDefining the Navigation WorkflowNavigating Within a Web Forms SiteTestability in Web Forms with MVPWriting Testable CodeAspects of Testable CodeUnit TestingTest-Driven DevelopmentTesting a Presenter ClassCreating a Unit TestTesting Presenters in IsolationSummary
IV. Infrastructure of the Application
16. The HTTP Request Context
Initialization of the ApplicationProperties of the HttpApplication ClassApplication ModulesMethods of the HttpApplication ClassEvents of the HttpApplication ClassThe global.asax FileCompiling global.asaxSyntax of global.asaxApplication DirectivesCode Declaration BlocksServer-Side <object> TagsStatic PropertiesThe HttpContext ClassProperties of the HttpContext ClassMethods of the HttpContext ClassURL RewritingLoading Resources ProgrammaticallyThe Server ObjectProperties of the HttpServerUtility ClassMethods of the HttpServerUtility ClassEmbedding Another Page’s ResultsServer-Side RedirectionThe HttpResponse ObjectProperties of the HttpResponse ClassSetting the Response Cache PolicySetting an Output FilterMethods of the HttpResponse ClassOutput Caching FeaturesLarge File TransmissionThe HttpRequest ObjectProperties of the HttpRequest ClassInformation About the RequestInformation from the ClientInformation About the ConnectionMethods of the HttpRequest ClassSaving the Request to DiskValidating Client InputSummary
17. ASP.NET State Management
The Application’s StateProperties of the HttpApplicationState ClassMethods of the HttpApplicationState ClassState SynchronizationTradeoffs of Application StateThe Session’s StateThe Session-State HTTP ModuleState Client ManagersCreating the HttpSessionState ObjectSynchronizing Access to the Session StateProperties of the HttpSessionState ClassMethods of the HttpSessionState ClassWorking with a Session’s StateIdentifying a SessionGenerating the Session IDSession CookiesCookieless SessionsIssues with Cookieless SessionsCookieless Sessions and SecurityCookieless Sessions and SEOConfiguring 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 IdentityCustomizing Session State ManagementBuilding 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 ManagerThe View State of a PageThe StateBag ClassView State PropertiesView State MethodsCommon Issues with View StateEncrypting and SecuringMachine Authentication CheckSize Thresholds and Page ThroughputProgramming the View StateDisabling View StateDetermining When to Disable View StateThe Control StateProgramming the Control StateKeeping the View State on the ServerSummary
18. ASP.NET Caching
Caching Application DataThe Cache ClassFundamental Aspects of the Cache ObjectProperties 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 ObjectClearing the CacheCache SynchronizationPer-Request CachingDesigning a Custom DependencyExtensions to the CacheDependency Base ClassGetting Change NotificationsThe AggregateCacheDependency ClassA Cache Dependency for XML DataDesigning the XmlDataCacheDependency ClassImplementing the DependencyTesting the Custom DependencySQL Server Cache DependencyTaking Advantage of SQL Server DependenciesDistributed CacheFeatures of a Distributed CacheHigh AvailabilityTopologyFreshness of DataIntegration with the Data Access LayerAppFabric Caching ServicesFast FactsArchitecture of Caching ServicesClient-Side Configuration of Caching ServicesProgramming Caching ServicesOther SolutionsMemcachedSharedCacheCommercial SolutionsCaching ASP.NET PagesASP.NET and the Browser CacheTypical Behavior of the Browser CacheTypical Behavior of an ASP.NET PageTypical Behavior of Static ResourcesMaking ASP.NET Pages CacheableThe @OutputCache DirectiveChoosing a Location for the Page OutputChoosing a Duration for ASP.NET Page OutputIIS Kernel CachingAdding 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 SubstitutionOutput Cache ProvidersSummary
19. ASP.NET Security
Where the Threats Come FromThe ASP.NET Security ContextWho 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 AccessWindows CardSpaceUsing Forms AuthenticationForms 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 IssuesCreating a Custom PrincipalThe Membership and Role Management APIThe 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 Legacy CodeConfiguring a Membership ProviderManaging RolesThe Role Management APIThe Roles ClassThe Role ProviderQuick Tour of Claims-Based IdentityClaims-Based IdentityClaims and Identity ProvidersThe Authentication WorkflowClaims and PoliciesUsing Claims in ASP.NET ApplicationsPicking Up the STSConfiguring the ASP.NET ApplicationSecurity-Related ControlsThe 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 ControlSummary
V. The Client Side
20. Ajax Programming
The Ajax InfrastructureThe Hidden Engine of AjaxThe Classic Browser-Led ModelThe New Out-of-Band ModelFrom Dynamic HTML to the Standard DOMThe XMLHttpRequest ObjectUsing the XMLHttpRequest ObjectJavaScript and AjaxFunctional Programming in JavaScriptObjects in JavaScriptUsing ClosuresUsing PrototypesCross-Domain AjaxPartial Rendering in ASP.NETThe ScriptManager ControlProperties of the ScriptManager ControlMethods of the ScriptManager ControlEvents of the ScriptManager ControlThe ScriptManagerProxy ControlScript Binding and LoadingHandling Debug and Release Script FilesScript GlobalizationThe UpdatePanel ControlThe UpdatePanel Control at a GlanceThe Programming Interface of the ControlPopulating the Panel ProgrammaticallyMaster Pages and Updatable RegionsConsiderations Regarding Partial RenderingConfiguring for Conditional RefreshDetecting Postbacks from Child ControlsProgrammatic UpdatesUsing TriggersFull Postbacks from Inside Updatable PanelsGiving Feedback to the UserThe UpdateProgress ControlComposing the Progress ScreenClient-Side Events for Richer FeedbackDisabling Visual Elements During UpdatesAborting a Pending UpdateThe Ins and Outs of Partial RenderingIssues with Concurrent CallsIssues with PollingREST and AjaxScriptable ServicesThe HTTP FaçadeWCF ServicesASP.NET Web ServicesDiscriminate Against OutsidersTrusting the HTTP FaçadeJSON PayloadsJSON at a GlanceData ContractsWhy JSON Is Preferable to XMLJavaScript Client CodeGetting a Proxy for the HTTP FaçadeUsing the ProxyRemote Calls via Page MethodsSummary
21. jQuery Programming
Power to the ClientProgramming within the BrowserOriginal Goals of the LanguageThe Scripting EngineFlaws and WorkaroundsWhat You Write JavaScript Code ForThe Gist of jQueryDetails of the LibraryThe Root ObjectjQuery and Functional ProgrammingWorking with jQueryDetecting DOM ReadinessThe DOM ReadyState PropertyThe jQuery’s Ready FunctionOnload vs. ReadyWrapped SetsEnumerating the ContentBasic SelectorsCompound SelectorsPredefined FiltersForm FiltersFilter vs. FindOperating on a Wrapped SetControlling VisibilityStylingBinding and Unbinding EventsLive Event BindingManipulating the DOMCreating a DOM TreeAdding Elements to the DOMRemoving DOM ElementsModifying DOM ElementsThe jQuery CacheCached Data and DOM ElementsWorking with Data in the In-Memory CacheAjax CapabilitiesPlain Ajax CallerGlobal Ajax Event HandlersGetting ScriptsGetting JSONGetting HTMLCross-Domain CallsCross-Domain HTML TagsBasics of JSONPJSONP in jQuerySummary
Index
About the Author
Copyright

Overview

Completely reengineered for ASP.NET 4—this definitive guide deftly illuminates the core architecture and programming features of ASP.NET 4 in a single, pragmatic volume. Web development expert Dino Esposito provides essential, architectural-level guidance, along with the in-depth technical insights designed to take you—and your solutions—to the next level. The book covers Dynamic Data, AJAX, Microsoft Silverlight, ASP.NET MVC, Web forms, LINQ, and security strategies—and features extensive code samples in Microsoft Visual C#(R) 2010.

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

Publisher Resources

ISBN: 9780735660144Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills