- Programming WCF Services
- Dedication
- A Note Regarding Supplemental Files
- Foreword
- Preface
- 1. WCF Essentials
- What Is WCF?
- Services
- Addresses
- Contracts
- Hosting
- Bindings
- Endpoints
- Metadata Exchange
- More on Behavior Configuration
- Client-Side Programming
- Programmatic Versus Administrative Configuration
- WCF Architecture
- Working with Channels
- Transport-Level Sessions
- Reliability
- 2. Service Contracts
- 3. Data Contracts
- 4. Instance Management
- Behaviors
- Per-Call Services
- Per-Session Services
- Singleton Service
- Demarcating Operations
- Instance Deactivation
- Durable Services
- Throttling
- 5. Operations
- 6. Faults
- 7. Transactions
- The Recovery Challenge
- Transactions
- Transaction Propagation
- Transaction Protocols and Managers
- The Transaction Class
- Transactional Service Programming
- Explicit Transaction Programming
- Service State Management
- Instance Management and Transactions
- Callbacks
- 8. Concurrency Management
- Instance Management and Concurrency
- Service Concurrency Modes
- Instances and Concurrent Access
- Resources and Services
- Resource Synchronization Context
- Service Synchronization Context
- Custom Service Synchronization Contexts
- Callbacks and Client Safety
- Callbacks and Synchronization Contexts
- Asynchronous Calls
- 9. Queued Services
- 10. Security
- Authentication
- Authorization
- Transfer Security
- Identity Management
- Overall Policy
- Scenario-Driven Approach
- Intranet Application Scenario
- Internet Application Scenario
- Business-to-Business Application Scenario
- Anonymous Application Scenario
- No Security Scenario
- Scenarios Summary
- Declarative Security Framework
- Security Auditing
- 11. The Service Bus
- What Is a Relay Service?
- Programming the Service Bus
- The Service Bus Bindings
- Cloud as Interceptor
- Service Bus Buffers
- Service Bus Authentication
- Transfer Security
- A. Introduction to Service Orientation
- B. Headers and Contexts
- C. Discovery
- D. Publish-Subscribe Service
- E. Generic Interceptor
- F. WCF Coding Standard
- G. ServiceModelEx Catalog
- CollectionExtensions
- ArrayExtensions
- InProcFactory<S,I>
- WcfWrapper<S,I>
- ServiceHost<T>
- MetadataHelper
- DataContractSerializer<T>
- GenericResolver, GenericResolverBehaviorAttribute, GenericResolverInstaller
- ServiceThrottleHelper
- IInstanceStore<ID,T>
- FileInstanceStore<ID,T>, FilePersistenceProvider, FilePersistenceProviderFactory
- MemoryProvider, MemoryProviderFactory
- TransactionalMemoryStore<ID,T>, TransactionalMemoryProvider, TransactionalMemoryProviderFactory
- TransactionalInstanceStore<ID,T>, TransactionalInstanceProvider, TransactionalInstanceProviderFactory
- InstanceContext<T>, DuplexClientBase<T,C>, DuplexChannelFactory<T,C>
- DebugHelper
- ErrorHandlerHelper
- ErrorHandlerBehaviorAttribute, CallbackErrorHandlerBehaviorAttribute
- ILogbookManager, LogbookManagerClient, LogbookManager
- BindingRequirementAttribute
- ResourceManager, TransactionalLock
- Transactional<T>
- TransactionalCollection<C,T>
- TransactionalArray<T>, TransactionalDictionary<K,T>, TransactionalLinkedList<T>, TransactionalList<T>, TransactionalQueue<T>, TransactionalSortedDictionary<K,T>, Tr
- TransactionalBehaviorAttribute
- AsyncOneWayClientBase<T>
- FormHost<F>
- SafeButton, SafeLabel, SafeListBox, SafeProgressBar, SafeStatusBar, SafeTextBox, SafeTrackBar
- ThreadPoolSynchronizer, ThreadPoolBehaviorAttribute, CallbackThreadPoolBehaviorAttribute, ThreadPoolHelper
- AffinitySynchronizer, ThreadAffinityBehaviorAttribute, CallbackThreadAffinityBehaviorAttribute, HostThreadAffinity
- PrioritySynchronizer, PriorityClientBase<T>, PriorityContext, PriorityCallsBehaviorAttribute
- QueuedServiceHelper
- ClientResponseBase<T>, ServiceResponseBase<T>, ResponseContext
- CredentialsManager, AspNetSqlProviderService
- SecureClientBase<T>, SecureDuplexClientBase<T,C>, SecurityBehaviorAttribute, SecurityHelper, ServiceSecurity
- IServiceBusProperties
- ServiceBusHelper
- ServiceBusHost, ServiceBusClientBase<T>, ServiceBusDuplexClientBase<T,C>
- DiscoverableServiceHost, IServiceBusDicovery, IServiceBusDiscoveryCallback, ServiceBusDiscoveryClient, ServiceBusDiscoveryFactory, ServiceBusDiscoveryHelper, IServiceBusAnnouncements, ServiceBusAnnoun
- OneWayClientBase<T>
- BufferedServiceBusHost<T>, BufferedServiceBusClient<T>, BufferedServiceBusChannelFactory<T>
- ClientBufferResponseBase<T>, ServiceBufferResponseBase<T>
- ServiceBusMetadataHelper
- HeaderClientBase<T,H>, HeaderChannelFactory<T,H>, GenericContext<T>
- ContextClientBase<T>, ContextManager
- NetNamedPipeContextBinding, NetNamedPipeContextBindingElement, NetNamedPipeContextBindingCollectionElement
- DiscoveryHelper
- DiscoveryFactory
- AddressesContainer<T>
- AnnouncementSink<T>
- DiscoveredServices<T>
- PersistentSubscriptionServiceClient, IPersistentSubscriptionService, ISubscriptionService, PersistentSubscription, PublishService<T>, SubscriptionManager<T>, PersistentSubscriptionManager
- ServiceBusEventsHost, ServiceBusEventsClientBase<T>
- DiscoveryPublishService <T>
- GenericInvoker, OperationInterceptorBehaviorAttribute, ServiceInterceptorBehaviorAttribute
- InterceptorClientBase<T>, InterceptorChannelFactory<T>
- SecurityCallFrame, SecurityCallStack, SecurityCallStackContext, SecurityCallStackClientBase<T>, SecurityCallStackInterceptor, OperationSecurityCallStackAttribute, SecurityCallStackBehaviorAttrib
- Index
- About the Author
- Colophon
- Copyright
As with a connected service, the ConcurrencyMode property governs concurrent
playback of queued messages. With a per-call service, all queued
messages are played at once to different instances as fast as they come
off the queue, up to the limit of the configured throttle. There is no
need to configure for reentrancy to support callbacks, because the
operation contexts can never have callback references. There is also no
need to configure for multiple concurrent access, because no two
messages will ever share an instance. In short, with a queued per-call
service, the concurrency mode is ignored.
When it comes to a sessionful queued service, you are required to
configure the service with ConcurrencyMode.Single. The reason is that it
is the only concurrency mode that allows you to turn off
auto-completion, which is essential to maintain the session semantic. The calls in the message are
always played to the same service instance, one at a time.
A queued singleton is really the only instancing mode that has any
leeway with its concurrency mode. If the singleton is configured with
ConcurrencyMode.Single, WCF will
retrieve the messages all at once from the queue (up to the thread pool
and throttling limits) and then queue up the calls in the internal queue
the context lock maintains. Calls will be dispatched to the singleton
one at a time. If the singleton is configured with ConcurrencyMode.Multiple, WCF will retrieve
the messages all at once from the queue (up to the thread pool and
throttling limits) and play them concurrently to the singleton.
Obviously, in that case the singleton must provide for synchronized
access to its state. If the singleton is also transactional, it is prone
to transactional deadlocks over prolonged isolation maintained
throughout each transaction.
Queued calls have a nasty side effect of excelling at turning a low level of load into a high level of stress. Imagine an offline queued service that sustained relatively low load, such as a call per minute for one day. Once the host is launched, WCF flushes the queued calls (all 1,440 of them) to the service all at once, subjecting it to high stress. The fact that there are over 1,000 messages in the queue does not mean that your design supports 1,000 concurrent instances and calls.
Throttling a queued service is your way of controlling the
stress on the service and avoiding turning load into stress. The
important value to throttle is the number of concurrent playbacks.
This is an effective way of throttling the number of played messages,
because if the maximum number of concurrent calls is exceeded (overall
stress), the excess messages will stay in the queue. With a per-call
service, the throttle controls the overall number of allowed
concurrent instances (and their implied resource consumption). With a
per-session service, the throttle controls the number of allowed
sessions. In the case of a queued singleton, you can combine a
throttle value with ConcurrencyMode.Multiple to control just how
many concurrent players are allowed (stress) and how many messages to
keep in the queue (buffered load).
-
No Comment