book

Programming Microsoft® ASP.NET

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

by Dino Esposito

June 2003

Intermediate to advanced

1200 pages

29h 31m

English

Microsoft Press

Read now

Unlock full access

Copyright
Dedication
Acknowledgments
Introduction
What Does This Book Cover?System RequirementsCode SamplesHow to Touch BaseMicrosoft Press Support
About the Author
Dino Esposito
I. Building an ASP.NET Page
1. The Web Forms 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 FormsThe Structure of ASP.NET PagesA Sample ASP.NET PageThe Processing Directives of a PageThe @Page DirectiveThe @Assembly DirectiveThe @Import DirectiveThe @Implements DirectiveThe @Reference DirectiveThe <script> SectionThe Language AttributeThe Src AttributeASP-Style Code Blocks in ASP.NETThe Layout SectionThe ASP.NET Component ModelA Model for Component InteractionThe runat AttributeWorking with Server-Side ControlsPagewide TagsMeta TagsUnknown TagsASP.NET Server ControlsMigrating from ASP to ASP.NETSide-by-Side ExecutionRewriting ASP Pages as ASP.NET PagesSuggested Migration PlansSame Application, New PagesNew Application, Same Framework, New PagesSame Application, New Presentation LayerSetting Up ASP.NET ApplicationsCreating a Visual Studio ProjectThe Project FilesCreating the Web Forms PageBuilding and DebuggingDeploying the ApplicationMultilanguage Projects with Visual Studio .NETThe CodeBehind Attribute in Visual Studio .NETVisual Studio CodeBehind vs. ASP.NET SrcThe Web Matrix EditorVisual Studio .NET vs. Web MatrixWhat Web Matrix Doesn't ProvideWhat Web Matrix Does ProvideHelp and CommunityConclusionResources
2. Web Forms Internals
Executing ASP.NET PagesThe IIS Resource MappingsThe ASP.NET Worker ProcessHow the ASP.NET Runtime WorksProcess RecyclingProcess Recycling in IIS 6.0Configuring the ASP.NET Worker ProcessAbout the Web Garden ModelThe ASP.NET HTTP PipelineThe HttpRuntime ObjectThe Application FactoryThe HttpApplication ObjectThe Handler FactoryThe ASP.NET Page Factory ObjectLocating the Assembly for the PageDetecting Page ChangesHow ASP.NET Replaces Page AssembliesBatch CompilationHow ASP.NET Creates a Class for the PageReviewing the Class Source CodeProcessing the Page RequestThe Page Life CyclePage-Related EventsThe Event ModelThe Single Form ModelAuto-Reentrant Web PagesThe View State of the PagePostback EventsState RestorationHandling the Server-Side EventRendering Back the PageThe Page ClassProperties of the Page ObjectMethods of the Page ObjectEvents of the Page ObjectThe Code-Behind TechniqueCode and Layout SeparationCode-Behind in Visual Studio .NETCode-Behind in Action at Run TimeMoving to Code-BehindPage InheritanceA Server-Side Abstraction for Client-Side EventsA Better Page ClassProgrammatically Set the Input FocusChanging the Default Page Base TypeMaster Pages in ASP.NETConclusionResources
3. ASP.NET Core Server Controls
Generalities of ASP.NET Server ControlsProperties of the Control ClassssIdentifying a Server ControlVisibility of a Server ControlMethods of the Control ClassEvents of the Control ClassHTML ControlsGeneralities of HTML ControlsThe HtmlControl Base ClassWorking with HTML AttributesHierarchy of HTML ControlsHTML Container ControlsNavigating to a URLHandling Events on the ServerThe HtmlSelect ControlHTML TablesThe HtmlTextArea ControlHTML Input ControlsCommand ButtonsControlling ValidationDetecting State Changes of ControlsUploading FilesThe HtmlImage ControlWeb ControlsGeneralities of Web ControlsProperties of Web ControlsStyling a Web ControlMethods of Web ControlsCore Web ControlsImages and Image ButtonsCheck Boxes and Radio ButtonsHyperLinksMiscellaneous Web ControlsThe AdRotator ControlThe Calendar ControlThe Xml ControlThe PlaceHolder ControlValidation ControlsTypes of Validation ControlsThe BaseValidator ClassAssociating Validators with Input ControlsThe CompareValidator ControlThe CustomValidator ControlThe RegularExpressionValidator ControlThe RangeValidator ControlThe RequiredFieldValidator ControlSetting Up a Data Entry PageDisplaying Error InformationThe ValidationSummary ControlValidating for Multiple ConditionsClient-Side ValidationEnabling Client ValidationImplementing Client ValidationData-Bound ControlsFeasible Data-Binding SourcesADO.NET ClassesCollection-Based ClassesSimple Data BindingSimple Data Binding in ActionImplementation of Data-Bound ExpressionsComplex Data BindingThe DropDownList ControlThe CheckBoxList ControlThe RadioButtonList ControlThe ListBox ControlConclusionResources
4. Working with the Page
Programming with FormsThe HtmlForm ClassProperties of the HtmlForm ClassMethods of the HtmlForm ClassMultiple FormsToggling the Control's VisibilityMultiple <form> Tags on a PagePassing Variables Across PagesReferencing Referrer PagesRetrieving ValuesPop-Up FormsClient Modal DialogsUsing Embedded FormsWorking with Script CodeSupporting Multiple BrowsersAdding Client-Side ScriptsRegistering Script BlocksRegistering Startup Script BlocksRegistering Hidden FieldsPage LocalizationCulture and LocalesProgramming CulturesInvariant and Neutral CulturesThe ASP.NET Resource ManagerCreating Satellite AssembliesRetrieving Localized InformationPage Errors and TracingDefining Custom Error PagesUsing Custom Error PagesHTTP ErrorsTracing the Execution Flow in .NETThe Listener ObjectRegistering and Configuring ListenersASP.NET TracingEnabling Page TracingEmitting Trace MessagesTracing from External ClassesThe Trace ViewerConclusionResources
II. Adding Data in an ASP.NET Site

5. The ADO.NET Object Model
The .NET Data Access LayerArchitecture of a .NET Managed ProviderManaged Providers vs. OLE DB ProvidersData Providers Available in the .NET FrameworkAlternative Ways of Exposing DataData Sources You Access Through ADO.NETAccessing SQL ServerAccessing Oracle DatabasesUsing OLE DB ProvidersUsing ODBC DriversAccessing Other Data SourcesConnecting to Data SourcesThe SqlConnection ClassConfiguring Connection PropertiesSecure ConnectionsConnection PoolingConfiguring PoolingGetting and Releasing ObjectsGeneric Database ProgrammingOther Connection ObjectsOracle ConnectionsOLE DB ConnectionsODBC ConnectionsExecuting CommandsThe SqlCommand ClassUsing ParametersWays to ExecuteSetting Up TransactionsOther Command ObjectsOracle CommandsOLE DB CommandsODBC CommandsADO.NET Data ReadersReading Data with the Data ReaderCommand BehaviorsClosing the ReaderAccessing Multiple Result SetsObtaining Schema InformationSpecial Features of Data ReadersOracle Data ReadersOLE DB Data ReadersADO.NET Data AdaptersThe SqlDataAdapter ClassProgramming the SQL Server Data AdapterFilling a DataSet Using a Data AdapterThe Table-Mapping MechanismThe Column-Mapping MechanismMissing Mapping ActionMissing Schema ActionPrefilling the SchemaHow Batch Update WorksData Conflicts and Optimistic LockCommand BuildersADO.NET Container ObjectsThe DataSet ObjectMerging DataSet ObjectsThe DataSet Commit ModelSerializing Contents to XMLThe DataTable ObjectPerforming ComputationsColumns of a TableRows of a TableTable ConstraintsData RelationsCreating a Data RelationPerforming Calculations on RelationsSerializing a Data RelationThe DataView ObjectNavigating the ViewFinding RowsConclusionResources
6. Creating Bindable Grids of Data
The DataGrid ControlProperties of the DataGrid ControlConstituent Elements of a DataGridData Source Rows and Displayed RowsEvents of the DataGrid ControlThe DataGridItem ObjectThe Data-Binding Process for the DataGrid ControlItemCreated and ItemDataBound EventsWhy Is ItemCreated Raised Twice?Binding Data to the GridData-Bound ColumnsConfiguring the Column FooterUsing Cascading Style Sheets StylesHyperLink ColumnsFormatting URLs and Column NamesUsing FramesBindable ToolTipsCommand ColumnsHandling a User's ClickingImplementing a Simple Shopping CartThe Select Button ColumnEnhancing the DataGridPaging the Grid ContentCaching the Data SourceBuilt-In Paging SupportCustomizing the Pager ComponentSorting the DataAuto-Reverse SortingProviding Feedback About SortingTemplated ColumnsAvailable TemplatesCombining Multiple-Source ColumnsUsing Multiple Arguments with HyperLink ColumnsEnhancing the Shopping Cart ApplicationDataGrid In-Place EditingConfiguring the Built-In Edit EngineSetting Up the Template of the RowValidation and Edit TemplatesPersisting ChangesRetrieving Input ValuesUpdating the Data SourceConclusionResources
7. Paging Through Data Sources
Custom Paging with DataGrid ControlsEnabling Custom PaginationSetting the Virtual Item CountPaging Using Key ValuesShortcomings of the Key-Based ApproachNext/Previous NavigationDefining the SQL CodeMoving to the Previous RecordMoving to the Next RecordSetting Up the Next/Previous NavigationSelecting Records in OracleAdding First and Last ButtonsCreating Link Buttons DynamicallySetting the Click HandlerAdding ToolTips to the PagerRandom Page NavigationSelecting a Specified Page of RecordsCustomizing the Structure of the PagerBuilding a Completely Customized Personal PagerLogical NavigationChanging the Pager's PerspectiveIs the DataGrid Appropriate for the Task?Configuring the DataGridBinding the Data SourceModifying the Pager BarSelecting the Page's RowsConclusionResources
8. Real-World Data Access
Compound CommandsConducting Multiple QueriesUsing Joined QueriesUsing Distinct QueriesRespecting Data IntegrityConducting Cross-Table UpdatesCascading ChangesThe Batch UpdateDetecting and Resolving Update ConflictsStored Procedures in Batch UpdatesUsing Transactions in Batch UpdatesRetrieving Server-Generated ValuesData Reporting and SubtotalsSummarizing or Aggregating ValuesThe WITH ROLLUP OperatorA Pure ADO.NET ApproachSetting Up the DataGridFormatting the Summary RowSetting Up the FooterAdding Statistical InformationMaster/Detail ViewsListing the CustomersCustom Paging and SortingThe Selection MechanismUsing Inline FramesListing the OrdersSmart CachingAdding Templated ColumnsListing the Order DetailsConclusionResources
III. ASP.NET Controls
9. ASP.NET Iterative Controls
What's an Iterative Control, Anyway?Iterative Controls vs. List ControlsIterative Controls vs. the DataGrid ControlThe Repeater ControlProgramming Interface of the Repeater ControlBinding a Repeater to DataHow the Repeater Builds the OutputTemplates of the Repeater ControlThe ITemplate InterfaceCreating Templates ProgrammaticallyWorking with the Repeater ControlDesigning the TemplatesBuilding the PageThe Initialization StepRetrieving Child ControlsHandling PostbacksA Scrollable List of Data ItemsHandling the Click EventMaking the Control ScrollRepeating with Custom ClassesThe DataList ControlProgramming Interface of the DataList ControlProperties of the DataList ControlEvents of the DataList ControlFormatting CapabilitiesTable and Flow LayoutExtracting Template RowsMulticolumn RenderingTemplates of the DataList ControlThe SelectedItemTemplate TemplateThe EditItemTemplate TemplateWorking with the DataList ControlAdding Support for SelectionMaking an Item SelectableKeeping the Selected Item in ViewAdding Support for PagingRendering Pages of DataTracking the Page IndexConclusionResources
10. Web Forms User Controls
What's a User Control, Anyway?The UserControl ClassBase Properties of User ControlsBase Methods of User ControlsConverting Pages into User ControlsThe @Control DirectiveFragment Output CachingDeveloping User ControlsBuilding a TabStrip User ControlIncluding a User Control in a PageThe @Register DirectiveSetting Up a User ControlBuilding a User-Control Object ModelAdding PropertiesInitializing the User ControlAdding MethodsHandling User-Control EventsAdding the SelectionChanged EventFiring a Custom EventHandling a Custom EventGetting Serious About User ControlsBuilding Data-Bound User ControlsThe ButtonList User ControlThe Programming Interface of the ButtonList ControlGenerating the OutputSetting Up a Client PageLoading Controls DynamicallyThe @Reference DirectiveAdding Dynamically Created Controls to the PageReferencing User Controls from Code-Behind PagesConclusionResources
11. ASP.NET Mobile Controls
Architecture of Mobile ControlsMultiple Markup LanguagesCompact HTMLHTML 3.2Wireless Markup LanguageThe Wireless Application ProtocolOverview of Mobile ControlsMobile Controls HierarchyASP.NET Mobile PagesPagination in Mobile PagesThe Life Cycle of a Mobile PageDevice AdaptersContainer ControlsThe Panel ControlThe Form ControlList ControlsThe List ControlThe ObjectList ControlThe SelectionList ControlText ControlsThe TextBox ControlThe Command ControlThe PhoneCall ControlValidation ControlsDeveloping Mobile ApplicationsThe CustomerFinder ApplicationDevising the Application for UsabilityThe Mobile Designer in Visual Studio .NETWorking with EmulatorsThe Navigation Model of the ApplicationThe Main FormThe Second Menu FormThe Customer FormAdaptive RenderingUnderstanding Device FiltersCreating Control TemplatesState ManagementThe View StateThe Private View StateThe Session StateConclusionResources
IV. ASP.NET Application Essentials
12. Configuration and Deployment
Configuration in the .NET FrameworkThe XML Schema of Configuration FilesThe Machine Configuration FileSecurity Configuration FilesApplication Configuration FilesManaging Configuration SettingsThe ConfigurationSettings ClassSection HandlersASP.NET Applications ConfigurationThe ASP.NET Configuration HierarchyThe <location> SectionCentralized ConfigurationUnmodifiable SettingsThe <system.web> SectionThe <authentication> SectionThe <authorization> SectionThe <browserCaps> SectionThe <clientTarget> SectionThe <compilation> SectionThe <customErrors> SectionThe <deviceFilters> SectionThe <globalization> SectionThe <httpHandlers> SectionThe <httpModules> SectionThe <httpRuntime> SectionThe <identity> SectionThe <machineKey> SectionThe <mobileControls> SectionThe <pages> SectionThe <processModel> SectionThe <securityPolicy> SectionThe <sessionState> SectionThe <trace> SectionThe <trust> SectionThe <webControls> SectionThe <webServices> SectionReading User Configuration DataUsing the ConfigurationSettings ClassThe NameValueFileSectionHandler ClassCreating New Configuration SectionsA Custom DataSet Section HandlerPersisting Application SettingsWriting to web.configWriting to Custom FilesWriting to DatabasesASP.NET Applications DeploymentCreating a SetupA Web Setup ProjectCustom ActionsProgrammatically Configuring the ACL of a FileUpdating Configuration OptionsConfiguring the MachineDeploying on a Web FarmConclusionResources
13. 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> TagsServer-Side IncludesStatic PropertiesTracking Errors and AnomaliesThe HttpContext ClassStatic MembersProperties of the HttpContext ClassMethods of the HttpContext ClassThe Server ObjectIntrinsic Objects? No, Intrinsic PropertiesProperties of the HttpServerUtility ClassMethods of the HttpServerUtility ClassEmbedding Another Page's ResultsServer-Side RedirectionLate-Bound COM ObjectsThe Importance of AspCompatThe Response ObjectProperties of the HttpResponse ClassSetting the Response Cache PolicySetting an Output FilterMethods of the HttpResponse ClassThe Request ObjectProperties of the HttpRequest ClassMethods of the HttpRequest ClassConclusionResources
14. ASP.NET State Management
The Application StateProperties of the HttpApplicationState ClassMethods of the HttpApplicationState ClassState SynchronizationTradeoffs of Application StateThe Session StateThe Session-State HTTP ModuleState Client ManagersCreating the HttpSessionState ObjectSynchronizing Access to the Session StateProperties of the HttpSessionState ClassMethods of the HttpSessionState ClassIdentifying a SessionCookieless SessionsGenerating the Session IDLifetime of a SessionThe Session_OnStart EventThe Session_OnEnd EventWhy Does My Session State Sometimes Get Lost?Detecting Expired SessionsPersist Session Data to Remote ServersState Serialization and DeserializationStoring Session DataConfiguring the StateServer ProviderPersist Session Data to SQL ServerPerformance and RobustnessCreating and Configuring the DatabaseWorking in a Web Farm ScenarioThe View State of a PageThe StateBag ClassView State PropertiesView State MethodsCommon Issues with View StateEncrypting and SecuringMachine Authentication CheckSize Thresholds and Page ThroughputProgramming Web Forms Without View StateKeeping the View State on the ServerThe LosFormatter ClassCreating a View-State-Less PageSaving the View State to a Web Server FileLoading the View State from a Web Server FileThe ASP.NET Caching SystemThe Cache ClassCache and Other State ObjectsProperties of the Cache ClassMethods of the Cache ClassWorking with the ASP.NET CacheInserting New Items in the CacheRemoving Items from the CacheTracking Item DependenciesDefining a Removal CallbackSetting the Item PriorityControlling Data ExpirationBuilding a Cache ViewerEnumerating Items in the CacheClearing the CacheCaching ASP.NET PagesThe @OutputCache DirectiveChoosing a Duration for the Output CacheChoosing a Location for the Output CacheThe HttpCachePolicy ClassProperties of the HttpCachePolicy ClassMethods of the HttpCachePolicy ClassServer Cache-Validation CallbackCaching Multiple Versions of a PageVary by ParametersVary by HeadersVary by Custom StringsCaching Portions of ASP.NET PagesCaching the Output of User ControlsVary by ControlsImplementing Partial CachingThe PartialCachingControl ClassConclusionResources
15. ASP.NET Security
Writing Secure CodeTypes of Web AttacksPassive AttacksActive AttacksGolden Rules for Secure CodingDon't TrustBuffer OverrunsSQL InjectionsKeep a Low ProfileCross-Site ScriptingConfiguring ASP.NET Applications for SecurityChoosing Strong PasswordsStoring PasswordsPasswords and EncryptionThe ASPNET AccountPrivileges of the ASPNET AccountWho Really Runs ASP.NET Applications?Secure Storage of PasswordsEnabling ASP.NET to Manage Local FilesChanging the Identity of the ASP.NET ProcessSetting the Process AccountImpersonating an IdentityImpersonating Through the Anonymous AccountImpersonation and Web Application IsolationCode Access Security and the CLRImplementing the <trust> SectionASP.NET PermissionsAlternative Strategies for Isolating ApplicationsUser Authentication and AuthorizationIIS AuthenticationASP.NET Authentication TypesASP.NET Authorization RulesASP.NET and SQL ServerSetting Up Trusted ConnectionsWorking with Untrusted ConnectionsWindows AuthenticationAuthenticating Users Through IISBasic AuthenticationDigest AuthenticationIntegrated Windows AuthenticationThe Windows Authentication ProviderHow to Verify the Identity of the UserUsing ACLs to Authorize AccessEnabling ImpersonationURL Authorization and User-Based SecurityPassport AuthenticationUnderstanding the Passport InitiativeThe Passport Authentication ProviderForms AuthenticationThe Forms Authentication ProviderAccessing Protected ASP.NET ResourcesValidating User CredentialsAttributes of the <authentication> SectionManaging the Authentication CookieThe <credentials> SectionThe Login ProcessCollecting Credentials Through LoginAuthenticating the UserAccessing the Authentication Cookie ProgrammaticallySigning OutRole-Based AuthenticationDefining RolesServing Personalized PagesURL AuthorizationThe <authorization> SectionBinding Roles and Identity ObjectsConclusionResources
16. Working with the File System
File I/O in the .NET FrameworkWorking with FilesThe FileInfo ClassKeeping File Information In SyncCopying and Deleting FilesAttributes of a FileWorking with DirectoriesThe DirectoryInfo ClassListing the Contents of a DirectoryFiltering the Contents of a DirectoryWorking with Path NamesThe Programming Interface of the Path ClassCombining PathsReaders and WritersWorking with StreamsWorking with Readers and WritersSpecialized Readers and WritersReading Local FilesThe StreamReader ClassAccessing the Underlying StreamCharacter EncodingMethods of the StreamReader ClassReading a Text FileBinding the Contents of a File to a DataGridThe BinaryReader ClassReading Binary InformationSkipping Bytes While ReadingWriting Local FilesThe StreamWriter ClassThe Programming Interface of the StreamWriter ClassPersisting a Collection of DataWriting Binary FilesCreating Images DynamicallyThe BinaryWriter ClassSerializing Data StructuresThe BinaryFormatter ClassSerializing Data Through ClassesWatching for File ChangesThe FileSystemWatcher ClassHooking Up EventsLoading XML DocumentsReading XML FilesThe Programming Interface of XML ReadersReading AttributesValidating ReadersThe XML DOM ParserLoading and Caching XML DocumentsWalking Your Way Through DocumentsValidating Documents Through XML DOMCreating XML DocumentsUsing XML WritersUsing the XML DOM WriterXML Documents in ASP.NETServer-Side XML TransformationsProgramming the Xml Server ControlWorking with the Xml Server ControlConclusionResources
17. Working with Web Services
The Infrastructure for Web ServicesThe SOAP ProtocolThe SOAP PayloadArchitectural IssuesThe WSDL LanguageElements of the WSDL SyntaxA Sample WSDL DocumentThe .NET Infrastructure for Web ServicesIIS SupportThe WebService ClassBuilding an ASP.NET Web ServiceWriting a Web Service ClassThe WebService AttributeChanging the Default NamespacePrecompiled Web ServicesExposing Web MethodsDefining a Web MethodType MarshalingUnder the Hood of a Web Method CallReferencing Web Services from ASP.NETBuilding a Proxy ClassSetting the URL of a Web ServiceDisabling HTTP-POST and HTTP-GETInvoking Methods on a Web ServiceWeb Methods Best PracticesAttributes of Web MethodsCaching the Output of a Web MethodMinimizing the Data TransferredThrowing ExceptionsTransactional MethodsAsynchronous MethodsSecuring Web ServicesHTTP User AuthenticationMaking a Secure CallDetecting the Connected UserCustom User AuthenticationEmbedding Credentials in the SOAP PayloadAuthenticating the UserManaging RolesUsing Application-Specific TokensGetting the TokenThe Amazon CaseManaging the State of Web ServicesEnabling Session StateUsing Cookie ContainersThe Importance of a Cookie ContainerBuilding a Persistent Cookie ContainerConclusionResources
V. Custom ASP.NET Controls
18. Extending Existing ASP.NET Controls
A Better Label ControlThe LinkLabel Server ControlSetting Up the New LinkLabel ClassHow Controls Render Their OutputFinding Web-Sensitive ElementsUsing the LinkLabel ControlConfiguring the Control at Design-TimeWant to Be Spammed?Modifying the Opening TagA Better DataGrid Control>Improving the Pager BarRefining the NextPrevModeA Tab-Style PagerImproving the FooterComputing Expressions DynamicallyThe Programming Interface of the FooterA DataGridwith Summary InformationA Better Server-Side Form ControlSupporting Multiple Server FormsDevising Logical FormsA Control Representing a Logical FormPacking the Form's ContentsCreating Multiple Form-Like ControlsPages with Multiple FormsRetrieving Form ValuesConclusionResources
19. Creating New ASP.NET Controls
Base Control Classes and InterfacesControl vs. WebControlRelated InterfacesThe HTML Text WriterWriting AttributesWorking with StylesBuilding a Gauge ControlDefining the Object ModelImplementing the Object ModelSetting Up the RulerSetting Up the Control's SiteRendering the ControlGenerating the HTML for a Custom ControlUsing Child Controls For RenderingThe Gauge in ActionBuilding a Chart Generator ControlDefining the Object ModelBinding DataThe Bar Chart ItemThe View State from the Control's PerspectiveRendering the ControlThe Title AreaBuilding the ChartThe Background of the TableThe BarChart Control in ActionBuilding Composite ControlsStructure of Composite ControlsDesigning a Composite ControlCreating Child ControlsThe Importance of Being a Naming ContainerHandling PostBacksUsing the LabelTextBox ControlConclusionResources
20. Data-Bound and Templated Controls
Designing a Data-Bound ControlMaking the BarChart Control Data BoundDefining Data-Bound PropertiesOverriding the DataBind MethodResolving Data SourcesUsing the Data-Bound BarChart ControlDesigning a Templated ControlA Templated BarChart ControlGeneral Rules for Templated ControlsParsing Nested TagsThe <CaptionTemplate> SectionThe <FooterTemplate> SectionThe Template Container ClassUsing the Templated BarChart ControlThe Control Builder ClassDesigning the TextBoxList ControlImplementing the TextBoxList ControlThe Custom Control Builder ClassThe TextBoxList ClassThe FormField ClassRendering the ControlUsing the TextBoxList ControlConclusionResources
21. Design-Time Support for Custom Controls
The Design-Time Architecture in .NETComponents, Sites, Containers, and ControlsControls and DesignersThe GraphicPanel ControlDesign-Time AttributesUsing Design-Time AttributesA Commonly Used Set of AttributesEnumeration and Color TypesAttributes that Affect Run-Time BehaviorExtending IntelliSense SupportWriting the Schema of a ControlRegistering a Custom Schema with Visual Studio .NETRendering TypesImplementing a Type ConverterDeriving from TypeConverterSerialization AttributesDeriving from ExpandableObjectConverterCreating a Type EditorThe About Property EditorDesigning a Custom Type EditorWriting Custom DesignersHTML Control DesignersCreating a Control DesignerGenerating Design-Time HTMLConclusionResources
VI. Advanced Topics
22. Working with Images in ASP.NET
Accessing Images from Web PagesThe <img> ElementReferencing Nonfile ImagesSetting the Content TypeFlushing to the Output StreamAccessing Database ImagesWorking with Binary FieldsReading Images from BLOB FieldsUploading Images to BLOB FieldsReal-World ScenariosOptimizing the Database QueryOptimizing Memory UsageShould You Really Store Images in the Database?Generating Images DynamicallyA Quick Tour of GDI+ ClassesThe Graphics ClassThe Bitmap ClassFilling RectanglesDrawing TextWriting Images to MemorySupported Image FormatsWriting Copyright Notes on ImagesGenerating ThumbnailsControlling the Compression Ratio of JPEG ImagesSaving to Larger FormatsThe MemoryStream ClassBuilding Chart Generator PagesDrawing a Pie ChartDrawing a Bar ChartConclusionResources
23. HTTP Handlers and Modules
Quick Overview of the IIS Extensibility APIThe ISAPI ModelIllustrious Children of the ISAPI ModelStructure of ISAPI ComponentsISAPI ExtensionsISAPI FiltersWriting HTTP HandlersThe IHttpHandler InterfaceMembers of the IHttpHandler InterfaceASP.NET Request ProcessingA Very Simple HTTP HandlerA Synchronous HTTP Handler for Quick Data ReportsBuilding a Query Manager ToolRegistering the HandlerDeploying as an ASHX ResourceAdvanced HTTP Handler ProgrammingHTTP Handler FactoriesAsynchronous HandlersWriting HTTP ModulesThe IHttpModule InterfaceA Custom HTTP ModuleWiring Up EventsAccessing Other HTTP ModulesRegistering with the Configuration FileConclusionResources
24. Hosting ASP.NET Outside IIS
Hosting the ASP.NET RuntimeThe ApplicationHost ClassThe Role of the Host TypeThe SimpleWorkerRequest ClassA Sample ASP.NET HostCompiling ASPX Pages to HTMLLocating the Host TypeThe Cassini Personal Web ServerCassini in PersonThe Architecture of CassiniPut Your Web Site on a CDStep-by-Step OperationsInstalling ASP.NET Without IISConclusionResources
Final Thoughts

Overview

This book uses a task-oriented approach to explain the inner workings of ASP.NET technology—with practical, hands-on examples to help programmers quickly implement ready-made solutions.

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: 0735619034Supplemental Contents Errata Catalog Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills