Microsoft Visual C# .NET 2003 Unleashed

by ;
Edition: 1st
Format: Paperback
Pub. Date: 2004-12-22
Publisher(s): Sams Publishing
Availability: This title is currently not available.
  • Free Shipping Icon

    This Item Qualifies for Free Shipping!*

    *Excludes marketplace orders.

List Price: $68.24

Rent Book

Select for Price
There was a problem. Please try again later.

New Book

We're Sorry
Sold Out

Used Book

We're Sorry
Sold Out

eBook

We're Sorry
Not Available

Summary

Microsoft Visual C# .NET 2003 Unleashedis a comprehensive reference and learning guide for the .NET Framework, using C# as the instructional language. You will be exposed to everything from low-level information on the Garbage Collector to advanced concepts like creating applications that use Enterprise Services, creating Web Services and even advanced Windows GUI. This book will become your definitive source of information on C# programming and the .NET framework. The book's lay-flat design makes it an ideal desk reference and the online searching and indexing through Safari make it the perfect tool for finding information quickly.Microsoft Visual C# .NET 2003 Unleashedwill show you all the ways you can unleash your C# programming skills.

Author Biography

Kevin Hoffman started programming on a Commodore VIC-20 donated by his grandfather. Ever since then, he has been hopelessly addicted to programming. Instead of spending time outside, absorbing rays from that big yellow thing (he's not even sure what it's called), he spent most of his time as a kid and up through high school and college learning as many programming languages as he could get his hands on. At one time or another, he has written applications in ADA, Assembly, Scheme, LISP, Perl, Java, Python, Tcl/Tk, C, C#, Visual Basic .NET, C++, Pascal, Delphi, Visual Basic, VAX/VMS Pascal, BASIC, dozens of proprietary scripting languages, PL/SQL, and probably a few more that he couldn't remember. He's even written a few programs for OS/2 and Mac OS X.

He started out working for a company that produces scientific instruments. He wrote code that interfaced PCs with data logging and gathering tools as well as real-time data analysis programs. From there he moved on to working technical support for Unix systems, PCs, SQL databases, and client/server applications. After that he made the infamous jump to a dot-com, where he wrote an extensive amount of Visual Basic, VBScript, and ASP code. After an additional job working with another n-tier, COM-based ASP application, he moved to Houston, where he now endures the heat with his wife, dog, and two cats.

Lonny Kruger has more than 18 years of experience in developing C/C++, C#, Pascal, Delphi, Java, JavaScript, and Prolog programs, specializing in real-time applications and user interface design. Mr. Kruger has served as Systems Engineering Manager, Development Manager, Senior Architect, Project Manager, Principal Investigator, and Senior Programmer for many projects including NASA's Next Grade Project, a tool for the rapid assembly and analysis of satellites, and was responsible for the development of hurricane tracking and prediction software using the CIA's world database. In addition to his programming experience, Mr. Kruger served six years in the United States Marine Corps, including a tour of duty in Saudi Arabia and Kuwait during the first Gulf War.


 

Table of Contents

Introduction 1(4)
Part I: Introduction to the Visual Studio .NET IDE
5(30)
The Visual Studio .NET IDE
6(29)
Window Management and Customization
7(7)
Customized Interfaces with Visual Studio .NET's ``Developer Profiles''
7(1)
Configuring Keyboard Shortcuts
8(1)
Filtering the MSDN Help
9(1)
Maximizing Your Viewable Area
9(1)
Using Visual Studio .NET 2003's Dockable Windows
10(4)
Understanding Visual Studio .NET 2003's Tool Windows
14(4)
Working with Documents
18(12)
Enhancing the Text Editor
18(4)
Finding Help Where You Need It
22(4)
Editing HTML
26(3)
Editing XML
29(1)
Editing Binary Files
30(1)
Using External Tools
30(2)
Defining Your Own Tools
31(1)
Summary
32(1)
Further Reading
32(3)
Part II: Language Fundamentals
35(278)
Introduction to C#
36(16)
Why Learn Yet Another Language?
37(1)
Learning Common Types
38(2)
Understanding Value Types
38(1)
Understanding Reference Types
39(1)
Reference Versus Value Types
40(1)
What Is the Common Language Runtime?
40(4)
Multiple Languages, One Runtime
42(1)
Isolation
42(1)
Platform Invoke
42(1)
Code Access Security
42(1)
The JIT Compiler
43(1)
Code Execution
43(1)
COM Interoperability
43(1)
Rotor: Microsoft's Shared Source Common Language Infrastructure
44(1)
Take Out the Trash: Theory of Garbage Collection
44(4)
Reference Counting
44(1)
Generations
44(1)
Collection
45(1)
Partial Collection
45(1)
Nondeterministic Finalization
45(1)
Using IDisposable to Create Well-Behaved Objects
46(2)
Introduction to the Base Class Library
48(1)
The Canonical ``Hello World'' Example
49(2)
Summary
51(1)
Further Reading
51(1)
Expressions and Control Structures
52(22)
Expressions and Control Structures
53(1)
Basic Expressions
53(1)
Legal Variable Names
53(1)
Using C# Operators
54(6)
Pre/Post Operators
60(1)
Program Flow Control: Control Structures
60(8)
The Program Execution Path
60(1)
Conditional Statements
60(1)
The if Control Structure
61(1)
The if/else Control Structure Combination
61(1)
Short Circuit Evaluation
62(2)
Using the Ternary Operator
64(1)
The switch Statement
65(3)
Looping
68(5)
The for Loop
68(1)
Using the for Statement
69(1)
The foreach Statement
69(1)
The while Loop
70(2)
The do.while Loop
72(1)
Summary
73(1)
Further Reading
73(1)
Strings and Regular Expressions
74(18)
String Basics
75(10)
Understanding the Immutability of Strings
75(1)
Applying Formatting to Strings
75(4)
Using Escape Sequences
79(1)
Locating Substrings
80(1)
Adding Padding
80(1)
Trimming Characters
81(1)
Replacing Characters
81(1)
Splitting Strings
82(1)
Modifying Case
82(1)
The StringBuilder
83(1)
Appending Values
83(1)
Using AppendFormat
83(1)
Inserting Strings
83(1)
Replacing Strings and Characters
84(1)
Removing Substrings
84(1)
Using Regular Expressions
85(1)
Understanding Expression Syntax
85(1)
How to Use Matching
85(6)
Validating Data with Regular Expressions
89(1)
Grouping Matches
89(1)
Replacing Matched Strings
90(1)
Summary
91(1)
Further Reading
91(1)
Arrays and Collections
92(20)
Using Arrays
93(5)
Understanding Single-Dimensional and Multidimensional Arrays
93(2)
Explaining Jagged Arrays
95(1)
Passing Arrays as Parameters
96(2)
Collection Basics
98(1)
Understanding the Basic Collection Interfaces
98(1)
Iterating Through Collections
98(1)
Collections Provided by the Base Class Libraries
99(8)
Using an ArrayList
100(1)
Using a Stack
101(1)
Using a Hashtable
102(1)
Using a BitArray
103(1)
Using the Queue
104(2)
Using a SortedList
106(1)
Creating Custom Collections
107(2)
Implementing the CollectionBase Class
107(1)
Creating a AddressList Collection
107(2)
Summary
109(1)
Further Reading
110(2)
Objects and Classes
112(16)
Objects and Classes
112(6)
Class Attributes
113(1)
Operations in Object-Oriented Design and Programming
114(2)
Classes
116(1)
Objects
117(1)
Objects State Maintenance
118(1)
Advanced Topics in Classes and Objects
118(7)
Inheriting from Base Classes
119(3)
Introduction to Polymorphism
122(3)
Summary
125(1)
Further Reading
126(2)
File and Stream I/O and Object Persistence
128(26)
File and Stream I/O
128(14)
Understanding File and Stream I/O
129(3)
Using Streams: FileStream, MemoryStream, StringReader, and StringWriter
132(6)
Using the FileSystemWatcher
138(4)
Object Persistence
142(10)
Serializing Objects
143(6)
Extending Standard Serialization
149(3)
Summary
152(1)
Further Reading
152(2)
XML Fundamentals
154(30)
Working with the DOM
155(8)
Creating an XML Document
161(1)
Working with XML Nodes, Elements, and Attributes
162(1)
Persisting the DOM
163(1)
Using the XmlReader Classes
163(5)
What Is an XmlReader?
164(1)
Using the XmlTextReader
164(2)
Using the XmlValidatingReader
166(1)
Using the XmlNodeReader
167(1)
Making Use of XmlConvert
167(1)
Exploring XPath
168(3)
Learning the Syntax
169(1)
Filtering Nodes
170(1)
Introduction to the XPathDocument
171(8)
Introduction to XSLT
175(1)
Transforming XML Documents
175(4)
Serialization XML Style
179(4)
Using Basic XML Serialization
179(2)
Customizing XML Serialization
181(2)
Summary
183(1)
Further Reading
183(1)
Multithreaded Programming
184(26)
Thread Basics
185(7)
Understanding the Key Thread Properties and Methods
185(2)
Explaining the ThreadStart Delegate
187(1)
Creating a Thread
188(1)
Running a Thread
188(1)
Terminating a Thread
188(3)
Suspending a Thread
191(1)
Creating a Pause by ``Sleeping'' a Thread
191(1)
Joining a Thread
191(1)
Synchronization
192(1)
Understanding the Different Types of Synchronization
193(1)
Applying the lock Keyword
193(13)
Raising Thread Events
194(2)
Using the Mutex Class
196(2)
Using the Monitor Class
198(5)
Safeguarding Variables (Interlocked Increment/Decrement)
203(1)
Reading Without Waiting (ReaderWriterLock)
203(3)
Using the Thread Pool for Asynchronous Programming
206(3)
Explaining the WaitCallback Delegate
206(1)
Queuing a Work Item
207(1)
Passing Data to Threads
208(1)
Further Reading
209(1)
Events and Delegates
210(18)
What Is a Delegate?
210(16)
Types of Delegates
215(3)
Delegates Inside
218(1)
Combined Delegates
219(2)
Events
221(5)
Summary
226(1)
Further Reading
226(2)
Reflection and Code Attributes
228(14)
Working with Reflection
228(6)
Introduction to Reflection
229(1)
How Reflection Works
229(1)
Discovering Type Information at Runtime
229(5)
Using Code Attributes
234(7)
Introduction to Code Attributes
234(1)
Using Code Attributes
235(1)
Creating Custom Attributes
236(2)
Querying Custom Attributes
238(3)
Summary
241(1)
Further Reading
241(1)
Assemblies and AppDomains
242(32)
Assemblies
243(1)
Introduction to Assemblies
243(1)
Assembly Building Blocks
243(4)
Introducing the Assembly Manifest
244(2)
Metadata
246(1)
Inside the Assembly---MSIL Code
247(1)
Assembly Resources
247(1)
Creating Assemblies
247(4)
Embedding Content and Resources in Assemblies
251(4)
Localization and Satellite Assemblies
255(4)
Satellite Assemblies
256(3)
AppDomains
259(5)
Introduction to AppDomains
259(1)
Programming with AppDomains
260(4)
Putting It Together---A Real-World Example
264(9)
Building Application Plug-Ins
264(9)
Summary
273(1)
COM and Windows Interoperability
274(20)
Using .NET Code to Interact with COM
275(6)
Introduction to COM Interop
275(1)
The Runtime Callable Wrapper
275(1)
.NET to COM Marshalling
276(2)
Code Interoperability Example: .NET Code Invoking COM Code
278(3)
COM to .NET
281(5)
The COM Callable Wrapper
281(1)
.NET Code Attributes for COM Interop Programming
281(1)
Marshalling Data from COM to .NET
282(1)
Interop Programming Example: COM Code Utilizing .NET Components
283(2)
When to Use Interop
285(1)
Primary Interop Assemblies
286(2)
Overview of Primary Interop Assemblies
286(1)
Working with PIAs
286(1)
Producing and Deploying PIAs
287(1)
Platform Invoke (P/Invoke)
288(4)
Introduction to Platform Invoke
288(1)
Consuming Unmanaged DLLs
288(1)
Platform Invoke---Data Marshalling
289(1)
Platform Invoke Sample---The Win32 API
290(2)
When to Use Platform Invoke
292(1)
Summary
292(1)
Further Reading
292(2)
High-Performance Programming
294(19)
Introduction to Garbage Collection
295(5)
Garbage Collection Internals---Generations
295(1)
Coding with the Garbage Collector in Mind
296(1)
Caveat: Nondeterministic Finalization Versus Deconstruction
297(3)
Memory and Class Management in the Common Language Runtime
300(5)
Boxing and Unboxing
300(2)
Collections and Boxing
302(1)
Using the StringBuilder Class
303(2)
High-Performance Code: Best Practices
305(5)
Using Exceptions
305(1)
Chunky API Calls
305(1)
Value Versus Reference Types
306(1)
Tip: Using AddRange on Collections
307(1)
Jagged Versus Rectangular Arrays
307(1)
For Versus Foreach
308(2)
Utilizing Asynchronous I/O
310(1)
Summary
310(1)
Further Reading
310(3)
Part III: Windows Applications
313(110)
Introduction to Windows Forms
314(16)
Windows Forms Basics
314(4)
Introducing the Main Method
315(1)
Understanding the Forms Designer
316(2)
Hello World
318(11)
Creating an Application Using the Windows Application Wizard
319(2)
Setting the Properties
321(1)
Compiling and Running the Application
322(2)
Responding to a Button Click
324(5)
Summary
329(1)
Further Reading
329(1)
Windows Forms User Interface Controls
330(20)
Standard Windows Forms User Interface Controls
330(17)
Performing Actions with Controls
330(4)
Storing and Changing Values with Controls
334(3)
Maintaining Lists with Controls
337(10)
User Controls
347(2)
Summary
349(1)
Further Reading
349(1)
Creating Visually Compelling Windows Forms Applications
350(22)
Visual Inheritance
351(8)
Using Inherited Forms
351(1)
WinForms Visual Inheritance in Action
352(6)
Visual Inheritance Best Practices
358(1)
Creating and Using Dynamic Context Menus
359(4)
Introduction to Contextual, Adaptive User Interfaces
360(1)
A Sample Dynamic Context Menu in Action
360(3)
Drawing Custom List Elements
363(1)
Using the DrawMode Property
363(5)
Creating a Custom ListBox
363(2)
Creating Custom Menu Items
365(3)
Shaped Forms
368(2)
Introduction to Shaped Forms
368(1)
Creating a Sample Shaped Form
368(2)
Summary
370(1)
Further Reading
370(2)
Consuming Web Services
372(18)
Adding Web References
373(5)
Adding References in Visual Studio .NET
373(4)
Using WSDL.EXE
377(1)
Supporting Dynamic URLs
378(5)
Storing URLs in app.config
379(1)
Storing URLs in Isolated Storage
379(3)
Dynamic URLs via UDDI Consumption
382(1)
Consuming Web Services Asynchronously
383(5)
Multithreaded Service Consumption Sample
384(1)
Web Service Client Reliability
385(1)
Testing for Network Connection
386(1)
Handling Web Service Errors
387(1)
Supporting Offline Actions
387(1)
Summary
388(1)
Further Reading
388(2)
Smart Clients
390(12)
Smart Clients
390(11)
Understanding the Smart Client
391(1)
Deploying Smart Client Updates from a Centralized Server
392(4)
Make Use of Web Services for Smart Client Back-End Support
396(4)
Deciding Whether to Process on the Server Side or Client Side for Efficiency
400(1)
Make Use of Online and Offline Functionality
400(1)
Summary
401(1)
Further Reading
401(1)
Deploying Windows Applications
402(21)
Installing .NET Applications
402(8)
Understanding Assembly Deployment
403(1)
Placing Assemblies in the Global Assembly Cache
404(5)
Private Installations
409(1)
Web Installations
410(5)
Deploying from a URL
410(2)
Deploying Smart Client Applications
412(3)
MSI/Project Installations
415(6)
Creating an Installation Project
415(6)
Summary
421(1)
Further Reading
421(2)
Part IV: Web Applications
423(112)
Introduction to Web Forms and ASP.NET
424(16)
Understanding the Web Forms Designer
424(2)
Creating an ASP.NET ``Hello World'' Application
426(7)
Basic Event Handling
433(5)
Summary
438(1)
Further Reading
438(2)
Web UI Controls
440(16)
Server Controls
440(15)
User Controls
444(11)
Summary
455(1)
Further Reading
455(1)
State Management in ASP.NET
456(28)
Client-Side State Management
456(23)
Understanding View State
456(7)
Using Hidden Form Fields
463(4)
Explaining Cookies
467(4)
Understanding Query Strings
471(3)
Passing Server Control Values Between Forms
474(5)
Server-Side State Management
479(3)
Explaining Application State
480(1)
Understanding Session State
481(1)
Summary
482(1)
Further Reading
483(1)
Caching
484(14)
Caching
484(12)
Introduction to ASP.NET Caching
485(1)
OutputCache Directive
486(3)
Using HttpCachePolicy
489(2)
Using the Cache Object
491(5)
Summary
496(1)
Further Reading
496(2)
Advanced ASP.NET
498(22)
Creating ASP.NET Applications in a Web Farm
499(7)
ViewState in a Web Farm
499(2)
Session State Maintenance in a Web Farm
501(2)
Application State in a Web Farm
503(1)
Web Farm Configuration and Deployment
504(1)
Web Farm Best Practices, Recommendations, and Caveats
505(1)
Localization and Globalization in ASP.NET
506(7)
Using Localized Resources
506(1)
Displaying Localized Content
507(4)
``Out of the Box'' Localization Functionality
511(2)
Creating Custom HttpModules
513(3)
Understanding the ASP.NET Application Events
513(1)
Creating a Custom HttpModule
513(3)
Creating Custom HttpHandlers
516(2)
Building a Synchronous HttpHandler
516(2)
Summary
518(1)
Further Reading
519(1)
Deploying ASP.NET Applications
520(15)
Manually Deploying an ASP.NET Application
521(2)
Deploying via ``Copy Project''
521(1)
XCopy Deployment
522(1)
When to XCopy
522(1)
Automated Deployment
523(6)
Creating a Setup Project
523(6)
Deploying a Setup Project
529(1)
Advanced ASP.NET Deployment
529(4)
Web Farm Considerations
530(1)
Firewalls, DMZs, Routers, and Security Constraints
530(2)
Hosted Environment Considerations
532(1)
Summary
533(1)
Further Reading
533(2)
Part V: Data Access
535(126)
Using .NET Data Providers
536(18)
SQL Server Data Provider
537(7)
Introduction to the SQL Server Data Provider
537(1)
Using the SqlConnection Class
537(2)
Using Database Connection Strings with a SqlConnection
539(1)
The SqlCommand Class
540(2)
The SqlDataReader Class
542(1)
The SqlDataAdapter Class
542(2)
Working with the OLEDB Data Provider
544(3)
Overview of the OLEDB Data Provider
545(1)
Using the OleDbConnection
545(1)
Using the OleDbCommand
545(1)
Using the OleDbDataReader
546(1)
Using the OleDbDataAdapter
546(1)
Additional Data Providers
547(1)
The Oracle.NET Data Provider (ODP.NET)
547(1)
The Microsoft .NET Data Provider for Oracle
547(1)
The .NET ODBC Data Provider
548(1)
The mySQL.NET Data Provider
548(1)
DataSet and DataAdapter Binding
548(4)
DataSet Review
548(1)
Associating a DataSet with a DataAdapter
549(1)
Sample: Hooking Up a DataSet to a Live Data Source
549(3)
Summary
552(1)
Further Reading
552(2)
Creating a Custom ADO.NET Data Provider
554(34)
Custom Data Providers
555(3)
When to Create a Data Provider
555(1)
Steps for Implementing a Custom Data Provider
556(1)
Sample Data Provider Scenario
556(1)
Overview of the Remote Data Provider
557(1)
Implementing IDataParameter and IDataParameterCollection
558(7)
The IDataParameter Interface
558(1)
The IDataParameterCollection Interface
559(1)
The RDPParameter Class
559(4)
The RDPParameterCollection Class
563(2)
Implementing a Custom Connection
565(4)
The IDbConnection Interface
566(1)
The RDPConnection Class
566(3)
Implementing a Custom Command
569(6)
The IDbCommand Interface
569(1)
The RDPCommand Class
570(5)
Implementing a Custom DataReader
575(7)
The IDataReader Interface
575(1)
The RDPDataReader Class
576(6)
Implementing a Custom DataAdapter
582(5)
The IDbDataAdapter Interface
582(1)
The RDPDataAdapter Class
582(5)
Summary
587(1)
Typed DataSets and XSD
588(24)
XML Schema Definition
589(10)
Introduction to XSD
589(2)
Primitive Data Types in XSD
591(1)
Derived Data Types
591(1)
Complex Data Types
592(1)
Grouping Elements
593(1)
Annotating XML Schemas
593(1)
XML Schema Facets
594(1)
Programming XML Schemas---The XmlSchema Class
595(4)
Structuring DataSets with Schema
599(4)
Defining Tables and Columns Using XML Schema
599(1)
Defining DataSet Keys and Constraints with XML Schema
600(3)
Typed DataSets
603(8)
Creating Typed DataSets in Visual Studio .NET
606(1)
Building Typed DataSets Using XSD.EXE
607(1)
Using Typed DataSets
607(2)
Annotating Typed DataSets
609(2)
Summary
611(1)
Further Reading
611(1)
Windows Forms Data Binding
612(22)
Data Binding Overview
613(3)
Introduction to Windows Forms Data Binding
613(1)
Simple Data Binding
613(3)
Complex Data Binding
616(1)
One-Way and Two-Way Data Binding
616(1)
Data Binding Mechanics
616(5)
The BindingContext Class
617(1)
The CurrencyManager Class
617(3)
The PropertyManager Class
620(1)
Data Binding Samples
621(4)
Simple Binding
621(1)
Binding to a ComboBox
622(1)
DataGrid Binding
622(3)
Advanced Binding Samples
625(7)
Header/Detail Forms
625(3)
Cascading Header/Detail
628(4)
Summary
632(2)
Web Forms Data Binding
634(27)
Data Binding Overview
635(4)
Introduction to Web Forms Data Binding
635(1)
<%# %> Binding Syntax
635(1)
Simple Data Binding
636(2)
Complex Data Binding
638(1)
The DataBind ( ) Methods
638(1)
Data Binding Mechanics
639(2)
Container.DataItem
639(1)
DataBinder.Eval
639(1)
The ItemDataBound Event
640(1)
Data Binding Samples
641(6)
Simple Binding
641(1)
Repeater Binding
641(4)
DataList Binding
645(2)
DataGrid Binding
647(1)
Advanced Binding Samples
647(10)
Header and Detail Forms
648(4)
Cascading Header and Detail
652(5)
Summary
657(1)
Further Reading
658(3)
Part VI: Web Services
661(32)
Introduction to Web Services
662(16)
Introduction to Web Services
663(2)
Defining Web Services
663(1)
Overview of Soap
663(2)
Overview of WSDL
665(1)
Building Web Services
665(9)
Hello World
665(4)
Complex Serialization
669(4)
Using Transactions with a Web Service
673(1)
Maintaining State with a Web Service
673(1)
Contract-First Programming with Web Services
674(1)
Review of Web Service Consumption
674(2)
Creating a Client Proxy for a Web Service
674(1)
Making Synchronous Calls
674(1)
Making Asynchronous Calls
675(1)
Summary
676(1)
Further Reading
676(2)
Introduction to WSE 2.0
678(15)
Introduction to WSE 2.0
679(1)
Overview of GXA
679(1)
Evolution of WSE
679(1)
TCP Messaging
679(8)
Soap over TCP
680(1)
SoapSender and SoapReceiver
680(3)
The SoapService Class
683(3)
The SoapClient Class
686(1)
Security
687(3)
Introduction to WSE Security
687(1)
UsernameTokens
688(1)
X.509 Certificates
689(1)
Signing Messages
690(1)
Messaging with Attachments Using WSE 2.0
690(1)
Introduction to DIME
690(1)
Transferring Files Via WSE
691(1)
Summary
691(1)
Further Reading
691(2)
Part VII: Secure Applications
693(80)
Code Access Security
694(16)
Introduction to CAS
695(3)
Using Code Access Security Permissions
696(1)
Code Access Permissions
696(1)
Identity Permissions
697(1)
Role-Based Security Permissions
698(1)
CAS Administration
698(6)
Modifying CAS Policy
698(1)
Policy Administration Tools
699(1)
Increasing Assembly Trust Levels
700(1)
Adjust Zone Security
701(1)
Evaluate Assembly
701(2)
Creating a Deployment Package
703(1)
Writing CAS-Aware Code
704(4)
Using Imperative Security Syntax
704(1)
Using Declarative Security Syntax
705(1)
Blocking Unwanted Clients
706(2)
Summary
708(1)
Further Reading
709(1)
Securing Sensitive Data
710(24)
Secret Key (Symmetric) Encryption
711(5)
DESCryptoServiceProvider
711(1)
RC2CryptoServiceProvider
712(1)
RijndaelManaged
713(1)
TripleDESCryptoServiceProvider
713(3)
Using Hashes to Protect Data
716(4)
MACTripleDES
716(2)
SHAIManaged
718(1)
MD5CryptoServiceProvider
719(1)
Public Key Encryption and Signatures
720(3)
DSACryptoServiceProvider
721(2)
RSACryptoServiceProvider
723(1)
Windows Data Protection API
723(10)
Using DPAPI
724(2)
Creating a DPAPI Wrapper
726(6)
Protecting Data in .NET with DPAPI
732(1)
Summary
733(1)
Securing ASP.NET Web Applications
734(20)
User Security
734(14)
Authenticating Users
735(5)
Authorizing Users with Roles
740(1)
Implementing IIdentity and IPrincipal
740(8)
Data Security in ASP.NET Applications
748(4)
Protecting Connection Strings and Web.config Data
748(1)
Protecting User Passwords
748(3)
Deciding When to Use SSL
751(1)
Data Security with ViewState Encryption
751(1)
Summary
752(1)
Further Reading
752(2)
Licensing and Intellectual Property
754(19)
Licensing Overview
755(2)
Licensing Defined
755(1)
When to License and Protect
755(1)
Types of Licensing and Verification
756(1)
Implementing Custom Licensing
757(11)
Introduction to the License Provider and License Manager
757(2)
Creating a License
759(1)
Creating a License Provider
760(4)
Building Licensed Controls
764(4)
Licensed Web Controls Versus Windows Forms Controls
768(1)
Licensing Implementation Strategies
768(1)
Deciding on a Licensing Deployment Method
768(1)
Deciding on a Licensing Verification Method
768(1)
Deciding on a License Purchase Method
768(1)
Deciding on a Licensing Method
769(1)
Protecting Your Intellectual Property
769(2)
Protecting Intellectual Property by Hiding Your Licensing Algorithm
769(1)
Protecting Intellectual Property Through Obfuscation
770(1)
Protecting Intellectual Property with Alternative Back-Ends
770(1)
Summary
771(1)
Further Reading
771(2)
Part VIII: Enterprise and Connected Applications
773(76)
Interface Programming
774(18)
Interface Programming
774(16)
Understanding the Interface
774(4)
Declaring the Interface Implicitly
778(6)
Declaring the Interface Explicitly
784(2)
Mapping the Interface
786(3)
Inheriting the Interface
789(1)
Summary
790(1)
Further Reading
790(2)
Remoting
792(16)
Remoting Architecture
792(14)
Introduction to Remoting
792(1)
Explaining Application Domains
793(2)
Understanding the Context
795(1)
Choosing a Channel
796(1)
Life and Death of the Remote Object
797(6)
Building the Remoting Server Application
803(2)
Building the Client
805(1)
IIS and Remoting
806(1)
Summary
807(1)
Further Reading
807(1)
COM+ Enterprise Services
808(20)
Overview of COM+
809(4)
Transactions
809(1)
JIT Activation in COM+
810(1)
Object Pooling
810(1)
Construction Strings
811(1)
Role-Based Security
811(1)
Queued Components
812(1)
Events
812(1)
Building COM+ Components
813(7)
Transactions
813(2)
Construction Strings
815(2)
JIT Activation Sample
817(1)
Object Pooling
817(1)
Shared Properties
818(2)
Security in COM+
820(3)
Object and Security Contexts
820(1)
Role-Based Security
821(2)
Advanced COM+
823(4)
Events
823(3)
Queued Components
826(1)
Summary
827(1)
Further Reading
827(1)
Enterprise Templates
828(21)
Enterprise Templates
828(3)
Introducing the Enterprise Template
829(1)
Static and Dynamic Content
830(1)
Static Prototypes
831(1)
Subproject Wizards
831(1)
Custom Wizards
831(1)
Policy Files
831(3)
TDL Elements
832(2)
Teaching by Example
834(12)
Setting Up the Prerequisites
834(1)
Laying Out the Template
835(1)
Creating the Template Structure
836(3)
Assigning a Policy to the Template
839(1)
Making the Template
840(4)
Making the Template Available to Users
844(1)
Testing the Template
845(1)
Summary
846(1)
Further Reading
847(2)
Part IX: Debugging and Testing
849(69)
Debugging Your Applications
850(22)
The Visual Studio .NET Debugging Environment
850(11)
Setting Up the Application for Debugging
850(2)
Understanding Syntax and Error Messages
852(2)
Understanding the Debugging Tool Windows
854(4)
Navigating the Application
858(1)
Setting and Using Breakpoints
859(2)
Debugging with Visual Studio .NET
861(11)
Debugging an Application
861(11)
Monitoring Your Applications
872(18)
Debugging and Tracing Statements
872(16)
Trace Listeners
876(6)
Trace Switches
882(3)
Custom Trace Listeners
885(3)
Summary
888(2)
Instrumenting Your Application
890(18)
Instrumenting Applications
890(12)
Introduction to Instrumenting an Application
891(1)
Methods of Instrumentation
892(1)
Windows Event Log
892(3)
Examining the Debug and Trace Classes
895(2)
Windows Management Instrumentation
897(5)
Enterprise Instrumentation Framework
902(5)
Introducing the EIF
902(1)
Enterprise Instrumentation Framework Requirements
903(1)
Elements of the EIF
903(3)
Request Tracing
906(1)
Configuring EIF
906(1)
Summary
907(1)
Further Reading
907(1)
The Future of C#
908(10)
The Future of C#
908(8)
Generics
909(3)
Anonymous Methods
912(1)
Nullable Types at Last
913(1)
List Management with Iterators
913(1)
Partial Types
914(1)
Static Classes
915(1)
Summary
916(1)
Further Reading
916(2)
Index 918

Excerpts

= 0) {slash = '\\';} else {slash = '/';}openLoc = figLoc.substring(0, figLoc.lastIndexOf(slash) + 1);while (pPage.substring(0,3) == '../') {openLoc = openLoc.substring(0, openLoc.lastIndexOf(slash, openLoc.length - 2)+ 1);pPage = pPage.substring(3, pPage.length + 1);}popUpWin =window.open('','popWin','resizable=1,scrollbars=1,location=0,toolbar=0,width=525,height=394');figDoc = popUpWin.document;zhtm= ' ' + pPage + ' ';zhtm += ' ';zhtm += ' ';zhtm += ' ';zhtm += '' + pPage.substring(pPage.lastIndexOf('/') + 1, pPage.length) + '';zhtm += ' ';figDoc.write(zhtm);figDoc.close();}// modified 3.1.99 RWE v4.1 --> Introduction Introduction Welcome to Visual C# .NET 2003Today, people are living in a busy time. Gone are the days when it took two to three weeks to get a decision on a credit application for a car. We live in a time where we need what we want, and we want what we need, right now.Wanting information right now is a common theme in today's environment. Having it right now is today's challenge. Whether it's while driving in the car, flying in an airplane, working, or while watching television at home, we all want it now. To solve this dilemma, IBM introduced the world to personal computers. For a time this was great, but personal computers were too expensive for the average person to have at home, so other companies introduced the portable computer. Don't let the termportableconfuse you, this computer was everything but portable. The portable computer eventually became small enough to actually carry around and everything seemed right with the world, at least for a time. However, as time passed, so did the fad of starting up your laptop to find the phone number or address of the person you were trying to contact. So, along came mobile devices. With time, mobile devices such as personal digital assistants (PDAs), cellular phones, and cellular phones that thought they were PDAs became more advanced and brought us to the brink of having everything that we wanted at our fingertips...but not quite.The great thing about the world is that everyone has his own ideas. Some ideas are great, and some...well, some are not so great. The problem with this is that most people have a bias toward their own ideas and think that their way is the right way. This causes companies to develop technologies to handle tasks in their own image and makes communication between similar devices, made by different manufacturers, difficult if not impossible. Imagine this: You are tasked with gathering stock prices from different vendors of stock quotes. One source requires that you query its database with a proprietary protocol. Another has a file that is reproduced every minute and requ

An electronic version of this book is available through VitalSource.

This book is viewable on PC, Mac, iPhone, iPad, iPod Touch, and most smartphones.

By purchasing, you will be able to view this book online, as well as download it, for the chosen number of days.

Digital License

You are licensing a digital product for a set duration. Durations are set forth in the product description, with "Lifetime" typically meaning five (5) years of online access and permanent download to a supported device. All licenses are non-transferable.

More details can be found here.

A downloadable version of this book is available through the eCampus Reader or compatible Adobe readers.

Applications are available on iOS, Android, PC, Mac, and Windows Mobile platforms.

Please view the compatibility matrix prior to purchase.