C

Index

[SYMBOL] [A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Z]

C language, pointers 2nd
C#
     choosing between Visual Basic and
     coding standard
         coding practices
         framework-specific guidelines
         naming conventions and styles
         project settings and structure
         remoting
         security
         serialization 2nd
     global namespace
     inheritance directives
     interface (reserved word)
     library assembly, creating in Visual Studio 2005
     lock statement
     params modifier 2nd
     partial types
C++
     .NET vs.
     function objects, delegates as
     memory de-allocation and object destruction
     templates, generics vs.
caching (native image cache)
call authorization
callbacks
     AsyncCallback parameter
     asynchronous stream read with
     channel registration for
     channeling multiple method completions to one callback
     client-side channel registration
     error handling
     IDeserializationCallback interface
     naming conventions
     passing state information
     remote
         error handling
         example
         metadata and
         registering channels
         type filtering and
     thread safety and 2nd
     TimerCallback
     WaitCallback delegate
CancelAsync( ) (BackgroundWorker)
caspol.exe utility
casting
     explicit casts to IDisposable
     generic interfaces and 2nd
     implicit casts to IDisposable
     interfaces and type safety
certificates
     managing
     Trusted Publishers
     Untrusted Certificates list
channel registration
channels
     administrative registration
     administrative remoting configuration (example)
     CrossAppDomainChannel class
     CrossContextChannel class 2nd
     custom, registering
     defined
     formats and
     formatters and
     host channel registration
     IIS and
     leases and
     registering callback channels
     registration for sponsors
     type filtering, remote callbacks and
ChannelServices class
     RegisterChannel( )
     UnregisterChannel( )
class constraint, generics
class factories 2nd 3rd
     separate synchronization domains and
class hierarchies
     in object-oriented programming
     interfaces and
     serialization and
         base classes and custom serialization
     serialization events and
     template implementing Dispose( ) and Finalize( )
class libraries
     adding references
         example
     client assembly using (example)
     composing assemblies, rules for
     ContextLogger, contents of
class library assemblies
     multi-file, avoiding with modules not containing IL
class members
     generic reflection (Type)
     internal and public access modifiers
     nonserializable
     readonly, initialization after deserialization
    static
         protecting for Monitor class
         remoting and
classes
     .NET base classes
     .NET, as binary components
     abstract, interfaces vs.
     delegate
     DLLs and assemblies vs.
     implementing multiple interfaces
     order of definition in .NET
     permission
     permission set
     security
     source files
     split across multiple files
     System.Object
ClickOnce applications
     client-side, security policy
     permissions
     security, administering
         trusting publishers
         versioning and
client and server
     binary compatibility between 2nd
     separation into different assemblies
client app domain
Client application, registering channels with
client assemblies
client channels registration, specifying formatter on sink interface
client context sinks
Client EXE assembly
     example
     for distributed application
client-activated objects 2nd 3rd
     client-side type registration
     creating with CreateInstance( ) (Activator)
     host type registration 2nd
     hosting with IIS
     leasing
     synchronization and
     type registration (example)
     URLs for remote objects
client-side custom security policy
client-side processing
client-side sinks
client-side type registration 2nd
client/server model
     marshaling by value and
clients
     adding a reference to server assembly
     asynchronous method calls
     Close( ), problems with
     Dispose( ) method, problems with
     hiding information from (encapsulation)
     leases and
ClientSponsor class
Clipboard, use by COM interop
Clone( ) (SerializationUtil)
Close( )
     Timer class
     use in deterministic finalization
CLR (Common Language Runtime)
     .NET programming languages
     choosing a .NET language
     CLR assemblies, requirement for
     generics, native support of
     intermediate language and JIT compiler
     language independence of .NET components
     versioning
         default version binding
         side-by-side execution
         specifying supported CLR versions
         version unification
code groups
     configuring permissions
     custom server-side security policy
     custom, configuring permissions
     Exclusive instruction
     Internet
     Intranet, configuring permissions
     Level Final instruction
     Restricted_Zone, default permissions
     Trusted_Zone
code origin
code refactoring (interfaces)
CodeAccessPermission class
     RevertAll( )
     RevertAssert( )
     RevertDeny( )
     reverting stack walk modifier set by permission set
     RevertPermitOnly( )
     static reversion methods
CoInitializeEx( )
Collect( ) (GC class)
COM
     .NET vs.
     apartments
     asynchronous
     binary compatibility
     complexity of, .NET vs.
     component deployment
     DCOM
     DLL Hell and
     interfaces
     memory deallocation and object destruction
     packaging and deployment of components
     QueryInterface( ) method
     singletons, support of
     surrogate process provided to in-process DLL
     type libraries vs. metadata
COM+
     Component Services Explorer
     context attributes
     context-agile objects
     same-context calls
Combine( ) (Delegate)
compacting the heap
CompareExchange( ) (Interlocked)
compilation, native image
compilers
     CLR and
     enforcing type safety with implicit casts
     generation of assembly manifest
     roots list, update of
     safe points, insertion into code
     volatile fields, handling of
Complete( ) (TransactionScope)
completion port threads
component services 2nd
     custom
         building custom context attribute
         installing custom message sink
         logbook service (example)
         transaction management service
     types
Component Services Explorer
component-oriented programming 2nd
     .NET adherence to principles
     asynchronous calls support
     basic terminology
     binary compatibility 2nd
     building blocks vs. monolithic applications
     components (classes)
     concurrency management 2nd
     developing .NET components
         base classes
         declarative programming
         security
         simplified deployment
     interface separation from implementation
     interfaces vs. inheritance
     language independence 2nd
     location transparency 2nd
     object-oriented vs. 2nd
     principles, listed
     security
         benefits of .NET infrastructure
         code origin and
     security model
     serialization, importance of
     type discovery
     versioning support
components
     BackgroundWorker
     Component class (Logbook example)
     context-bound, synchronized access to
     defined
     defined in another assembly, using
     inheritance in
     instances of (objects)
     modifying and updating
     packaging in library assemblies
     synchronous vs. asynchronous processing
     thread-safe
     threads and
     version control and DLL Hell
     visibility, managing in assemblies
concurrency management service
Conditional attribute
configuration
     lease and lease manager properties, global defaults for
     security
configuration files
     administrative remoting configuration example
     application
     generating automatically
     machine-wide (machine.config)
Configuration tool (.NET)
     application configuration file
     application custom policy
     custom permission assembly, registering
     custom version binding policy
     Everything permission set
     global custom policies for assemblies
     managing GAC
     remoting support, shortcomings of
     security administration utilities
         adjusting security
         evaluating an assembly
         exporting security policies
         managing policy files
         resetting policies
         trusting an assembly
     security policy configuration 2nd
     security, code groups
     SecurityManager vs.
Configure( ) (RemotingConfiguration) 2nd 3rd 4th
Configured Assemblies folder
Connect( ) (RemotingServices) 2nd
constraints
     generic
         class/struct
         constructor
         derivation
     generic derivation
     interface-level, for generic types
     serialization
constructors
     attributes
     channel classes
     custom serialization and base classes
     deserialization
     generic, constraints
     PrincipalPermission attribute and
     server-activated singletons
constructs, strict typing in .NET
content-based security evidence
     superiority to origin-based
context attributes, custom
     UML activity diagram of process flow
context-agile objects 2nd 3rd
context-bound objects 2nd 3rd
     client access in same-context calls
     client context sinks and
     custom context attributes
     declarative transaction support
     multiple context attributes, conflicts in
     remoting and
     synchronization domain
context-bound services
ContextAttribute class 2nd
ContextBoundObject class 2nd
     ServicedComponent subclass
     Synchronization attribute
ContextID property
ContextLogger class library
contexts 2nd
     .NET
         assigning objects to
         call interception architecture
         Context class
         context ID
         context object associated with
         context-bound objects and remoting
         same-context calls
     component services
     custom component services
         custom context attribute
         installing custom message sink
         logbook service (example)
         transaction management service
     defined
     Indigo
     object types and
     properties associated with
     synchronization
     synchronization domains and
Control class
controls
     commonly-used, source code
     reliance on Windows messages and message pump
     SafeLabel class (example)
CORBA
cost of long-term maintenance
CPU architectures
     assemblies and
     JIT compilation and
CPU-bound operations
CreateDomain( ) (AppDomain)
CreateInstance( )
     Activator class 2nd
     AppDomain class
CreateInstanceAndUnwrap( ) (AppDomain) 2nd 3rd
CreateWaitableTimer( ) function (Win32 API)
CrossAppDomainChannel class
     leases and
CrossContextChannel class 2nd 3rd
cryptographic hash of assembly modules
cryptography
     hashing algorithms
     public/private encryption keys for strong names
current lease time property
CurrentDomain property (AppDomain)
CurrentPrincipal property (Thread) 2nd
CurrentState property (ILease)
CurrentThread property (Thread class)
custom attributes
custom codebase binding policy
custom context attributes
custom deserialization constructor
custom event arguments, defining
custom permissions
     Trusted_Same_Site_Access code group
CustomPrincipal class (example)
cyclic references, serialization and