<span xmlns="" class="firstname">Mark</span> <span xmlns="" class="surname">Pollack</span> - The Spring.NET Framework

Download the archived PDF

The Spring.NET Framework
Preface
Introduction
Overview
Background
Modules
Usage Scenarios
Quickstart applications
License Information
Support
Background information
Inversion of Control
Migrating from 1.1 M2
Introduction
Important Changes
Namespaces
Core
Web
Data
Core Technologies
The IoC container
Introduction
Basics - containers and objects
The container
Configuration metadata
Instantiating a container
Composing XML-based configuration metadata
The Objects
Naming objects
Aliasing objects
Object creation
Object creation via constructor invocation
Object creation via a static factory method
Object creation via an instance factory method
Object creation of generic types
Object creation of generic types via constructor invocation
Object creation of generic types via static factory method
Object creation of generic types via instance factory method
Using the container
Dependencies
Injecting dependencies
Constructor Injection
Constructor Argument Resolution
Constructor Argument Type Matching
Constructor Argument Index
Constructor Arguments by Name
Setter Injection
Some examples
Dependencies and configuration in detail
Straight values (primitives, strings, etc.)
The idref element
Whitespace Handling
Referring to collaborating objects
Inline objects
Setting collection values
Setting generic collection values
Setting null values
Setting indexer properties
Value and ref shortcut forms
Compound property names and Spring expression references
Declarative Event Listener Registration
Declarative event handlers
Configuring a method to be invoked when an event is fired
Registering a collection of handler methods based on a regular expression
Registering a handler method against an event name that contains a regular expression
Using depends-on
Lazily-instantiated objects
Autowiring collaborators
Checking for dependencies
Method Injection
Lookup Method Injection
Arbitrary method replacement
Setting a reference using the members of other objects and classes.
Setting a reference to the value of property.
Setting a reference to the value of field.
Setting a property or constructor argument to the return value of a method invocation.
Provided IFactoryObject implementations
Common logging
Object Scopes
The singleton scope
The prototype scope
Singleton objecgts with prototype-object dependencies
The other scopes
Type conversion
Type Conversion for Enumerations
Built-in TypeConverters
Custom Type Conversion
Using CustomConverterConfigurer
Customizing the nature of an object
Lifecycle interfaces
IInitializingObject / init-method
IDisposable / destroy-method
Knowing who you are
IObjectFactoryAware
IObjectNameAware
Object definition inheritance
Interacting with the container
Obtaining an IFactoryObject, not its product
Container extension points
Customizing objects with IObjectPostProcessors
Example: Hello World, IObjectPostProcessor-style
Example: the RequiredAttributeObjectPostProcessor
Customizing configuration metadata with ObjectFactoryPostProcessors
Example: The PropertyPlaceholderConfigurer
Type, Ref, and Expression substitution
Replacement with Environment Variables
Example: The PropertyOverrideConfigurer
IVariableSource
Customizing instantiation logic using IFactoryObjects
IConfigurableFactoryObject
The IApplicationContext
IObjectFactory or IApplicationContext?
Configuration of IApplicationContext
Registering custom parsers
Registering custom resource handlers
Registering Type Aliases
Registering Type Converters
Added functionality of the IApplicationContext
Context Hierarchies
Using IMessageSource
Using resources within Spring.NET
Loosely coupled events
Event notification from IApplicationContext
Customized behavior in the ApplicationContext
The IApplicationContextAware marker interface
The IObjectPostProcessor
The IObjectFactoryPostProcessor
The PropertyPlaceholderConfigurer
Configuration of ApplicationContext without using XML
Service Locator access
Stereotype attributes
The IObjectWrapper and Type conversion
Introduction
Manipulating objects using the IObjectWrapper
Setting and getting basic and nested properties
Other features worth mentioning
Type conversion
Type Conversion for Enumerations
Built-in TypeConverters
Custom type converters
Resources
Introduction
The IResource interface
Built-in IResource implementations
Registering custom IResource implementations
The IResourceLoader
The IResourceLoaderAware interface
Application contexts and IResource paths
Threading and Concurrency Support
Introduction
Thread Local Storage
Synchronization Primitives
ISync
SyncHolder
Latch
Semaphore
Object Pooling
Introduction
Interfaces and Implementations
Spring.NET miscellanea
Introduction
PathMatcher
General rules
Matching filenames
Matching subdirectories
Case does matter, slashes don't
Expression Evaluation
Introduction
Evaluating Expressions
Language Reference
Literal expressions
Properties, Arrays, Lists, Dictionaries, Indexers
Defining Arrays, Lists and Dictionaries Inline
Methods
Operators
Relational operators
Logical operators
Mathematical operators
Assignment
Expression lists
Types
Type Registration
Constructors
Variables
The '#this' and '#root' variables
Ternary Operator (If-Then-Else)
List Projection and Selection
Collection Processors and Aggregators
Count Aggregator
Sum Aggregator
Average Aggregator
Minimum Aggregator
Maximum Aggregator
Non-null Processor
Distinct Processor
Sort Processor
Type Conversion Processor
Reverse Processor
OrderBy Processor
User Defined Collection Processor
Spring Object References
Lambda Expressions
Delegate Expressions
Null Context
Classes used in the examples
Validation Framework
Introduction
Example Usage
Validator Groups
Validators
Condition Validator
Required Validator
Regular Expression Validator
Generic Validator
Conditional Validator Execution
Validator Actions
Error Message Action
Generic Actions
Validator References
Progammatic usage
Usage tips within ASP.NET
Rendering Validation Errors
Configuring which Error Renderer to use.
Aspect Oriented Programming with Spring.NET
Introduction
AOP concepts
Spring.NET AOP capabilities
AOP Proxies in Spring.NET
Pointcut API in Spring.NET
Concepts
Operations on pointcuts
Convenience pointcut implementations
Static pointcuts
Regular expression pointcuts
Attribute pointcuts
Dynamic Pointcuts
Control Flow Pointcuts
Custom pointcuts
Advice API in Spring.NET
Advice Lifecycle
Advice types
Interception Around Advice
Before advice
Throws advice
After Returning advice
Advice Ordering
Introduction advice
Advisor API in Spring.NET
Using the ProxyFactoryObject to create AOP proxies
Basics
ProxyFactoryObject Properties
Proxying Interfaces
Proxying Classes
Concise proxy definitions
Proxying mechanisms
InheritanceBasedAopConfigurer
Creating AOP Proxies Programatically with the ProxyFactory
Manipulating Advised Objects
Using the "autoproxy" facility
Autoproxy object definitions
ObjectNameAutoProxyCreator
DefaultAdvisorAutoProxyCreator
PointcutFilteringAutoProxyCreator
TypeNameAutoProxyCreator
AttributeAutoProxyCreator
AbstractFilteringAutoProxyCreator
AbstractAutoProxyCreator
Using attribute-driven auto-proxying
Using AOP Namespace
Using TargetSources
Hot swappable target sources
Pooling target sources
Prototype target sources
ThreadLocal target sources
Defining new Advice types
Further reading and resources
Aspect Library
Introduction
Caching
Exception Handling
Language Reference
Logging
Retry
Language Reference
Transactions
Parameter Validation
Common Logging
Introduction
Testing
Introduction
Unit testing
Integration testing
Context management and caching
Dependency Injection of test fixtures
Field level injection
Transaction management
Convenience variables
Unknown
Further Resources
Middle Tier Data Access
Transaction management
Introduction
Motivations
Key Abstractions
Resource synchronization with transactions
High-level approach
Low-level approach
Declarative transaction management
Understanding Spring's declarative transaction implementation
A First Example
Declarative transactions using the transaction namespace
Transaction attribute settings
Declarative Transactions using AutoProxy
Creating transactional proxies with ObjectNameAutoProxyCreator
Creating transactional proxies with DefaultAdvisorAutoProxyCreator
Declarative Transactions using TransactionProxyFactoryObject
Concise proxy definitions
Declarative Transactions using ProxyFactoryObject
Programmatic transaction management
Using the TransactionTemplate
Specifying transaction settings
Using the PlatformTransactionManager
Choosing between programmatic and declarative transaction management
Transaction lifecycle and status information
DAO support
Introduction
Consistent exception hierarchy
Consistent abstract classes for DAO support
DbProvider
Introduction
IDbProvider and DbProviderFactory
XML based configuration
Connection String management
Additional IDbProvider implementations
UserCredentialsDbProvider
MultiDelegatingDbProvider
Data access using ADO.NET
Introduction
Motivations
Provider Abstraction
Creating an instance of IDbProvider
Namespaces
Approaches to Data Access
Introduction to AdoTemplate
Execute Callback
Execute Callback in .NET 2.0
Execute Callback in .NET 1.1
Quick Guide to AdoTemplate Methods
Quick Guide to AdoTemplate Properties
Transaction Management
Exception Translation
Parameter Management
IDbParametersBuilder
IDbParameters
Custom IDataReader implementations
Basic data access operations
ExecuteNonQuery
ExecuteScalar
Queries and Lightweight Object Mapping
ResultSetExtractor
RowCallback
RowMapper
Query for a single object
Query using a CommandCreator
DataTable and DataSet
DataTables
DataSets
TableAdapters and participation in transactional context
Database operations as Objects
AdoQuery
MappingAdoQuery
AdoNonQuery
Stored Procedure
Object Relational Mapping (ORM) data access
Introduction
NHibernate
Resource management
Transaction Management
SessionFactory set up in a Spring container
The HibernateTemplate
Implementing Spring-based DAOs without callbacks
Implementing DAOs based on plain Hibernate 1.2/2.0 API
Exception Translation
Programmatic transaction demarcation
Declarative transaction demarcation
Transaction management strategies
Web Session Management
Session Scope
The Web
Spring.NET Web Framework
Introduction
Background
Automatic context loading and hierarchical contexts
Configuration
Configuration for IIS7
Context Hierarchy
Dependency Injection for ASP.NET Pages
Injecting Dependencies into Controls
Injecting dependencies into custom HTTP modules
Injecting dependencies into HTTP handlers and handler factories
Injecting dependencies into custom providers
Customizing control dependency injection
Web object scopes
Master Pages in ASP.NET 1.1
Linking child pages to their master
Bidirectional Data Binding and Model Management
Data Binding Under the Hood
Binding Direction
Formatters
Type Conversion
Data Binding Events
Rendering Binding Errors
HttpRequestListBindingContainer
Using DataBindingPanel
Customizing Model Persistence
Localization and Message Sources
Automatic Localization Using Localizers ("Push" Localization)
Global Message Sources
Working with Localizers
Applying Resources Manually ("Pull" Localization)
Localizing Images within a Web Application
User Culture Management
DefaultWebCultureResolver
RequestCultureResolver
SessionCultureResolver
CookieCultureResolver
Changing Cultures
Result Mapping
Registering user defined transfer modes
Client-Side Scripting
Registering Scripts within the head HTML section
Adding CSS Definitions to the head Section
Well-Known Directories
Spring User Controls
Validation Controls
Databinding Controls
Calendar Control
Panel Control
ASP.NET AJAX
Introduction
Web Services
Exposing Web Services
Calling Web Services by using JavaScript
Services
Introduction to Spring Services
Introduction
.NET Remoting
Introduction
Publishing SAOs on the Server
SAO Singleton
SAO SingleCall
IIS Application Configuration
Accessing a SAO on the Client
CAO best practices
Registering a CAO object on the Server
Applying AOP advice to exported CAO objects
Accessing a CAO on the Client
Applying AOP advice to client side CAO objects.
XML Schema for configuration
Additional Resources
.NET Enterprise Services
Introduction
Serviced Components
Server Side
Client Side
Web Services
Introduction
Server-side
Removing the need for .asmx files
Injecting dependencies into web services
Exposing PONOs as Web Services
Exporting an AOP Proxy as a Web Service
Client-side
Using VS.NET generated proxy
Generating proxies dynamically
Configuring the proxy instance
Windows Communication Foundation (WCF)
Introduction
Configuring WCF services via Dependency Injection
Dependency Injection
Apply AOP advice to WCF services
Creating client side proxies declaratively
Exporting PONOs as WCF Services
Integration
Message Oriented Middleware - Apache ActiveMQ
Introduction
Separation of Concerns
Interoperability and provider portability
The role of Messaging API in a 'WCF world'
Using Spring Messaging
Messaging Template overview
Connections
Caching Messaging Resources
SingleConnectionFactory
CachingConnectionFactory
Destination Management
Message Listener Containers
Transaction Management
Sending a Message
Using MessageConverters
Session and Producer Callback
Receiving a message
Synchronous Reception
Asynchronous Reception
The ISessionAwareMessageListener interface
MessageListenerAdapater
Processing messages within a messaging transaction
Messaging Namespace support
Message Oriented Middleware - MSMQ
Introduction
A quick tour for the impatient
Using Spring MSMQ
MessageQueueTemplate
MessageQueueFactoryObject
MessageQueue and IMessageConverter resource management
Message Listener Containers
NonTransactionalMessageListenerContainer
TransactionalMessageListenerContainer
DistributedTxMessageListenerContainer
MessageConverters
Using MessageConverters
Interface based message processing
Unknown
MessageListenerAdapater
Comparison with using WCF
Scheduling and Thread Pooling
Introduction
Using the Quartz.NET Scheduler
Using the JobDetailObject
Using the MethodInvokingJobDetailFactoryObject
Wiring up jobs using triggers and the SchedulerFactoryObject
VS.NET Integration
Visual Studio.NET Integration
XML Editing and Validation
Versions of XML Schema
Integrated API help
Quickstart applications
IoC Quickstarts
Introduction
Movie Finder
Getting Started - Movie Finder
First Object Definition
Setter Injection
Constructor Injection
Summary
Logging
ApplicationContext and IMessageSource
Introduction
ApplicationContext and IEventRegistry
Introduction
Pooling example
Implementing Spring.Pool.IPoolableObjectFactory
Being smart using pooled objects
Using the executor to do a parallel grep
AOP
AOP Guide
Introduction
The basics
Applying advice
Using Pointcuts - the basics
Going deeper
Other types of Advice
Before advice
After advice
Throws advice
Introductions (mixins)
Layering advice
Configuring advice
Using Attributes to define Pointcuts
The Spring.NET AOP Cookbook
Caching
Performance Monitoring
Retry Rules
Spring.NET AOP Best Practices
Portable Service Abstraction Quick Start
Introduction
.NET Remoting Example
Implementation
Running the application
Remoting Schema
.NET Enterprise Services Example
Web Services Example
Additional Resources
Web Quickstarts
Introduction
SpringAir - Reference Application
Introduction
Getting Started
Container configuration
Bi-directional data binding
Declarative Validation
Internationalization
Web Services
Data Access QuickStart
Introduction
Database configuration
AdoTemplate Configuration
CommandCallback
Transactions QuickStart
Introduction
Application Overview
Interfaces
Implementation
Configuration
Rollback Rules
Adding additional Aspects
NHibernate QuickStart
Introduction
Quartz QuickStart
Introduction
Application Overview
Standard job scheduling
Scheduling arbitrary methods as jobs
NMS QuickStart
Introduction
Message Destinations
Gateways
Message Data
Message Handlers
Message Converters
Messaging Infrastructure
Running the application
MSMQ QuickStart
Introduction
Message Destinations
Gateways
Message Data
Message Handlers
MessageConverters
Messaging Infrastructure
Running the application
WCF QuickStart
Introduction
The server side
WCF Dependency Injection and AOP in self-hosted application
WCF Dependency Injection and AOP in IIS web application
Client access
Spring.NET for Java developers
Spring.NET for Java Developers
Introduction
Beans to Objects
PropertyEditors to TypeConverters
ResourceBundle-ResourceManager
Exceptions
Application Configuration
AOP Framework
Cannot specify target name at the end of interceptorNames for ProxyFactoryObject
XML Schema-based configuration
Introduction
XML Schema-based configuration
Referencing the schemas
The tx (transaction) schema
The aop schema
The db schema
The remoting schema
The nms messaging schema
The validation schema
The objects schema
Setting up your IDE
Extensible XML authoring
Introduction
Authoring the schema
Coding a INamespaceParser
Coding an IObjectDefinitionParser
Registering the handler and the schema
NamespaceParsersSectionHandler
Using a custom extension in your Spring XML configuration
Further Resources
Spring.NET's spring-objects.xsd

<span xmlns="" class="firstname">Mark</span> <span xmlns="" class="surname">Pollack</span> - The Spring.NET Framework

Table of contents