Atnaujinkite slapukų nuostatas

El. knyga: Pro .NET 1.1 Remoting, Reflection, and Threading

, , , , , , , , ,
  • Formatas: PDF+DRM
  • Išleidimo metai: 02-Nov-2006
  • Leidėjas: APress
  • Kalba: eng
  • ISBN-13: 9781430200253
Kitos knygos pagal šią temą:
Pro .NET 1.1 Remoting, Reflection, and ThreadingDidesnis paveikslėlis
  • Formatas: PDF+DRM
  • Išleidimo metai: 02-Nov-2006
  • Leidėjas: APress
  • Kalba: eng
  • ISBN-13: 9781430200253
Kitos knygos pagal šią temą:

DRM apribojimai

  • Kopijuoti:

    neleidžiama

  • Spausdinti:

    neleidžiama

  • El. knygos naudojimas:

    Skaitmeninių teisių valdymas (DRM)
    Leidykla pateikė šią knygą šifruota forma, o tai reiškia, kad norint ją atrakinti ir perskaityti reikia įdiegti nemokamą programinę įrangą. Norint skaityti šią el. knygą, turite susikurti Adobe ID . Daugiau informacijos  čia. El. knygą galima atsisiųsti į 6 įrenginius (vienas vartotojas su tuo pačiu Adobe ID).

    Reikalinga programinė įranga
    Norint skaityti šią el. knygą mobiliajame įrenginyje (telefone ar planšetiniame kompiuteryje), turite įdiegti šią nemokamą programėlę: PocketBook Reader (iOS / Android)

    Norint skaityti šią el. knygą asmeniniame arba „Mac“ kompiuteryje, Jums reikalinga  Adobe Digital Editions “ (tai nemokama programa, specialiai sukurta el. knygoms. Tai nėra tas pats, kas „Adobe Reader“, kurią tikriausiai jau turite savo kompiuteryje.)

    Negalite skaityti šios el. knygos naudodami „Amazon Kindle“.

Three powerful technologiesRemoting, Reflection, and Threadingare combined in a single book! And when these technologies come together, you are faced with a powerful range of tools that allow you to run code faster, more securely, and more flexibly. (And performance gains are critical in todays industry!) So you'll be able to code applications across the spectrumfrom a single machine to an entire network.



This book begins by discussing the most fundamental of the three techniques: .NET Remoting in Visual Basic .NET, which allows you to customize your application communication processes. The next portion of the book covers reflection, which allows you to examine code at run time, regardless of prior knowledge of its structure. Finally, the book explores threading, which helps break up your application into multiple, independent threads.
About the Author xv
About the Technical Reviewers xvii
Acknowledgments xix
Introduction xxi
Introducing .NET Remoting
1(14)
Distributed Systems
1(5)
Client-Server Models
2(2)
Evolution of Distributed Systems
4(2)
Using .NET Remoting
6(8)
Remote Object Types
7(1)
Context
8(1)
Managing Remote Objects
9(1)
The Remoting Process
10(4)
Summary
14(1)
Remoting Basics
15(28)
.NET Remoting Classes
15(7)
Classes Associated with Marshaling
16(1)
Channel Classes
17(2)
.NET Remoting Code Example
19(3)
Marshaling User-Defined Objects
22(4)
Marshaling User-Defined Objects by Value
22(3)
Marshaling User-Defined Objects by Reference
25(1)
MBR Activation Modes
26(10)
Server-Activated Objects
26(4)
Client-Activated Objects
30(1)
Dynamically Publishing Server-Activated Objects
31(5)
MBR Lifetime Management
36(6)
A Closer Look at Leased-Based Lifetimes
36(2)
Manipulating Leases
38(1)
Renewing Leases
39(3)
Summary
42(1)
Custom Remoting
43(56)
A Closer Look at the Sink Chain
43(5)
Formatter Classes
44(1)
Channel Sink Interfaces and Classes
45(2)
Client Channel Sink Providers
47(1)
Customizing the Sink Chain
48(23)
The Basic Invert Example
48(4)
Adding a New Client Channel Sink
52(7)
Replacing the Formatter Sink
59(3)
Adding a Custom Formatter
62(9)
Custom Serialization
71(12)
Defining a Custom Serialization Format
72(11)
Channels with Custom Transport Protocols
83(15)
Channel Interfaces
83(1)
Implementing a Custom TCP/IP Socket Channel
84(14)
Summary
98(1)
Configuration and Deployment
99(28)
Configuration
99(11)
Standard Configuration File Types
100(1)
Configuration File Structure
100(5)
Loading a Configuration File
105(5)
Deploying Metadata
110(5)
Using Interface-Only Assemblies
111(2)
Using Soapsuds
113(2)
Hosting
115(8)
Hosting in a Windows Service
115(4)
Hosting in IIS
119(4)
Versioning
123(2)
Assigning a Version Number
123(1)
Determining the Version to Use
124(1)
Other Versioning Issues
124(1)
Summary
125(2)
Asynchronous Remoting
127(32)
Simple Asynchronous Remoting
127(11)
Implementing a Slow Synchronous Process
128(2)
Implementing a Slow Asynchronous Process
130(5)
Implementing a Slow Asynchronous Remote Process
135(3)
Using Events with Asynchronous Remote Processes
138(16)
Generating Events in a Single Application Domain
139(2)
Passing Events Between Remote Applications
141(8)
Multiuser Asynchronous Remote Applications
149(5)
Using Call Contexts with Asynchronous Remoting
154(3)
Using Call Contexts in the Teleconference Application
154(3)
Summary
157(2)
Debugging and Error Handling
159(50)
Common Exceptions in Remoting Applications
159(10)
Illustrating Common Remoting Exceptions
160(9)
Diagnosing and Preventing Errors in Remoting Applications
169(22)
Implementing the Bank Application
170(13)
Dealing with Errors in the Client
183(2)
Dealing with Errors in the Remote Object
185(4)
Improving the Bank Application
189(2)
Defining Custom Exception Classes for Remote Objects
191(7)
Defining Exception Classes in the Exception Inheritance Hierarchy
191(1)
Exceptions and Serialization
192(2)
Defining Constructors
194(3)
Defining Informational Properties and Methods
197(1)
Logging Error Information at the Server
198(9)
Logging Errors to a File
198(2)
Logging Errors to a Database
200(3)
Logging Errors to the Windows Event Log
203(4)
Summary
207(2)
Flexible Programming
209(14)
Reflection Defined
209(3)
What Is Reflection For?
210(2)
Type Terminology
212(1)
Binding
213(5)
Early (Static) Binding
213(1)
Runtime Binding
214(1)
Object-Orientation
214(1)
Late Binding
215(3)
Metadata
218(1)
Accessing .NET Metadata
219(2)
Attributes
220(1)
Reflection in .NET
221(1)
Examining Objects
221(1)
Manipulating Objects
221(1)
Creating Objects
221(1)
Summary
221(2)
Examining Assemblies, Objects, and Types
223(28)
Examining Assembly Metadata
223(7)
The Assembly Class
225(5)
Examining Type Metadata
230(4)
Retrieving Types
230(1)
Type Class Members
231(3)
Examining Class Member Metadata
234(16)
The MemberInfo Class
235(3)
The FieldInfo Class
238(2)
The PropertyInfo Class
240(2)
The MethodBase Class
242(1)
The MethodInfo Class
243(2)
The ConstructorInfo Class
245(1)
The EventInfo Class
246(1)
The ParameterInfo Class
247(3)
Summary
250(1)
Using Objects
251(28)
Why Invoke Members Using Reflection?
251(1)
Invoking Members Dynamically
252(20)
Invoking Class Members Using the Info Classes
252(4)
Invoking Class Members Using InvokeMember()
256(16)
Reflective Invocation at a Price
272(6)
Reflection or Delegates?
273(5)
Summary
278(1)
Creating Objects
279(22)
Dynamic Assembly Loading
279(6)
Creating Assembly References
280(2)
Methods Used for Dynamic Assembly Loading
282(1)
Instantiating Classes Dynamically
283(2)
Abstract Factory Pattern
285(15)
Implementing the Abstract Factory Pattern with Dynamic Assembly Loading in VB .NET
289(11)
Summary
300(1)
Attributes
301(42)
Understanding Attributes
302(13)
Syntax for Using Attributes
304(7)
Testing a Data Type for Standard Attributes
311(4)
Using Predefined .NET Attributes
315(17)
Understanding Attribute Class Definitions
316(6)
Using Attributes to Control the Compiler
322(5)
Defining and Using Assembly Attributes
327(5)
Defining New Custom Attributes
332(8)
Summary
340(3)
The .NET Component Model
343(54)
Investigating the .NET Component Model
344(14)
Components, Controls, and Classes
344(1)
Using Reflection with the Component Model
345(13)
Creating New Components
358(37)
Defining a Component Class
359(5)
Storing Components in a Container
364(8)
Using Components in VS .NET
372(3)
Defining Properties and Events for a Component
375(6)
Defining Converter Classes for Components
381(11)
Testing the Final Employee Component Class
392(3)
Summary
395(2)
Defining Threads
397(24)
Threading Defined
397(13)
Multitasking
398(1)
Processes
399(1)
Threads
400(10)
Thread Support in Visual Basic .NET
410(9)
System.AppDomain
411(7)
Thread Management and the .NET Runtime
418(1)
Summary
419(2)
Threading in .NET
421(48)
System.Threading Namespace
421(21)
Thread Class
422(2)
Creating a Thread
424(3)
ThreadStart and Execution Branching
427(2)
Thread Properties and Methods
429(2)
Thread Priorities
431(3)
Timers and Callbacks
434(2)
Spinning Threads with Threads
436(6)
Life Cycle of Threads
442(15)
Putting a Thread to Sleep
443(2)
Interrupting a Thread
445(2)
Pausing and Resuming Threads
447(6)
Destroying Threads
453(2)
Joining Threads
455(2)
Why Not Thread Everything?
457(1)
Threading Opportunities
458(4)
Background Processes
458(3)
Accessing External Resources
461(1)
Threading Traps
462(6)
Execution Order Revisited
463(2)
Threads in a Loop
465(3)
Summary
468(1)
Working with Threads
469(50)
Why Worry About Synchronization?
469(3)
Synchronize Critical Sections
470(1)
Making the Account Object Immutable
471(1)
Using a Thread-Safe Wrapper
472(1)
.NET Synchronization Support
472(1)
.NET Synchronization Strategies
473(25)
Synchronized Contexts
473(1)
Synchronized Code Regions
474(14)
Manual Synchronization
488(10)
Synchronization and Performance
498(1)
Beware of Deadlocks
498(3)
End-to-End Examples
501(17)
Writing Your Own Thread-Safe Wrappers
501(9)
A Database Connection Pool
510(8)
Summary
518(1)
Threading Models
519(16)
Multiple Threads in Applications
519(1)
STA Threading Model
520(1)
MTA Threading Model
521(12)
Specifying the Threading Model
522(1)
Designing Threaded Applications
522(2)
Threads and Relationship
524(9)
Summary
533(2)
Scaling Threaded Applications
535(28)
What Is Thread Pooling?
535(2)
The Need for Thread Pooling
536(1)
The Concept of Thread Pooling
536(1)
The CLR and Threads
537(2)
The Role of the CLR in Thread Pooling
537(1)
Glitches Involved in Thread Pooling
538(1)
The Size of a Thread Pool
538(1)
Exploring the ThreadPool Class
539(3)
Programming the Thread Pool in VB .NET
542(5)
Scalability in .NET
547(14)
A Thread Pool Manager
548(13)
Summary
561(2)
Debugging and Tracing Threads
563(30)
Creating the Application Code
564(1)
Debugging Your Code
564(6)
Visual Studio .NET Debugger
565(3)
Stepping Through the Code
568(1)
Setting Breakpoints
568(2)
Debugging Threads
570(1)
Code Tracing
570(14)
The System.Diagnostics.Trace Class
571(3)
Using Different Listener Applications
574(5)
Tracing Switches
579(4)
The Debug Class
583(1)
The Datalmport Example
584(7)
The Code
584(5)
Testing the Application
589(1)
Logical Errors
589(2)
Summary
591(2)
Networking and Threading
593(26)
Networking in .NET
593(2)
System.Net Namespace
594(1)
System.Net.Sockets Namespace
595(1)
Creating the Sample Application
595(23)
Design Goals
596(1)
Building the Application
597(18)
Running the Applications
615(3)
Summary
618(1)
Index 619


Syed Fahad Gilani has more than 15 years of experience in computing. He sold his first program at the age of 10.
Daugiau apie elektronines knygas Daugiau apie elektronines knygas
Pastovi nuoroda: https://www.kriso.lt/db/97814302002532e.html
Raktažodžiai: