Home Page Icon
Home Page
Table of Contents for
Programming Microsoft .NET (core reference)
Close
Programming Microsoft .NET (core reference)
by Jeff Prosise
Programming Microsoft® .NET
Dedication
Acknowledgments
Introduction
The Journey Ahead
A Word About Programming Languages
System Requirements
What’s on the CD
Support
Blogs and Other Things That Go Bump in the Night
I. Essential Concepts
1. Hello, .NET
The Microsoft .NET Initiative
The Microsoft .NET Framework
The Common Language Runtime
Programming Languages
Managed Modules
Metadata
Common Intermediate Language
Assemblies
The .NET Framework Class Library
Your First .NET Framework Application
Hello, World
Inside Hello.cs
More About the Main Method
Inside Hello.exe
The Big Picture
2. Types and Exceptions
.NET Framework Data Types
Classes
Structs
Interfaces
Enumerations
Delegates
Boxing and Unboxing
Reference Types vs. Value Types
Nondeterministic Destruction
Dynamic Linking
Creating a Multifile Assembly
Dynamically Linking to an Assembly
Versioning an Assembly
Sharing an Assembly: The Global Assembly Cache
Applying Strong Names Using Attributes
Delayed Signing
Exception Handling
Catching Exceptions
Guaranteeing Execution
Throwing Exceptions
Next Up: The .NET Framework Class Library
3. The .NET Framework Class Library
File and Stream I/O
Text File I/O
Binary File I/O
Collections
Hash Tables
Resizable Arrays
The WordCount Application
Regular Expressions
Splitting Strings
Searching Strings
Replacing Strings
Internet Classes
HttpWebRequest and HttpWebResponse
The System.Web.Mail Namespace
Data Access
DataReaders
Inserts, Updates, and Deletes
DataSets and DataAdapters
Reflection
Retrieving Information About Assemblies, Modules, and Types
Custom Attributes
Dynamically Loading Types (Late Binding)
The FCL in Review
4. Windows Forms
The Windows Forms Programming Model
Your First Windows Form
Drawing in a Form: The GDI+
Drawing Lines, Curves, and Figures
Disposing of GDI+ Objects
Coordinates and Transformations
Units of Measure
Menus
Main Menus
Processing Menu Commands
Context Menus
Menu Item States
Accelerators
The ImageView Application
Mouse and Keyboard Input
Processing Keyboard Input
Processing Mouse Input
The NetDraw Application
Other Form-Level Events
Controls
The ControlDemo Application
Anchoring
Dialog Boxes
The DialogDemo Application
Windows Forms and Visual Studio .NET
Step 1: Create a Project
Step 2: Design the Form
Step 3: Add Fields
Step 4: Modify the Form’s Class Constructor
Step 5: Add Helper Methods
Step 6: Add Click Handlers
Step 7: Add Keyboard Handlers
Step 8: Override ProcessDialogKey
Step 9: Build and Run the Application
The NetCalc Source Code
Windows Forms Retrospective
II. ASP.NET
5. Web Forms
Web Application Primer
Hypertext Transfer Protocol
HTML Forms
Server-Side Processing
The Active Server Pages Solution
Your First Web Form
Control Properties
Control Events
Implementation Notes
The Web Forms Programming Model
Web Controls
HTML Controls
Page-Level Events
The Page.Load Event and the Page.IsPostBack Property
The Page.Init Event
Page-Level Directives
The @ Page Directive
The @ Import Directive
The @ Assembly Directive
The @ OutputCache Directive
A Web Forms Currency Converter
Code-Behind Programming
The Lander Application
How Code-Behind Works
Using Code-Behind Without Precompiling: The Src Attribute
Using Non-ASP.NET Languages in ASP.NET Web Forms
Web Forms and Visual Studio .NET
Step 1: Create a Virtual Directory
Step 2: Create a Web Application Project
Step 3: Change to Flow Layout Mode
Step 4: Add a Table
Step 5: Insert Text
Step 6: Add TextBox Controls
Step 7: Add a Button Control
Step 8: Add a Label Control
Step 9: Edit the HTML
Step 10: Add a Click Handler
Step 11: Build and Test
The LoanCalc Source Code
A Glimpse into the Future
6. Web Controls
Simple Controls
TextBox Controls
TextChanged Events and the AutoPostBack Property
Label Controls
HyperLink Controls
Image Controls
CheckBox Controls
RadioButton Controls
Table Controls
Panel Controls
Button Controls
List Controls
DropDownList Controls
ListBox Controls
CheckBoxList Controls
RadioButtonList Controls
Data Binding with List Controls
Data-Bound Controls
Repeater Controls
The MyComicsRepeater Page
DataList Controls
The MyComicsDataList Page
DataGrid Controls
Sortable DataGrid Controls
Pageable DataGrid Controls
The MyComicsDataGrid Page
Calendar Controls
Advanced Customization: The DayRender Event
Showtime
Validation Controls
Using the Validation Controls
RequiredFieldValidator
RangeValidator
CompareValidator
RegularExpressionValidator
CustomValidator
ValidationSummary
Spammers, Incorporated
Connecting Web Forms with Response.Redirect
The StringBuilder Class
Conditional Validation
Odds, Ends, and the WebControl Base Class
7. User Controls
User Control Fundamentals
The @ Control Directive
Your First User Control
Adding Properties
Adding Events
Using Code-Behind with User Controls
The XmlNavBar Control
Dynamic Loading (and Cookies, Too!)
Cookies
Cookies and ASP.NET
Multivalue Cookies
The MyQuotes Page
Fragment Caching
Next Up: Custom Controls
8. Custom Controls
Custom Control Basics
Your First Custom Control
Testing the Hello Control
Improving the Hello Control: Adding Properties
More About HtmlTextWriter
Postbacks and Postback Data
The IPostBackDataHandler Interface
View State
Change Events
How View State Works
View State Security
Generating Postbacks
The IPostBackEventHandler Interface
The AutoCounter Control
Composite Controls
Declarative Composites
The GroupBox Control
Programmatic Composites
The LoginControl
Server Controls and Client-Side Scripting
Returning JavaScript to the Client
The RegisterClientScriptBlock Method
Keeping Your Code Off the Client
The RolloverImageLink Control
The NumTextBox Control
Graphical Controls
HTTP Handlers
The Odometer Control
How the Odometer Control Works
Summary
9. Web Applications
Structure of an ASP.NET Application
The Web.config File
<appSettings>
<system.web>
Configuration Inheritance
The Global.asax File
Global Directives
The @ Application Directive
The @ Import Directive
The @ Assembly Directive
Global Event Handlers
Start and End Events
Per-Request Events
Error Events
Global Object Tags
Application State
Using Application State
Locking and Unlocking
The AppCounter Application
The Application Cache
Adding and Removing Items
Locking and Unlocking
Expiration Policies
Cache Removal Callbacks
The Cache.Add Method
The SmartQuotes Application
Session State
Using Session State
The SessionSpy Page
Cookieless Session State
Session State Process Models
In-Proc Session State
State Server Session State
SQL Server Session State
State Servers, SQL Servers, and Serializable Objects
Session Lifetimes
Disabling Session State
A Word on Web Farms
The Congo.com Application
Inside Congo.com
On Your Own
10. ASP.NET Security
Understanding Web Security
Authentication
Authorization
IIS Security
ASP.NET Security
Windows Authentication
Basic Authentication
Digest Authentication
Integrated Windows Authentication
Getting Information About Authenticated Users
Windows Authentication in Action
Windows Authentication and URL Authorizations
Windows Authentication and Role-Based Security
Forms Authentication
A First Look at Forms Authentication
Real-World Forms Authentication
Authentication Cookie Lifetime
Forms Authentication and Role-Based Security
Multiple Roles
Signing Out
Authentication Cookie Security
Caveat Emptor
11. Web Services
Web Services
Your First Web Service
Testing a Web Service
Web Services and Code-Behind
The WebService Base Class
The WebMethod Attribute
The Web Services Description Language
Web Services and Complex Data Types
Web Service Discovery—DISCO
Web Service Discovery—UDDI
Web Service Clients
Web Service Proxies
A Simple Web Service Client
Avoiding Hard-Coded Service URLs
Asynchronous Method Calls
Web Service Clients and Proxy Servers
The CityView Application
How CityView Works
For-Fee Web Services
Dawn of a New Era
III. The Cutting Edge
12. ADO.NET
A Tale of Two Providers
The System.Data.SqlClient and System.Data.OleDb Namespaces
Connections, Commands, and DataReaders
The SqlConnection Class
The OleDbConnection Class
Opening and Closing Connections
Command Classes
The ExecuteNonQuery Method
The ExecuteScalar Method
The ExecuteReader Method
Closing a DataReader
Transacted Commands
Parameterized Commands
Stored Procedures
DataSets and DataAdapters
The DataSet Class
DataSets vs. DataReaders
DataAdapter Classes
Initializing a DataSet from a Database: DataAdapter.Fill
DataTable and Friends
Inserting Records into a DataTable
Selecting Records in a DataTable
Updating Records in a DataTable
Deleting Records from a DataTable
Propagating Changes Back to a Database: DataAdapter.Update
CommandBuilder Classes
The DataView Class
A Word About XML
13. XML
XML Primer
Elements
Attributes
CDATA, PCDATA, and Entity References
Namespaces
Document Validity and Schemas
XML Parsers
Reading and Writing XML
The XmlDocument Class
The XmlTextReader Class
The XmlValidatingReader Class
The XmlTextWriter Class
XPath
XPath Basics
XPathNavigator and Friends
A Do-It-Yourself XPath Expression Evaluator
XSL Transformations (XSLT)
Converting XML to HTML on the Client
Converting XML to HTML on the Server
Converting XML Document Formats
Summary
14. Multithreading
Threads
Starting Threads
Foreground Threads vs. Background Threads
Thread Priorities
Suspending and Resuming Threads
Terminating Threads
If It Sounds Too Good to Be True…
The Sieve and MultiSieve Applications
Timer Threads
Thread Synchronization
The Interlocked Class
Monitors
The C# lock Keyword
Conditionally Acquiring a Lock
Waiting and Pulsing
Monitor Internals
Reader/Writer Locks
Mutexes
Events
Waiting on Multiple Synchronization Objects
Serializing Access to Collections
Thread Synchronization via the MethodImpl Attribute
Thread Pooling
15. Remoting
Remoting Basics
Your First Remoting Application
Programmatic vs. Declarative Configuration
Server Activation vs. Client Activation
The Activator.GetObject and Activator.CreateInstance Methods
Object Lifetimes and Lifetime Leases
Advanced Remoting
Using IIS as an Activation Agent
HTTP Channels and Binary Formatters
Delegates and Events
Asynchronous Method Calls
One-Way Methods
Putting It All Together: The NetDraw Application
Microsoft .NET: A Whole New Ball Game
A. About the Author
Jeff Prosise
About the Author
Copyright
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
Cover
Next
Next Chapter
Dedication
Programming Microsoft .NET (core reference)
Jeff Prosise
Published by
Microsoft Press
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset