Spring.NET 1.3.0 RC1 for .NET 2.0 API Reference

IInitializingObject Interface

Defines a simple initialization callback for objects that need to to some post-initialization logic after all of their dependencies have been injected.

For a list of all members of this type, see IInitializingObject Members .

[Visual Basic]
Public Interface IInitializingObject
[C#]
public interface IInitializingObject

Types that implement IInitializingObject

Type Description
DefaultAdvisorAutoProxyCreator ObjectPostProcessor implementation that creates AOP proxies based on all candidate Advisors in the current IObjectFactory. This class is completely generic; it contains no special code to handle any particular aspects, such as pooling aspects.
AbstractPoolingTargetSource Abstract superclass for pooling ITargetSources.
AbstractPrototypeTargetSource Base class for dynamic ITargetSource implementations that can create new prototype object instances to support a pooling or new-instance-per-invocation strategy.
PrototypeTargetSource ITargetSource implementation that creates a new instance of the target object for each request.
SimplePoolTargetSource Pooling target source implementation based on the SimplePool
ThreadLocalTargetSource ITargetSource implementation that uses a threading model in which every thread has its own copy of the target.
AbstractExceptionHandlerAdvice This is
ExceptionHandlerAdvice Exception advice to perform exception translation, conversion of exceptions to default return values, and exception swallowing. Configuration is via a DSL like string for ease of use in common cases as well as allowing for custom translation logic by leveraging the Spring expression language.
RetryAdvice AOP Advice to retry a method invocation on an exception. The retry semantics are defined by a DSL of the form
on exception name [ExceptionName1,ExceptionName2,...] retry [number of times] [delay|rate] [delay time|rate expression]
. For example,
on exception name ArithmeticException retry 3x delay 1s
ResourceSetMessageSource An IMessageSource implementation that accesses resources from .resx / .resource files.
DaoSupport Generic base class for DAOs, defining template methods for DAO initialization.
PersistenceExceptionTranslationInterceptor AOP MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator.
DbProviderFactoryObject A IFactoryObject implementation that creates instances of the IDbProvider class.
DelegatingDbProvider IDbProvider implementation that delegates all calls to a given target IDbProvider
UserCredentialsDbProvider An adapter for a target IDbProvider, applying the specified user credentials to the connection string for every GetConnection call.
AdoAccessor Base class for AdoTemplate and other ADO.NET DAO helper classes defining common properties like DbProvider.
AdoDaoSupport Convenient super class for ADO.NET data access objects.
AdoPlatformTransactionManager ADO.NET based implementation of the IPlatformTransactionManager interface.
AdoTemplate This is the central class in the Spring.Data namespace. It simplifies the use of ADO.NET and helps to avoid commons errors.
ServiceDomainPlatformTransactionManager Transaction Manager that uses EnterpriseServices to access the MS-DTC. It requires the support of 'Services without Components' functionality which is available on Win 2003 and Win XP SP2.
TxScopeTransactionManager TransactionManager that uses TransactionScope provided by System.Transactions.
AdoDaoSupport Convenient super class for ADO.NET data access objects using generics.
AdoTemplate This is the central class in the Spring.Data.Generic namespace. It simplifies the use of ADO.NET and helps to avoid commons errors.
MultiDelegatingDbProvider A wrapper implementation for IDbProvider such that multiple DbProvider instances can be selected at runtime, say based on web request criteria.
FilterDefinitionFactoryObject Convenient FactoryObject for defining Hibernate FilterDefinitions. Exposes a corresponding Hibernate FilterDefinition object.
FilterDefinitionFactoryObject Convenient FactoryObject for defining Hibernate FilterDefinitions. Exposes a corresponding Hibernate FilterDefinition object.
HibernateTemplate Generic version of the Helper class that simplifies NHibernate data access code
HibernateTemplate Generic version of the Helper class that simplifies NHibernate data access code
HibernateTemplate Generic version of the Helper class that simplifies NHibernate data access code
HibernateDaoSupport Convenient super class for Hibernate data access objects.
HibernateDaoSupport Convenient super class for Hibernate data access objects.
HibernateDaoSupport Convenient super class for Hibernate data access objects.
HibernateAccessor Base class for HibernateTemplate defining common properties like SessionFactory and flushing behavior.
HibernateAccessor Base class for HibernateTemplate defining common properties like SessionFactory and flushing behavior.
HibernateAccessor Base class for HibernateTemplate defining common properties like SessionFactory and flushing behavior.
HibernateTemplate Helper class that simplifies NHibernate data access code
HibernateTemplate Helper class that simplifies NHibernate data access code
HibernateTemplate Helper class that simplifies NHibernate data access code
HibernateTransactionManager PlatformTransactionManager implementation for a single Hibernate SessionFactory. Binds a Hibernate Session from the specified factory to the thread, potentially allowing for one thread Session per factory
HibernateTransactionManager PlatformTransactionManager implementation for a single Hibernate SessionFactory. Binds a Hibernate Session from the specified factory to the thread, potentially allowing for one thread Session per factory
HibernateTransactionManager PlatformTransactionManager implementation for a single Hibernate SessionFactory. Binds a Hibernate Session from the specified factory to the thread, potentially allowing for one thread Session per factory
LocalSessionFactoryObject An IFactoryObject that creates a local Hibernate SessionFactory instance. Behaves like a SessionFactory instance when used as bean reference, e.g. for HibernateTemplate's "SessionFactory" property.
LocalSessionFactoryObject An IFactoryObject that creates a local Hibernate SessionFactory instance. Behaves like a SessionFactory instance when used as bean reference, e.g. for HibernateTemplate's "SessionFactory" property.
LocalSessionFactoryObject An IFactoryObject that creates a local Hibernate SessionFactory instance. Behaves like a SessionFactory instance when used as bean reference, e.g. for HibernateTemplate's "SessionFactory" property.
HibernateDaoSupport Convenient super class for Hibernate data access objects.
HibernateDaoSupport Convenient super class for Hibernate data access objects.
HibernateDaoSupport Convenient super class for Hibernate data access objects.
AbstractAdoOperation Abstract base class providing common functionality for generic and non generic implementations of "AdoOperation" subclasses.
AdoNonQuery Encapsulate Command.ExecuteNonQuery operations within a reusable class.
AdoOperation A "AdoOperation" is a thread-safe, reusable object representing an ADO Query, "NonQuery" (Create, Update, Delete), stored procedure or DataSet manipualtions.
AdoQuery Place together the mapping logic to a plain .NET object for one result set within the same class.
AdoScalar Encapsulate Command ExecuteScalar operations within a reusable class.
AdoOperation A "AdoOperation" is a thread-safe, reusable object representing an ADO Query, "NonQuery" (Create, Update, Delete), stored procedure or DataSet manipualtions.
AdoQuery Place together the mapping logic to a plain .NET object for one result set within the same class.
MappingAdoQuery Reusable query in which concrete subclasses must implement the MapRow method to map each row of a single result set into an object.
MappingAdoQueryWithContext Reusable query in which concrete subclasses must implement the abstract MapRow method to map each row of a single result set into an object.
StoredProcedure A superclass for object based abstractions of RDBMS stored procedures.
MappingAdoQuery Reusable query in which concrete subclasses must implement the MapRow method to map each row of a single result set into an object.
MappingAdoQueryWithContext Reusable query in which concrete subclasses must implement the MapRow method to map each row of a single result set into an object.
StoredProcedure A superclass for object based abstractions of RDBMS stored procedures.
EnterpriseServicesExporter Exports components as ServicedComponents using the specified ServicedComponentExporters.
ServicedComponentExporter Encapsulates information necessary to create ServicedComponent wrapper around target class.
ServicedComponentFactory Factory Object that instantiates and configures ServicedComponent.
MessageQueueGatewaySupport Convenient super class for application classes that need MSMQ access.
MessageQueueMetadataCache Missing <summary> documentation for T:Spring.Messaging.Core.MessageQueueMetadataCache
MessageQueueTemplate Helper class that simplifies MSMQ access code.
EmsConnectionFactory Missing <summary> documentation for T:Spring.Messaging.Ems.Common.EmsConnectionFactory
CachingConnectionFactory SingleConnectionFactory subclass that adds Session, MessageProducer, and MessageConsumer caching. This ConnectionFactory also switches the ReconnectOnException property to true by default, allowing for automatic recovery of the underlying Connection.
EmsTransactionManager A AbstractPlatformTransactionManager implementation for a single EMS
ConnectionFactory
. Binds a Connection/Session pair from the specified ConnecctionFactory to the thread, potentially allowing for one thread-bound Session per ConnectionFactory.
SingleConnectionFactory A ConnectionFactory adapter that returns the same Connection from all CreateConnection() calls, and ignores calls to Connection.Close(). According to the JMS Connection model, this is perfectly thread-safe. The shared Connection can be automatically recovered in case of an Exception.
EmsGatewaySupport Convenient super class for application classes that need EMS access.
EmsTemplate Helper class that simplifies EMS access code.
AbstractListenerContainer Common base class for all containers which need to implement listening based on a Connection (either shared or freshly obtained for each attempt). Inherits basic Connection and Session configuration handling from the EmsAccessor base class.
AbstractMessageListenerContainer Abstract base class for message listener containers. Can either host a standard EMS MessageListener or a Spring-specific ISessionAwareMessageListener
SimpleMessageListenerContainer Message listener container that uses the plain EMS client API's MessageConsumer.Listener method to create concurrent MessageConsumers for the specified listeners.
EmsDestinationAccessor Base class for EmsTemplate} and other EMS-accessing gateway helpers, adding destination-related properties to EmsAccessor's common properties.
EmsAccessor Base class for EmsTemplate and other EMS-accessing gateway helpers
AbstractListenerContainer Provides basic lifecyle management methods for implementing a message listener container.
AbstractMessageListenerContainer Defines a minimal programming model for message listener containers. They are expected to invoke a IMessageListener upon asynchronous receives of a MSMQ message. Access to obtain MessageQueue and IMessageConverter instances is available through the IMessageQueueFactory property, the default implementation DefaultMessageQueueFactory provides per-thread instances of these classes.
AbstractPeekingMessageListenerContainer Base class for listener container implementations which are based on Peeking for messages on a MessageQueue. Peeking is the only resource efficient approach that can be used in order to have MessageQueue receipt in conjunction with transactions, either local MSMQ transactions, local ADO.NET based transactions, or DTC transactions. See SimpleMessageListenerContainer for an implementation based on a synchronous receives and you do not require transactional support.
AbstractSendToQueueExceptionHandler Provides common functionality to exception handlers that will send the exceptional message to another queue.
AbstractTransactionalMessageListenerContainer An implementation of a Peeking based MessageListener container that starts a transaction before recieving a message. The IPlatformTransactionManager implementation determines the type of transaction that will be started. An exception while processing the message will result in a rollback, otherwise a transaction commit will be performed.
DistributedTxMessageListenerContainer A MessageListenerContainer that uses distributed (DTC) based transactions. Exceptions are handled by instances of IDistributedTransactionExceptionHandler.
MessageListenerAdapter Message listener adapter that delegates the handling of messages to target listener methods via reflection DynamicReflectionManager, with flexible message type conversion. Allows listener methods to operate on message content types, completely independent from the MSMQ API.
NonTransactionalMessageListenerContainer An implementation of a Peeking based MessageListener container that does not surround the receive operation with a transaction.
SendToQueueDistributedTransactionExceptionHandler detects poison messages by tracking the Message Id property in memory with a count of how many times an exception has occurred. If that count is greater than the handler's MaxRetry count it will be sent to another queue. The queue to send the message to is specified via the property M essageQueueObjectName.
SendToQueueExceptionHandler Keeps track of the Message's Id property in memory with a count of how many times an exception has occurred. If that count is greater than the handler's MaxRetry count it will be sent to another queue using the provided MessageQueueTransaction. The queue to send the message to is specified via the property MessageQueueObjectName.
TransactionalMessageListenerContainer A MessageListenerContainer that uses local (non-DTC) based transactions. Exceptions are handled by instances of IMessageTransactionExceptionHandler.
CachingConnectionFactory SingleConnectionFactory subclass that adds Session, MessageProducer, and MessageConsumer caching. This ConnectionFactory also switches the ReconnectOnException property to true by default, allowing for automatic recovery of the underlying Connection.
NmsTransactionManager A AbstractPlatformTransactionManager implementation for a single NMS
ConnectionFactory
. Binds a Connection/Session pair from the specified ConnecctionFactory to the thread, potentially allowing for one thread-bound Session per ConnectionFactory.
SingleConnectionFactory A ConnectionFactory adapter that returns the same Connection from all CreateConnection() calls, and ignores calls to Connection.Close(). According to the JMS Connection model, this is perfectly thread-safe. The shared Connection can be automatically recovered in case of an Exception.
NmsGatewaySupport Convenient super class for application classes that need NMS access.
NmsTemplate Helper class that simplifies NMS access code.
AbstractListenerContainer Common base class for all containers which need to implement listening based on a Connection (either shared or freshly obtained for each attempt). Inherits basic Connection and Session configuration handling from the NmsAccessor base class.
AbstractMessageListenerContainer Abstract base class for message listener containers. Can either host a standard NMS MessageListener or a Spring-specific ISessionAwareMessageListener
SimpleMessageListenerContainer Message listener container that uses the plain NMS client API's MessageConsumer.Listener method to create concurrent MessageConsumers for the specified listeners.
NmsDestinationAccessor Base class for NmsTemplate} and other NMS-accessing gateway helpers, adding destination-related properties to MessagingAccessor's common properties.
NmsAccessor Base class for NmsTemplate and other NMS-accessing gateway helpers
AbstractFactoryObject Simple template superclass for IFactoryObject implementations that allows for the creation of a singleton or a prototype instance (depending on a flag).
DelegateFactoryObject IFactoryObject implementation that creates delegates.
DictionaryFactoryObject Simple factory for shared IDictionary instances.
FieldRetrievingFactoryObject IFactoryObject implementation that retrieves a static or non-static public field value.
ListFactoryObject Simple factory for shared IList instances.
LogFactoryObject IFactoryObject implementation that creates instances of the ILog class.
MethodInvokingFactoryObject An IFactoryObject that returns a value that is the result of a static (Shared in Visual Basic) or instance method invocation.
ObjectFactoryCreatingFactoryObject Returns a value that is an IGenericObjectFactory that returns an object from an IObjectFactory.
PropertyRetrievingFactoryObject IFactoryObject implementation that retrieves a or non-static public property value.
ResourceManagerFactoryObject A convenience class to create a ResourceManager given the resource base name and assembly name.
SetFactoryObject Simple factory object for shared ISet instances.
CaoExporter Registers an object type on the server as a Client Activated Object (CAO).
CaoFactoryObject Factory for creating a reference to a client activated object (CAO).
RemoteObjectFactory Factory for creating MarshalByRefObject wrapper around target class.
SaoExporter Publishes an instance of an object under a given url as a Server Activated Object (SAO).
SaoFactoryObject Factory for creating a reference to a remote server activated object (SAO).
CronTriggerObject Convenience subclass of Quartz's CronTrigger type, making property based usage easier.
JobDetailObject Convenience subclass of Quartz' JobDetail class that eases properties based usage.
MethodInvokingJobDetailFactoryObject IFactoryObject that exposes a JobDetail object that delegates job execution to a specified (static or non-static) method. Avoids the need to implement a one-line Quartz Job that just invokes an existing service method.
MethodInvokingRunnable Adapter that implements the Runnable interface as a configurable method invocation based on Spring's MethodInvoker.
SchedulerAccessorObject Spring class for accessing a Quartz Scheduler, i.e. for registering jobs, triggers and listeners on a given IScheduler instance.
SchedulerFactoryObject FactoryObject that sets up a Quartz Scheduler and exposes it for object references.
SimpleThreadPoolTaskExecutor Subclass of Quartz's SimpleThreadPool that implements Spring's TaskExecutor interface and listens to Spring lifecycle callbacks.
SimpleTriggerObject Convenience subclass of Quartz's SimpleTrigger class, making properties based usage easier.
VelocityEngineFactoryObject FactoryObject implementation that configures a VelocityEngine and provides it as an object reference. This object is intended for any kind of usage of Velocity in application code, e.g. for generating email content. See the base class VelocityEngineFactory for configuration details.
TransactionAspectSupport Superclass for transaction aspects, such as the AOP Alliance-compatible TransactionInterceptor.
TransactionInterceptor An AOP Alliance IMethodInterceptor providing declarative transaction management using the common Spring.NET transaction infrastructure.
TransactionProxyFactoryObject Proxy factory object for simplified declarative transaction handling.
TransactionTemplate Helper class that simplifies programmatic transaction demarcation and transaction exception handling.
WebServiceExporter Exports an object as a web service.
WebServiceProxyFactory Factory Object that dynamically implements service interface for web service.

Remarks

An implementation of the AfterPropertiesSet method might perform some additional custom initialization (over and above that performed by the constructor), or merely check that all mandatory properties have been set (this last example is a very typical use case of this interface).

Note    The use of the IInitializingObject interface by non-Spring.NET framework code can be avoided (and is generally discouraged). The Spring.NET container provides support for a generic initialization method given to the object definition in the object configuration store (be it XML, or a database, etc). This requires slightly more configuration (one attribute-value pair in the case of XML configuration), but removes any dependency on Spring.NET from the class definition.

Requirements

Namespace: Spring.Objects.Factory

Assembly: Spring.Core (in Spring.Core.dll)

See Also

IInitializingObject Members | Spring.Objects.Factory Namespace | IObjectFactory