Spring.NET 1.3.0 RC1 for .NET 2.0 API Reference

Spring.Core Assembly

Referenced Assemblies

Assembly Reference Description
Common.Logging  
Microsoft.VisualBasic  
mscorlib  
mscorlib  
System  
System.Configuration  
System.Drawing  
System.Xml  

Dependent Assemblies

Assembly Description
Spring.Aop  
Spring.Data  
Spring.Data.NHibernate12  
Spring.Data.NHibernate20  
Spring.Data.NHibernate21  
Spring.Messaging  
Spring.Messaging.Ems  
Spring.Messaging.Nms  
Spring.Scheduling.Quartz  
Spring.Services  
Spring.Template.Velocity  
Spring.Testing.Microsoft  
Spring.Testing.NUnit  
Spring.Web  

Namespaces

Namespace Description
Spring.Caching Missing <summary> Documentation for Spring.Caching
Spring.Collections Missing <summary> Documentation for Spring.Collections
Spring.Collections.Generic Missing <summary> Documentation for Spring.Collections.Generic
Spring.Context Missing <summary> Documentation for Spring.Context
Spring.Context.Events Missing <summary> Documentation for Spring.Context.Events
Spring.Context.Support Missing <summary> Documentation for Spring.Context.Support
Spring.Core Missing <summary> Documentation for Spring.Core
Spring.Core.IO Missing <summary> Documentation for Spring.Core.IO
Spring.Core.TypeConversion Missing <summary> Documentation for Spring.Core.TypeConversion
Spring.Core.TypeResolution Missing <summary> Documentation for Spring.Core.TypeResolution
Spring.DataBinding Missing <summary> Documentation for Spring.DataBinding
Spring.Expressions Missing <summary> Documentation for Spring.Expressions
Spring.Expressions.Parser.antlr Missing <summary> Documentation for Spring.Expressions.Parser.antlr
Spring.Expressions.Parser.antlr.collections Missing <summary> Documentation for Spring.Expressions.Parser.antlr.collections
Spring.Expressions.Parser.antlr.collections.impl Missing <summary> Documentation for Spring.Expressions.Parser.antlr.collections.impl
Spring.Expressions.Parser.antlr.debug Missing <summary> Documentation for Spring.Expressions.Parser.antlr.debug
Spring.Expressions.Processors Missing <summary> Documentation for Spring.Expressions.Processors
Spring.Globalization Missing <summary> Documentation for Spring.Globalization
Spring.Globalization.Formatters Missing <summary> Documentation for Spring.Globalization.Formatters
Spring.Globalization.Localizers Missing <summary> Documentation for Spring.Globalization.Localizers
Spring.Globalization.Resolvers Missing <summary> Documentation for Spring.Globalization.Resolvers
Spring.Objects Missing <summary> Documentation for Spring.Objects
Spring.Objects.Events Missing <summary> Documentation for Spring.Objects.Events
Spring.Objects.Events.Support Missing <summary> Documentation for Spring.Objects.Events.Support
Spring.Objects.Factory Missing <summary> Documentation for Spring.Objects.Factory
Spring.Objects.Factory.Attributes Missing <summary> Documentation for Spring.Objects.Factory.Attributes
Spring.Objects.Factory.Config Missing <summary> Documentation for Spring.Objects.Factory.Config
Spring.Objects.Factory.Parsing Missing <summary> Documentation for Spring.Objects.Factory.Parsing
Spring.Objects.Factory.Support Missing <summary> Documentation for Spring.Objects.Factory.Support
Spring.Objects.Factory.Xml Missing <summary> Documentation for Spring.Objects.Factory.Xml
Spring.Objects.Support Missing <summary> Documentation for Spring.Objects.Support
Spring.Pool Missing <summary> Documentation for Spring.Pool
Spring.Pool.Support Missing <summary> Documentation for Spring.Pool.Support
Spring.Proxy Missing <summary> Documentation for Spring.Proxy
Spring.Reflection.Dynamic Missing <summary> Documentation for Spring.Reflection.Dynamic
Spring.Stereotype Missing <summary> Documentation for Spring.Stereotype
Spring.Threading Missing <summary> Documentation for Spring.Threading
Spring.Util Missing <summary> Documentation for Spring.Util
Spring.Util.Generic Missing <summary> Documentation for Spring.Util.Generic
Spring.Validation Missing <summary> Documentation for Spring.Validation
Spring.Validation.Actions Missing <summary> Documentation for Spring.Validation.Actions
Spring.Validation.Config Missing <summary> Documentation for Spring.Validation.Config
Spring.Validation.Validators Missing <summary> Documentation for Spring.Validation.Validators

Classes

Class Description
AbstractApplicationContext Partial implementation of the IApplicationContext interface.
AbstractAutowireCapableObjectFactory Abstract IObjectFactory superclass that implements default object creation.
AbstractBinding Abstract base class for IBinding implementations.
AbstractCache An abstract ICache implementation that can be used as base class for concrete implementations.
AbstractConfigurer Base class that provides common functionality needed for several IObjectFactoryPostProcessor implementations
AbstractEventHandlerValue Base class implementation for classes that describe an event handler.
AbstractFactoryObject Simple template superclass for IFactoryObject implementations that allows for the creation of a singleton or a prototype instance (depending on a flag).
AbstractLocalizer Abstract base class that all localizers should extend
AbstractMessageSource Abstract implementation of the IHierarchicalMessageSource interface, implementing common handling of message variants, making it easy to implement a specific strategy for a concrete IMessageSource.
AbstractMethodReplacer An IMethodReplacer implementation that provides some convenience support for derived classes.
AbstractObjectDefinition Common base class for object definitions, factoring out common functionality from RootObjectDefinition and ChildObjectDefinition.
AbstractObjectDefinitionParser Abstract IObjectDefinitionParser implementation providing a number of convenience methods and a ParseInternal template method that subclasses must override to provide the actual parsing logic.
AbstractObjectDefinitionReader Abstract base class for object definition readers.
AbstractObjectFactory Abstract superclass for IObjectFactory implementations.
AbstractProxyMethodBuilder Base class for method builders that contains common functionalities.
AbstractProxyTypeBuilder Base class for proxy builders that can be used to create a proxy for any class.
AbstractQueue This class provides skeletal implementations of some IQueue operations.
AbstractResource Convenience base class for IResource implementations, pre-implementing typical behavior.
AbstractResourceCache Abstract base class that all resource cache implementations should extend.
AbstractSharedStateFactory Convenience base class for ISharedStateFactory implementations.
AbstractSimpleBinding Abstract base class for simple, one-to-one IBinding implementations.
AbstractSimpleObjectDefinitionParser Convenient base class for when there exists a one-to-one mapping between attribute names on the element that is to be parsed and the property names on the Type being configured.
AbstractSingleObjectDefinitionParser Base Type for those IObjectDefinitionParser implementations that need to parse and define just a single IObjectDefinition.
AbstractWiringEventHandlerValue Base class for all IEventHandlerValue implemenations that actually perform event wiring.
AbstractXmlApplicationContext Convenient abstract superclass for IApplicationContext implementations that draw their configuration from XML documents containing object definitions as understood by an XmlObjectDefinitionReader.
Amex American Express credit card type validation support.
ANTLREventArgs Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.ANTLREventArgs
ANTLRException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.ANTLRException
ANTLRPanicException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.ANTLRPanicException
AnyValidatorGroup IValidator implementation that supports grouping of validators.
ApplicationContextAwareProcessor IObjectPostProcessor implementation that passes the application context to object that implement the IApplicationContextAware, IMessageSourceAware, and IResourceLoaderAware interfaces.
ApplicationContextException Exception thrown during application context initialization.
ApplicationEventArgs Encapsulates the data associated with an event raised by an IApplicationContext.
ApplicationObjectSupport Convenient superclass for application objects that want to be aware of the application context, e.g. for custom lookup of collaborating object or for context-specific resource access.
ArgumentConvertingMethodInvoker Specialisation of the MethodInvoker class that tries to convert the given arguments for the actual target method via an appropriate IObjectWrapper implementation.
ArrayConstructorNode Represents parsed method node in the navigation expression.
ArrayUtils Various utility methods relating to the manipulation of arrays.
AssemblyResource An IResource implementation for resources stored within assemblies.
AssertUtils Assertion utility methods that simplify things such as argument checks.
AssignNode Represents parsed assignment node in the navigation expression.
ASTArray Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.collections.impl.ASTArray
ASTFactory AST Support code shared by TreeParser and Parser.
ASTFactory.FactoryEntry Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.ASTFactory.FactoryEntry
ASTNodeCreator A creator of AST node instances.
ASTNULLType Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.ASTNULLType
AttributeNode Represents parsed attribute node in the navigation expression.
AttributeUtils General utility methods for working with annotations
AutowireUtils Utility class that contains various methods useful for the implementation of autowire-capable object factories.
AutoWiringEventHandlerValue Describes an IEventHandlerValue implementation that autowires events to handler methods.
AverageAggregator Implementation of the average aggregator.
BaseAST Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.BaseAST
BaseBindingContainer Base implementation of the IBindingContainer.
BaseBindingManager BaseBindingManager keeps track of all registered bindings and represents an entry point for the binding and unbinding process.
BaseCacheAttribute Abstract base class containing shared properties for all cache attributes.
BaseDynamicMember Base class for dynamic members.
BaseNode Base type for all expression nodes.
BaseNode.EvaluationContext Holds the state during evaluating an expression.
BaseProxyMethodBuilder Implementation of IProxyMethodBuilder that delegates method calls to the base class.
BaseSimpleValidator Base class that defines common properties for all single validators.
BaseValidationAction Abstract base class that should be extended by all validation actions.
BaseValidator Base class that defines common properties for all validators.
BaseValidatorGroup Base class for composite validators
BinaryOperator Base class for binary operators.
BindingErrorMessage Represents an ErrorMessage specific to a binding instance.
BitSet Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.collections.impl.BitSet
BooleanFormatter Implementation of IFormatter that can be used to format and parse boolean values.
BooleanLiteralNode Represents parsed boolean literal node.
ByteBuffer Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.ByteBuffer
ByTypeSharedStateFactory Serves shared state on a by-type basis.
CachedTypeResolver Resolves (instantiates) a Type by it's (possibly assembly qualified) name, and caches the Type instance against the type name.
CacheParameterAttribute This attribute should be used to mark methods whose argument(s) need to be cached.
CacheResultAttribute This attribute should be used to mark methods whose result needs to be cached.
CacheResultItemsAttribute This attribute should be used with methods that return an ICollection in order to cache each item separately.
CallContextStorage Implements IThreadStorage by using CallContext.
CannotLoadObjectTypeException Exception thrown when the ObjectFactory cannot load the specified type of a given object.
CaseInsensitiveHashtable Provides a performance improved hashtable with case-insensitive (string-only! based) key handling.
CharBuffer Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.CharBuffer
CharQueue Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.CharQueue
CharScanner Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.CharScanner
CharStreamException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.CharStreamException
CharStreamIOException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.CharStreamIOException
ChildObjectDefinition Object definition for definitions that inherit settings from their parent (object definition).
CollectionUtils Miscellaneous collection utility methods.
CollectionUtils Miscellaneous generic collection utility methods.
CollectionValidator IValidator implementation that supports validating collections.
CommandLineArgsVariableSource Implementation of IVariableSource that resolves variable name against command line arguments.
CommonAST Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.CommonAST
CommonAST.CommonASTCreator Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.CommonAST.CommonASTCreator
CommonASTWithHiddenTokens Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.CommonASTWithHiddenTokens
CommonASTWithHiddenTokens.CommonASTWithHiddenTokensCreator Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.CommonASTWithHiddenTokens.CommonASTWithHiddenTokensCreator
CommonHiddenStreamToken Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.CommonHiddenStreamToken
CommonHiddenStreamToken.CommonHiddenStreamTokenCreator Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.CommonHiddenStreamToken.CommonHiddenStreamTokenCreator
CommonToken Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.CommonToken
CommonToken.CommonTokenCreator Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.CommonToken.CommonTokenCreator
CompareUtils Utility class containing helper methods for object comparison.
ComponentAttribute Indicates that an annotated class is a "component". Such classes are considered as candidates for future features such as auto-detection when using attribute-based configuration and assembly scanning.
ComposedCriteria A ICriteria implementation that represents a composed collection of ICriteria instances.
CompositionProxyTypeBuilder Builds a proxy type using composition.
ConditionValidator Evaluates validator test using condition evaluator.
ConfigSectionResource Used when retrieving information from the standard .NET configuration files (App.config / Web.config).
ConfigSectionVariableSource Implementation of IVariableSource that resolves variable name against name-value sections in the standard .NET configuration file.
ConfigurableResourceLoader Configurable implementation of the IResourceLoader interface.
ConfigurationReader Various utility methods for .NET style .config files.
ConfigurationUtils Utility class for .NET configuration files management.
ConfigXmlAttribute An XmlAttribute holding information about its original text source location.
ConfigXmlDocument An XmlDocument implementation, who's elements retain information about their location in the original XML text document the were read from.
ConfigXmlElement An XmlElement holding information about its original text source location.
ConnectionStringsVariableSource Implementation of IVariableSource that resolves variable name connection strings defined in the standard .NET configuration file.
ConsoleListener Simple listener that logs application events to the console.
ConstructorArgumentValues Holder for constructor argument values for an object.
ConstructorArgumentValues.ValueHolder Holder for a constructor argument value, with an optional Type attribute indicating the target Type of the actual constructor argument.
ConstructorNode Represents parsed method node in the navigation expression.
ContextEventArgs Event object sent to listeners registered with an IApplicationContext to inform them of context lifecycle events.
ContextHandler Creates an IApplicationContext instance using context definitions supplied in a custom configuration and configures the ContextRegistry with that instance.
ContextRegistry Provides access to a central registry of IApplicationContexts.
ControlFlowFactory Factory class to conceal any default IControlFlow implementation.
Conventions Provides methods to support various naming and other conventions used throughout the framework. Mainly for internal use within the framework.
ConversionProcessor Converts all elements in the input list to a given target type.
CountAggregator Implementation of the count aggregator.
CredentialConverter Converts string representation of a credential for Web client authentication into an instance of NetworkCredential.
CreditCardValidator Perform credit card validations.
CriteriaMemberFilter Convenience class that exposes a signature that matches the MemberFilter delegate.
CurrencyFormatter Implementation of IFormatter that can be used to format and parse currency values.
CustomConverterConfigurer IObjectFactoryPostProcessor implementation that allows for convenient registration of custom TypeConverters.
CustomNumberConverter A custom TypeConverter for any primitive numeric type such as Int32, Single, Double, etc.
DateLiteralNode Represents parsed node in the navigation expression.
DateTimeFormatter Implementation of IFormatter that can be used to format and parse DateTime values.
DebuggingCharScanner Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.DebuggingCharScanner
DebuggingInputBuffer Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.DebuggingInputBuffer
DefaultCultureResolver ICultureResolver implementation that simply returns the CultureInfo value of the DefaultCulture property (if said property value is not ), or the CultureInfo of the current thread if it is .
DefaultFileLineFormatter Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.DefaultFileLineFormatter
DefaultListableObjectFactory Concrete implementation of the IListableObjectFactory and IObjectDefinitionRegistry interfaces.
DefaultMessageSourceResolvable Default implementation of the IMessageSourceResolvable interface.
DefaultNode Represents parsed default node in the navigation expression.
DefaultObjectDefinitionDocumentReader XML resource reader.
DefaultObjectDefinitionFactory Default implementation of the IObjectDefinitionFactory interface.
DefaultObjectNameGenerator Default implementation of the IObjectNameGenerator interface, deleagting to ObjectDefinitionReaderUtils's GenerateObjectName.
DefaultSectionHandler Default section handler that can handle any configuration section.
DefensiveEventRaiser Raises events defensively.
DelegateFactoryObject IFactoryObject implementation that creates delegates.
DelegateInfo Discovers the attributes of a DelegateType and provides access to the DelegateTypes metadata.
DelegatingMessageSource Empty IMessageSource implementation that simply delegates all method calls to it's parent IMessageSource.
DelegatingMethodReplacer An IMethodReplacer implementation that delegates to an IMethodReplacer that is obtained as the result of a lookup in an associated IoC container.
DependencyDescriptor Descriptor for a specific dependency that is about to be injected. Wraps a constructor parameter, a method parameter or a field, allowing unified access to their metadata.
DictionaryFactoryObject Simple factory for shared IDictionary instances.
DictionarySet DictionarySet is an abstract (MustInherit in Visual Basic) class that supports the creation of new ISet types where the underlying data store is an IDictionary instance.
DictionaryVariableSource A very simple, hashtable-based implementation of IVariableSource
Discover Discover credit card type validation support.
DistinctProcessor Implementation of the distinct processor.
DocumentDefaultsDefinition Simple class that holds the defaults specified at the 
<objects>
level in a standard Spring XML object definition document: 
default-lazy-init
, 
default-autowire
, etc.
DumpASTVisitor Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.DumpASTVisitor
DynamicCodeManager Use this class for obtaining ModuleBuilder instances for dynamic code generation.
DynamicConstructor Factory class for dynamic constructors.
DynamicField Factory class for dynamic fields.
DynamicIndexer Obsolete. Factory class for dynamic indexers.
DynamicMethod Factory class for dynamic methods.
DynamicProperty Factory class for dynamic properties.
DynamicProxyManager Allows easy access to existing and creation of new dynamic proxies.
DynamicReflectionManager Allows easy access to existing and creation of new dynamic relection members.
EmailValidator Perform email validations.
EncodedResource Holder that combines IResource with a specific encoding to be used for reading from the resource
EnvironmentVariableSource Implementation of IVariableSource that resolves variable name against environment variables.
ErrorMessage Represents a single validation error message.
ErrorMessageAction Implementation of IValidationAction that adds error message to the validation errors container.
EventListenerAttribute Marks an interface as being an application event listener.
EventManipulationUtils Utility class to aid in the manipulation of events and delegates.
EventRaiser A utility class for raising events in a generic and consistent fashion.
EventRegistry Default implementation of the IEventRegistry interface.
EventValues Holder for event handler values for an object.
ExceptionAction Missing <summary> documentation for T:Spring.Validation.Actions.ExceptionAction
ExclusiveValidatorGroup IValidator implementation that supports grouping of validators.
Expression Container object for the parsed expression.
Expression.ReservedVariableNames Contains a list of reserved variable names. You must not use any variable names with the reserved prefix!
ExpressionAction Implementation of IValidationAction that allows you to define Spring.NET expressions that should be evaluated after validation.
ExpressionConverter Converts string representation of expression into an instance of IExpression.
ExpressionEvaluator Utility class that enables easy expression evaluation.
ExpressionHolder Immutable placeholder class used for the value of a PropertyValue object when it's a reference to a Spring IExpression that should be evaluated at runtime.
ExpressionListNode Represents parsed expression list node in the navigation expression.
FactoryObjectNotInitializedException Exception thrown if an IFactoryObject is not fully initialized, for example if it is involved in a circular reference.
FatalObjectException Thrown on an unrecoverable problem encountered in the objects namespace or sub-namespaces, e.g. bad class or field.
FatalReflectionException Thrown on an unrecoverable problem encountered in the objects namespace or sub-namespaces, e.g. bad class or field.
FieldRetrievingFactoryObject IFactoryObject implementation that retrieves a static or non-static public field value.
FileInfoConverter Converter for FileInfo instances.
FileLineFormatter Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.FileLineFormatter
FileSystemResource A File backed resource.
FilteringFormatter Provides base functionality for filtering values before they actually get parsed/formatted.
FloatFormatter Implementation of IFormatter that can be used to format and parse floating point numbers.
FunctionNode Represents parsed function node.
GenericApplicationContext Generic ApplicationContext implementation that holds a single internal DefaultListableObjectFactory instance and does not assume a specific object definition format.
GenericArgumentsHolder Holder for the generic arguments when using type parameters.
GenericObjectDefinition GenericObjectDefinition is a one-stop shop for standard object definition purposes. Like any object definition, it allows for specifying a class plus optionally constructor argument values and property values. Additionally, deriving from a parent bean definition can be flexibly configured through the "parentName" property.
GenericTypeResolver Resolves a generic Type by name.
GuessingEventArgs Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.GuessingEventArgs
HashedSet Implements an ISet based on a hash table.
HasTextFilteringFormatter Replaces input strings with a given default value, if they are null or contain whitespaces only,
HexLiteralNode Represents parsed hexadecimal integer literal node.
HybridSet Implements an ISet that automatically changes from a list based implementation to a hashtable based implementation when the size reaches a certain threshold.
ImmutableSet Implements an immutable (read-only) ISet wrapper.
IndexerNode Represents parsed indexer node in the navigation expression.
InheritanceProxyTypeBuilder Builds a proxy type using inheritance.
InputBuffer Represents a stream of characters fed to the lexer from that can be rewound via mark()/rewind() methods.
InputBufferEventArgs Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.InputBufferEventArgs
InputBufferEventSupport Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.InputBufferEventSupport
InputBufferListenerBase Provides an abstract base for implementing InputBufferListener subclasses.
InputBufferReporter Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.InputBufferReporter
InputStreamResource IResource adapter implementation for a Stream.
InstanceEventHandlerValue Describes an event handler for an object instance.
InstantiationAwareObjectPostProcessorAdapter Adapter that implements all methods on SmartInstantiationAwareObjectPostProcessor as no-ops, which will not change normal processing of each object instantiated by the container. Subclasses may override merely those methods that they are actually interested in.
IntegerFormatter Implementation of IFormatter that can be used to format and parse integer numbers.
IntLiteralNode Represents parsed integer literal node.
InvalidateCacheAttribute This attribute should be used to mark method that should invalidate one or more cache items when invoked.
InvalidPropertyException Thrown in response to referring to an invalid property (most often via reflection).
ISBNValidator Validates that the object is valid ISBN-10 or ISBN-13 value.
LambdaExpressionNode Represents lambda expression.
Latch A latch is a boolean condition that is set at most once, ever. Once a single release is issued, all acquires will pass.

Sample usage. Here are a set of classes that use a latch as a start signal for a group of worker threads that are created and started beforehand, and then later enabled.

class Worker implements IRunnable { private readonly Latch startSignal; Worker(Latch l) { startSignal = l; } public void Run() { startSignal.acquire(); DoWork(); } void DoWork() { ... } } class Driver { // ... void Main() { Latch go = new Latch(); for (int i = 0; i < N; ++i) // make threads new Thread(new ThreadStart(new Worker(go)).Start(); DoSomethingElse(); // don't let run yet go.Release(); // let all threads proceed } }
LexerSharedInputState Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.LexerSharedInputState
LinkedList Simple linked list implementation.
ListBinding IBindingContainer implementation that allows data binding between collections that implement IList interface.
ListFactoryObject Simple factory for shared IList instances.
ListInitializerNode Represents parsed list initializer node in the navigation expression.
ListSet Implements a ISet based on a list.
LLkDebuggingParser Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.LLkDebuggingParser
LLkParser Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.LLkParser
LocalFunctionNode Represents local function node.
LocalVariableNode Represents parsed variable node.
LogFactoryObject IFactoryObject implementation that creates instances of the ILog class.
LogicalThreadContext An abstraction to safely store "ThreadStatic" data.
LookupMethodOverride Represents an override of a method that looks up an object in the same IoC context.
LookupMethodReplacer An IMethodReplacer implementation that simply returns the result of a lookup in an associated IoC container.
ManagedDictionary Tag subclass used to hold a dictionary of managed elements.
ManagedList Tag subclass used to hold a list of managed elements.
ManagedNameValueCollection Tag class which represent a Spring-managed NameValueCollection instance that supports merging of parent/child definitions.
ManagedSet Tag subclass used to hold a set of managed elements.
MapEntryNode Represents parsed map entry node.
MapInitializerNode Represents parsed map initializer node in the navigation expression.
Mastercard Mastercard credit card type validation support.
MatchEventArgs Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.MatchEventArgs
MaxAggregator Implementation of the maximum aggregator.
MessageEventArgs Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.MessageEventArgs
MessageListenerBase Provides an abstract base for implementing MessageListener subclasses.
MessageSourceAccessor Helper class for easy access to messages from an IMessageSource, providing various overloaded GetMessage methods.
MessageSourceResolvableVisitor Visitor class to represent IMessageSourceResolvable instances.
MethodArgumentsCriteria Criteria that is satisfied if the Type of each of the arguments matches each of the parameter Types of a given MethodInfo.
MethodGenericArgumentsCountCriteria Criteria that is satisfied if the number of generic arguments to a given MethodBase matches an arbitrary number.
MethodInjectingInstantiationStrategy An IInstantiationStrategy implementation that supports method injection.
MethodInvocationException Thrown when a method (typically a property getter or setter invoked via reflection) throws an exception, analogous to a TargetInvocationException.
MethodInvoker Helper class allowing one to declaratively specify a method call for later invocation.
MethodInvokingFactoryObject An IFactoryObject that returns a value that is the result of a static (Shared in Visual Basic) or instance method invocation.
MethodNameMatchCriteria Criteria that is satisfied if the method Name of an MethodInfo instance matches a supplied string pattern.
MethodNode Represents parsed method node in the navigation expression.
MethodOverride Represents the override of a method on a managed object by the IoC container.
MethodOverrides A collection (with set semantics) of method overrides, determining which, if any, methods on a managed object the Spring.NET IoC container will override at runtime.
MethodParameter Helper class that encapsulates the specification of a method parameter, i.e. a MethodInfo or ConstructorInfo plus a parameter index. Useful as a specification object to pass along.
MethodParametersCountCriteria Criteria that is satisfied if the number of parameters to a given MethodBase matches an arbitrary number.
MethodParametersCriteria Criteria that is satisfied if the Type of each of the parameters of a given MethodInfo matches each of the parameter Types of a given MethodInfo.
MethodReturnTypeCriteria Criteria that is satisfied if the return Type of a given MethodInfo matches a given Type.
MinAggregator Implementation of the minimum aggregator.
MismatchedCharException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.MismatchedCharException
MismatchedTokenException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.MismatchedTokenException
MutablePropertyValues Default implementation of the IPropertyValues interface.
MutableSortDefinition Mutable implementation of the ISortDefinition interface that supports toggling the ascending value on setting the same property again.
NamedArgumentNode Represents parsed named argument node in the expression.
NamespaceParserAttribute Attribute that should be used to specify the default namespace and schema location for a custom namespace parser.
NamespaceParserRegistry Provides a resolution mechanism for configuration parsers.
NamespaceParsersSectionHandler Configuration section handler for the (recommended, Spring.NET standard) parsers config section.
NamespaceParserSupport Support class for implementing custom namespace parsers.
NameValueConverter Custom TypeConverter implementation for NameValueCollection objects.
NewLineEventArgs Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.NewLineEventArgs
NodeWithArguments Base type for nodes that accept arguments.
NoElementsException Thrown when an element is requested from an empty IQueue.
NonExpiringCache A simple ICache implementation backed by a dictionary that never expires cache items.
NonNullProcessor Implementation of the non-null processor.
NoSuchMessageException Thrown when a message cannot be resolved.
NoSuchObjectDefinitionException Exception thrown when an IObjectFactory is asked for an object instance name for which it cannot find a definition.
NotReadablePropertyException Thrown in response to a failed attempt to read a property.
NotWritablePropertyException Thrown in response to a failed attempt to write a property.
NoViableAltException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.NoViableAltException
NoViableAltForCharException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.NoViableAltForCharException
NullFormatter Implementation of IFormatter that simply calls ToString.
NullLiteralNode Represents parsed null literal node.
NullMessageSource An IMessageSource that doesn't do a whole lot.
NullResourceCache Resource cache implementation that doesn't cache resources.
NullValueInNestedPathException Thrown in response to encountering a a null reference (Nothing in Visual Basic) value when traversing a nested path expression.
NumberFormatter Implementation of IFormatter that can be used to format and parse numbers.
NumberUtils Various utility methods relating to numbers.
ObjectCreationException Thrown when an IObjectFactory encounters an error when attempting to create an object from an object definition.
ObjectCurrentlyInCreationException Thrown in case of a reference to an object that is currently in creation.
ObjectDefinitionBuilder Programmatic means of constructing a IObjectDefinition using the builder pattern. Intended primarily for use when implementing custom namespace parsers.
ObjectDefinitionConstants Constants defining the structure and values associated with the Spring.NET XML object definition format.
ObjectDefinitionException Exception thrown when an INamespaceParser encounters an error when attempting to parse an object definition.
ObjectDefinitionHolder Holder for an IObjectDefinition with name and aliases.
ObjectDefinitionParserHelper Stateful class used to parse XML object definitions.
ObjectDefinitionReaderUtils Utility methods that are useful for IObjectDefinitionReader implementations.
ObjectDefinitionStoreException Thrown when an IObjectFactory encounters an internal error, and its definitions are invalid.
ObjectDefinitionValidationException Thrown when the validation of an object definition failed.
ObjectDefinitionValueResolver Helper class for use in object factory implementations, resolving values contained in object definition objects into the actual values applied to the target object instance.
ObjectDefinitionVisitor Visitor class for traversing IObjectDefinition objects, in particular the property values and constructor arguments contained in them resolving object metadata values.
ObjectFactoryCreatingFactoryObject Returns a value that is an IGenericObjectFactory that returns an object from an IObjectFactory.
ObjectFactorySectionHandler Creates an IObjectFactory instance populated with the object definitions supplied in the configuration section.
ObjectFactoryUtils Convenience methods operating on object factories, returning object instances, names, or counts.
ObjectInitializationException Exception that an object implementation is suggested to throw if its own factory-aware initialization code fails. ObjectsException thrown by object factory methods themselves should simply be propagated as-is.
ObjectIsNotAFactoryException Thrown in response to an attempt to lookup a factory object, and the object identified by the lookup key is not a factory.
ObjectNotOfRequiredTypeException Thrown when an object doesn't match the required Type.
ObjectReferenceFactoryObject An IFactoryObject implementation that exposes an arbitrary target object under a different name.
ObjectsException Superclass for all exceptions thrown in the Objects namespace and sub-namespaces.
ObjectsNamespaceParser Default implementation of the INamespaceParser interface.
ObjectUtils Helper methods with regard to objects, types, properties, etc.
ObjectWrapper Default implementation of the IObjectWrapper interface that should be sufficient for all normal uses.
OpADD Represents arithmetic addition operator.
OpAND Represents AND operator (both, bitwise and logical).
OpBetween Represents logical BETWEEN operator.
OpDIVIDE Represents arithmetic division operator.
OpEqual Represents logical equality operator.
OpGreater Represents logical "greater than" operator.
OpGreaterOrEqual Represents logical "greater than or equal" operator.
OpIn Represents logical IN operator.
OpIs Represents logical IS operator.
OpLess Represents logical "less than" operator.
OpLessOrEqual Represents logical "less than or equal" operator.
OpLike Represents VB-style logical LIKE operator.
OpMatches Represents logical MATCHES operator.
OpMODULUS Represents arithmetic modulus operator.
OpMULTIPLY Represents arithmetic multiplication operator.
OpNOT Represents NOT operator (both, bitwise and logical).
OpNotEqual Represents logical inequality operator.
OpOR Represents OR operator (both, bitwise and logical).
OpPOWER Represents arithmetic exponent operator.
OpSUBTRACT Represents arithmetic subtraction operator.
OpUnaryMinus Represents unary minus operator.
OpUnaryPlus Represents unary plus operator.
OpXOR Missing <summary> documentation for T:Spring.Expressions.OpXOR
OrderByProcessor Implementation of the 'order by' processor.
OrderComparator Comparator implementation for IOrdered objects, sorting by order value ascending (resp. by priority descending).
Parser Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.Parser
ParserContext Context that gets passed along an object definition parsing process, encapsulating all relevant configuraiton as well as state.
ParserEventSupport A class to assist in firing parser events NOTE: I intentionally _did_not_ synchronize the event firing and add/remove listener methods. This is because the add/remove should _only_ be called by the parser at its start/end, and the _same_thread_ should be performing the parsing. This should help performance a tad...
ParserListenerBase Provides an abstract base for implementing ParserListener subclasses.
ParserMatchListenerBase Provides an abstract base for implementing ParserMatchListener subclasses.
ParserReporter Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.ParserReporter
ParserSharedInputState Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.ParserSharedInputState
ParserTokenListenerBase Provides an abstract base for implementing ParserTokenListener subclasses.
ParseTree Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.ParseTree
ParseTreeDebugParser Specifies the behaviour required (i.e. parser modifications) specifically to support parse tree debugging and derivation.
ParseTreeRule Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.ParseTreeRule
ParseTreeToken Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.ParseTreeToken
PathMatcher Support matching of file system paths in a manner similar to that of the NAntFileSet.
PatternMatchUtils Utility methods for simple pattern matching, in particular for Spring's typical "xxx*", "*xxx" and "*xxx*" pattern styles.
PercentFormatter Implementation of IFormatter that can be used to format and parse numbers.
PoolException Base class for all pooling exceptions.
PriorityQueue An unbounded priority IQueue based on a priority heap. This queue orders elements according to an order specified at construction time, which is specified either according to their natural order (see IComparable, or according to a IComparer, depending on which constructor is used. A priority queue does not permit elements. A priority queue relying on natural ordering also does not permit insertion of non-comparable objects (doing so will result InvalidCastException.

The head of this queue is the lowest element with respect to the specified ordering. If multiple elements are tied for lowest value, the head is one of those elements -- ties are broken arbitrarily.

A priority queue is unbounded, but has an internal capacity governing the size of an array used to store the elements on the queue. It is always at least as large as the queue size. As elements are added to a priority queue, its capacity grows automatically. The details of the growth policy are not specified.

This class and its enumerator implement all of the optional methods of the ICollection and IEnumerator interfaces. The enumerator provided in method GetEnumerator is not guaranteed to traverse the elements of the PriorityQueue in any particular order.

Note that this implementation is NOT synchronized. Multiple threads should not access a PriorityQueue instance concurrently if any of the threads modifies the list structurally. Instead, use the thread-safe PriorityBlockingQueue.
ProjectionNode Represents parsed projection node in the navigation expression.
Properties An implementation of the Java Properties class.
PropertiesObjectDefinitionReader Object definition reader for a simple properties format.
PropertyAccessException Superclass for exceptions related to a property access, such as a Type mismatch or a target invocation exception.
PropertyAccessExceptionsException Combined exception, composed of individual binding PropertyAccessExceptions.
PropertyChangeEventArgs Provides additional data for the PropertyChanged event.
PropertyComparator Performs a comparison of two objects, using the specified object property via an IObjectWrapper.
PropertyFileVariableSource Implementation of IVariableSource that resolves variable name against Java-style property file.
PropertyOrFieldNode Represents node that navigates to object's property or public field.
PropertyOverrideConfigurer Overrides default values in one or more object definitions.
PropertyPathFactoryObject IFactoryObject implementation that evaluates a property path on a given target object.
PropertyPlaceholderConfigurer Resolves placeholder values in one or more object definitions.
PropertyResourceConfigurer Allows for the configuration of individual object property values from a .NET .config file.
PropertyRetrievingFactoryObject IFactoryObject implementation that retrieves a or non-static public property value.
PropertyValue Holds information and value for an individual property.
ProxyIgnoreAttribute This attribute can be used to mark interfaces that should not be proxied
QualifiedIdentifier Represents parsed named argument node in the expression.
ReaderContext Context that gets passed along an object definition reading process, encapsulating all relevant configuraiton as well as state.
ReadOnlyDictionary(TKey,TValue) Represents a read only wrapper around a generic IDictionary. The design pattern mirrors ReadOnlyCollection, and follows the apparent pattern that write operations do not throw an exception, but simply make no change to the underlying collection.
RealLiteralNode Represents parsed real literal node.
RecognitionException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.RecognitionException
ReferenceNode Represents a reference to a Spring-managed object.
ReflectionException Superclass for all exceptions thrown in the Objects namespace and sub-namespaces.
ReflectionUtils Various reflection related methods that are missing from the standard library.
ReflectionUtils.CustomAttributeBuilderBuilder Creates a CustomAttributeBuilder.
RegexConverter Converts string representation of a regular expression into an instance of Regex.
RegistryKeyConverter Converts string representation of the registry key into RegistryKey instance.
RegistryVariableSource Implementation of IVariableSource that resolves variable name against registry key.
RegularExpressionCriteria A base class for all ICriteria implementations that are regular expression based.
RegularExpressionEventNameCriteria Criteria that is satisfied if the Name property of an EventInfo instance matches a supplied regular expression pattern.
RegularExpressionMethodNameCriteria Criteria that is satisfied if the Name property of an MethodInfo instance matches a supplied regular expression pattern.
RegularExpressionValidator Validates that object matches specified regular expression.
ReplacedMethodOverride Represents the replacement of a method on a managed object by the IoC container.
RepositoryAttribute Indicates that an annotated class is a "Repository" (or "DAO").
RequiredAttribute Marks a property as being 'required': that is, the setter property must be configured to be dependency-injected with a value.
RequiredAttributeObjectPostProcessor A IObjectPostProcessor implementation that enforces required properties to have been configured. Required properties are detected through an attribute, by default, Spring's RequiredAttribute attribute.
RequiredValidator Validates that required value is not empty.
Resource Holds mapping between control property and it's value as read from the resource file.
ResourceConverter Custom type converter for IResource instances.
ResourceHandlerConfigurer IObjectFactoryPostProcessor implementation that allows for convenient registration of custom IResource implementations.
ResourceHandlerRegistry Registry class that allows users to register and retrieve protocol handlers.
ResourceHandlersSectionHandler Handler for Spring.NET resourceHandlers config section.
ResourceManagerConverter Converts a two part string, (resource name, assembly name) to a ResourceManager instance.
ResourceManagerFactoryObject A convenience class to create a ResourceManager given the resource base name and assembly name.
ResourceSetLocalizer Loads a list of resources that should be applied from the .NET ResourceSet.
ResourceSetMessageSource An IMessageSource implementation that accesses resources from .resx / .resource files.
ReverseProcessor Reverts order of elements in the list
RGBColorConverter Converter for Color from a comma separated list of RBG values.
RootObjectDefinition A plain-vanilla object definition.
RuntimeObjectReference Immutable placeholder class used for the value of a PropertyValue object when it's a reference to another object in this factory to be resolved at runtime.
RuntimeTypeConverter A custom TypeConverter for runtime type references.
SafeConstructor Safe wrapper for the dynamic constructor.
SafeField Safe wrapper for the dynamic field.
SafeIndexer Obsolete. Safe wrapper for the dynamic indexer.
SafeMethod Safe wrapper for the dynamic method.
SafeProperty Safe wrapper for the dynamic property.
ScannerEventSupport A class to assist in firing parser events NOTE: I intentionally _did_not_ synchronize the event firing and add/remove listener methods. This is because the add/remove should _only_ be called by the parser at its start/end, and the _same_thread_ should be performing the parsing. This should help performance a tad...
SelectionFirstNode Represents parsed selection node in the navigation expression.
SelectionLastNode Represents parsed selection node in the navigation expression.
SelectionNode Represents parsed selection node in the navigation expression.
SemanticException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.SemanticException
SemanticPredicateEventArgs Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.SemanticPredicateEventArgs
SemanticPredicateListenerBase Provides an abstract base for implementing SemanticPredicateListener subclasses.
Semaphore

Base class for counting semaphores based on Semaphore implementation from Doug Lea.
ServiceAttribute Indicates that an annotated class is a "Service" (e.g. a business service facade).
Set A collection that contains no duplicate elements.
SetFactoryObject Simple factory object for shared ISet instances.
SharedStateAwareProcessor Configure all ISharedStateAware objects, delegating concrete handling to the list of SharedStateFactories.
SimpleAutowireCandidateResolver A IAutowireCandidateResolver implementation to use that checks the object definitions only (no attributes)
SimpleExpressionBinding Simple, expression-based implementation of IBinding that binds source to target one-to-one.
SimpleInstantiationStrategy Simple object instantiation strategy for use in IObjectFactory implementations.
SimplePool A simple pool implementation
SortedSet Implements an ISet based on a sorted tree.
SortProcessor Implementation of the sort processor.
SpecialFolderVariableSource Implementation of IVariableSource that resolves variable name against special folders (as defined by SpecialFolder enumeration).
SpringAST For internal purposes only. Use BaseNode for expression node implementations.
StaticApplicationContext IApplicationContext that allows concrete registration of objects and messages in code, rather than from external configuration sources.
StaticEventHandlerValue Describes an event handler for a static class method.
StaticListableObjectFactory Static factory that permits the registration of existing singleton instances.
StaticMessageSource Simple implementation of IMessageSource that allows messages to be held in an object and added programmatically.
StreamConverter Converter for Stream to directly set a Stream property.
StringArrayConverter Converts a separated String to a String array.
StringLiteralNode Represents parsed string literal node.
StringResource A IResource adapter implementation encapsulating a simple string.
StringUtils Miscellaneous String utility methods.
StringUtils Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.StringUtils
SumAggregator Implementation of the sum aggregator.
SyncHolder Utility class to use an ISync with the C# using () {} idiom
SynchronizedHashtable Synchronized Hashtable that, unlike hashtable created using Synchronized method, synchronizes reads from the underlying hashtable in addition to writes.
SynchronizedSet Implements a thread-safe ISet wrapper.
SyntacticPredicateEventArgs Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.SyntacticPredicateEventArgs
SyntacticPredicateListenerBase Provides an abstract base for implementing SyntacticPredicateListener subclasses.
SystemUtils Utility class containing miscellaneous system-level functionality.
TargetProxyMethodBuilder Implementation of IProxyMethodBuilder that delegates method calls to target object.
TernaryNode Represents ternary expression node.
TextPositionInfo Holds text position information for e.g. error reporting purposes.
ThreadStaticStorage Implements IThreadStorage by using a ThreadStaticAttribute hashtable.
TimeoutException Thrown by synchronization classes that report timeouts via exceptions. The exception is treated as a form (subclass) of InterruptedException. This both simplifies handling, and conceptually reflects the fact that timed-out operations are artificially interrupted by timers.
TimeoutSync A TimeoutSync is an adaptor class that transforms all calls to acquire to instead invoke attempt with a predetermined timeout value.
TimeSpanConverter Converter for TimeSpan instances.
Token Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.Token
TokenBuffer Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenBuffer
TokenCreator A creator of Token object instances.
TokenEventArgs Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.TokenEventArgs
TokenStreamBasicFilter Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenStreamBasicFilter
TokenStreamException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenStreamException
TokenStreamHiddenTokenFilter Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenStreamHiddenTokenFilter
TokenStreamIOException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenStreamIOException
TokenStreamRecognitionException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenStreamRecognitionException
TokenStreamRetryException Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenStreamRetryException
TokenStreamRewriteEngine This token stream tracks the *entire* token stream coming from a lexer, but does not pass on the whitespace (or whatever else you want to discard) to the parser.
TokenStreamRewriteEngine.DeleteOp Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenStreamRewriteEngine.DeleteOp
TokenStreamRewriteEngine.InsertBeforeOp Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenStreamRewriteEngine.InsertBeforeOp
TokenStreamRewriteEngine.ReplaceOp Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenStreamRewriteEngine.ReplaceOp
TokenStreamRewriteEngine.RewriteOperation Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenStreamRewriteEngine.RewriteOperation
TokenStreamRewriteEngine.RewriteOperationComparer Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenStreamRewriteEngine.RewriteOperationComparer
TokenStreamSelector Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenStreamSelector
TokenWithIndex This token tracks it's own index 0..n-1 relative to the beginning of the stream. It is designed to work with TokenStreamRewriteEngine in TokenStreamRewriteEngine.cs
TraceEventArgs Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.TraceEventArgs
TraceListenerBase Provides an abstract base for implementing TraceListener subclasses.
Tracer Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.Tracer
TreeParser Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TreeParser
TreeParserSharedInputState Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TreeParserSharedInputState
TypeAliasConfigurer IObjectFactoryPostProcessor implementation that allows for convenient registration of custom type aliases.
TypeAliasesSectionHandler Configuration section handler for the Spring.NET typeAliases config section.
TypeAssemblyHolder Holds data about a Type and it's attendant Assembly.
TypeConversionUtils Utility methods that are used to convert objects from one type into another.
TypeConverterRegistry Registry class that allows users to register and retrieve type converters.
TypeConvertersSectionHandler Configuration section handler for the Spring.NET typeConverters config section.
TypedStringValue Holder for a typed String value.
TypeMismatchException Exception thrown on a Type mismatch when trying to set a property or resolve an argument to a method invocation.
TypeNode Represents parsed type node in the navigation expression.
TypeRegistry Provides access to a central registry of aliased Types.
TypeResolutionUtils Helper methods with regard to type resolution.
TypeResolver Resolves a Type by name.
UnaryOperator Base class for unary operators.
UniqueKey UniqueKey allows for generating keys unique to a type or particular instance and a partial name, that can e.g. be used as keys in Hashtable.
UniqueKeyConverter Converts between instances of UniqueKey and their string representations.
UnsatisfiedDependencyException Exception thrown when an object depends on other objects or simple properties that were not specified in the object factory definition, although dependency checking was enabled.
UriConverter Converter for Uri instances.
UrlResource A Uri backed resource on top of WebRequest
UrlValidator Validates that the value is valid URL.
Utils Support to account for differences between java nad .NET:
    ValidatedAttribute Allows developers to specify which validator should be used to validate method argument.
    ValidationErrors A container for validation errors.
    ValidationException Thrown by the validation advice if the method parameters validation fails.
    ValidationNamespaceParser Implementation of the custom configuration parser for validator definitions.
    ValidatorGroup IValidator implementation that supports grouping of validators.
    ValidatorReference Represents a reference to an externally defined validator object
    VariableAccessor Provides methods for type-safe accessing IVariableSources.
    VariableNode Represents parsed variable node.
    VariablePlaceholderConfigurer Resolves placeholder values in one or more object definitions
    Visa Visa credit card type validation support.
    XmlApplicationContext An IApplicationContext implementation that reads context definitions from XML based resources.
    XmlObjectDefinitionReader Object definition reader for Spring's default XML object definition format.
    XmlObjectFactory Convenience extension of DefaultListableObjectFactory that reads object definitions from an XML document or element.
    XmlReaderContext Extension of ReaderContext specific to use with an XmlObjectDefinitionReader. Provides access to NamespaceParserResolver configured in XmlObjectDefinitionReader
    XmlUtils XML utility methods.

    Interfaces

    Interface Description
    AST Minimal AST node interface used by ANTLR AST generation and tree-walker.
    ASTVisitor Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.ASTVisitor
    DebuggingParser This type was created in VisualAge.
    IApplicationContext The central interface to Spring.NET's IoC container.
    IApplicationContextAware To be implemented by any object that wishes to be notified of the IApplicationContext that it runs in.
    IApplicationEventListener A listener for application events.
    IApplicationEventPublisher Encapsulates event publication functionality.
    IAutowireCandidateResolver Strategy interface for determining whether a specific object definition qualifies as an autowire candidate for a specific dependency.
    IAutowireCapableObjectFactory Extension of the IObjectFactory interface to be implemented by object factories that are capable of autowiring and expose this functionality for existing object instances.
    IBinding An interface that defines the methods that have to be implemented by all data bindings.
    IBindingContainer An interface that has to be implemented by all data binding containers.
    ICache Defines a contract that all cache implementations have to fulfill.
    IChainableConfigSystem Implement this interface to create your own, delegating IInternalConfigSystem and set them using SetConfigurationSystem
    ICharScannerDebugSubject Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.ICharScannerDebugSubject
    ICollectionProcessor Defines an interface that should be implemented by all collection processors and aggregators.
    IConfigurableApplicationContext Provides the means to configure an application context in addition to the methods exposed on the IApplicationContext interface.
    IConfigurableFactoryObject Extension of the IFactoryObject interface that injects dependencies into the object managed by the factory.
    IConfigurableListableObjectFactory SPI interface to be implemented by most if not all listable object factories.
    IConfigurableObjectDefinition Describes a configurable object instance, which has property values, constructor argument values, and further information supplied by concrete implementations.
    IConfigurableObjectFactory Configuration interface to be implemented by most if not all object factories.
    IControlFlow Interface to be implemented by objects that can return information about the current call stack.
    ICreditCardType CreditCardType interface defines how validation is performed for one type/brand of credit card.
    ICriteria The criteria for an arbitrary filter.
    ICultureResolver Strategy interface for CultureInfo resolution.
    IDataBound Interface that should be implemented by data bound objects, such as web pages, user controls, windows forms, etc.
    IDebugSubject Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.IDebugSubject
    IDestructionAwareObjectPostProcessor Subinterface of IObjectPostProcessor that adds a before-destruction callback.
    IDynamicConstructor Defines constructors that dynamic constructor class has to implement.
    IDynamicField Defines methods that dynamic field class has to implement.
    IDynamicIndexer Defines methods that dynamic indexer class has to implement.
    IDynamicMethod Defines methods that dynamic method class has to implement.
    IDynamicProperty Defines methods that dynamic property class has to implement.
    IErrorCoded Interface that can be implemented by exceptions etc that are error coded.
    IEventHandlerValue Describes an event handler.
    IEventRegistry A registry that manages subscriptions to and the publishing of events.
    IEventRegistryAware To be implemented by any object that wishes to receive a reference to an IEventRegistry.
    IExpression Interface that all navigation expression nodes have to implement.
    IFactoryObject Interface to be implemented by objects used within an IObjectFactory that are themselves factories.
    IFormatter Interface that should be implemented by all formatters.
    IGenericObjectFactory Interface defining a factory which can return an object instance (possibly shared or independent) when invoked.
    IHiddenStreamToken Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.IHiddenStreamToken
    IHierarchicalMessageSource Sub-interface of IMessageSource to be implemented by objects that can resolve messages hierarchically.
    IHierarchicalObjectFactory Sub-interface implemented by object factories that can be part of a hierarchy.
    IInitializingObject Defines a simple initialization callback for objects that need to to some post-initialization logic after all of their dependencies have been injected.
    IInputStreamSource Simple interface for objects that are sources for Streams.
    IInstantiationAwareObjectPostProcessor Subinterface of IObjectPostProcessor that adds a before-instantiation callback.
    IInstantiationStrategy Responsible for creating instances corresponding to a RootObjectDefinition.
    ILifecycle Interface defining methods for start/stop lifecycle control. The typical use case for this is to control asynchronous processing.
    IListableObjectFactory Extension of the IObjectFactory interface to be implemented by object factories that can enumerate all their object instances, rather than attempting object lookup by name one by one as requested by clients.
    ILocalizer Defines an interface that localizers have to implement.
    IManagedCollection Denotes a special placeholder collection that may contain RuntimeObjectReferences or other placeholder objects that will need to be resolved.
    IMergable Interface representing an object whose value set can be merged with that of a parent object.
    IMessageSource Describes an object that can resolve messages.
    IMessageSourceAware To be implemented by any object that wishes to be notified of the IMessageSource associated with it.
    IMessageSourceResolvable Describes objects that are suitable for message resolution in a IMessageSource.
    IMethodReplacer Permits the (re)implementation of an arbitrary method on a Spring.NET IoC container managed object.
    INamespaceParser Strategy interface for parsing XML object definitions. Equivalent to Spring/Java's NamespaceHandler interface.
    InputBufferListener Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.InputBufferListener
    IObjectDefinition Describes an object instance, which has property values, constructor argument values, and further information supplied by concrete implementations.
    IObjectDefinitionDocumentReader SPI for parsing an XML document that contains Spring object definitions. Used by XmlObjectDefinitionReader for actually parsing a DOM document.
    IObjectDefinitionFactory Central interface for factories that can create IConfigurableObjectDefinition instances.
    IObjectDefinitionParser Interface used to handle custom, top-level tags.
    IObjectDefinitionReader Simple interface for object definition readers.
    IObjectDefinitionRegistry Interface for registries that hold object definitions, i.e. RootObjectDefinition and ChildObjectDefinition instances.
    IObjectFactory The root interface for accessing a Spring.NET IoC container.
    IObjectFactoryAware Interface to be implemented by objects that wish to be aware of their owning IObjectFactory.
    IObjectFactoryPostProcessor Allows for custom modification of an application context's object definitions, adapting the object property values of the context's underlying object factory.
    IObjectNameAware Interface to be implemented by objects that wish to be aware of their object name in an IObjectFactory.
    IObjectNameGenerator Strategy interface for generating object names for object definitions
    IObjectPool A simple pooling interface for managing and monitoring a pool of objects.
    IObjectPostProcessor Allows for custom modification of new object instances, e.g. checking for marker interfaces or wrapping them with proxies.
    IObjectWrapper The central interface of Spring.NET's low-level object infrastructure.
    IOrdered Interface that can be implemented by objects that should be orderable, e.g. in an ICollection.
    IParserDebugSubject Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.IParserDebugSubject
    IPoolableObjectFactory Defines lifecycle methods for objects that are to be used in an IObjectPool implementation.
    IPropertyValues A collection style container for PropertyValue instances.
    IProxyMethodBuilder Defines interface that proxy method builders have to implement.
    IProxyTypeBuilder Describes the operations for a generic proxy type builder that can be used to create a proxy type for any class.
    IProxyTypeGenerator Describes the operations that generates IL instructions used to build the proxy type.
    IQueue A collection designed for holding elements prior to processing.
    IResource The central abstraction for Spring.NET's access to resources such as Streams.
    IResourceCache Defines an interface that resource cache adapters have to implement.
    IResourceLoader Describes an object that can load IResources.
    IResourceLoaderAware Interface to be implemented by any object that wishes to be notified of the IResourceLoader (typically the IApplicationContext) that it runs in.
    ISet A collection that contains no duplicate elements.
    ISharedStateAware This interface should be implemented by classes that want to have access to the shared state.
    ISharedStateFactory Abstracts the state sharing strategy used by SharedStateAwareProcessor
    ISingletonObjectRegistry Interface that defines a registry for shared object instances.
    ISortDefinition Definition for sorting object instances by a property.
    ISync Acquire/Release protocol, base of many concurrency utilities.
    ITextPosition Holds text position information for e.g. error reporting purposes.
    IThreadStorage Specifies the contract a strategy must be implement to store and retrieve data that is specific to the executing thread.
    IToken A token is minimally a token type. Subclasses can add the text matched for the token and line info.
    ITypeResolver Resolves a Type by name.
    IValidationAction An action that should be executed after validator is evaluated.
    IValidationErrors An interface that validation errors containers have to implement.
    IValidator An object that can validate application-specific objects.
    IVariableSource Defines contract that different variable sources have to implement.
    Listener Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.Listener
    MessageListener Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.MessageListener
    NewLineListener Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.NewLineListener
    ParserController Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.ParserController
    ParserListener Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.ParserListener
    ParserMatchListener Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.ParserMatchListener
    ParserTokenListener Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.ParserTokenListener
    SemanticPredicateListener Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.SemanticPredicateListener
    SmartInstantiationAwareObjectPostProcessor Extension of the IInstantiationAwareObjectPostProcessor interface, adding a callback for predicting the eventual type of a processed object.
    SyntacticPredicateListener Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.SyntacticPredicateListener
    TokenStream Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.TokenStream
    TraceListener Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.TraceListener

    Structures

    Structure Description
    ASTPair Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.ASTPair

    Delegates

    Delegate Description
    ApplicationEventHandler The callback for application events.
    CollectionUtils.CompareCallback A callback method used for comparing to items.
    ConstructorDelegate Represents a constructor
    FieldGetterDelegate Represents a Get method
    FieldSetterDelegate Represents a Set method
    FunctionDelegate Represents a method
    ManagedCollectionElementResolver Resolves a single element value of a managed collection.
    MatchEventHandler Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.MatchEventHandler
    MessageEventHandler Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.MessageEventHandler
    NewLineEventHandler Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.NewLineEventHandler
    ObjectDefinitionVisitor.ResolveHandler Missing <summary> documentation for T:Spring.Objects.Factory.Config.ObjectDefinitionVisitor.ResolveHandler
    PatternMatchUtils.ObjectNameMatchPredicate Signature of callbacks that may be used for matching object names.
    PropertyGetterDelegate Represents an Indexer Get method
    PropertySetterDelegate Represents a Set method
    SemanticPredicateEventHandler Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.SemanticPredicateEventHandler
    SyntacticPredicateEventHandler Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.SyntacticPredicateEventHandler
    TokenEventHandler Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.TokenEventHandler
    TraceEventHandler Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.TraceEventHandler

    Enumerations

    Enumeration Description
    AutoWiringMode The various autowiring modes.
    BindingDirection Enumeration that defines possible values for data binding direction.
    ContextEventArgs.ContextEvent The various context event types.
    DependencyCheckingMode The various modes of dependency checking.
    EnvironmentVariableMode Specifies how instances of the PropertyPlaceholderConfigurer class must apply environment variables when replacing values.
    MatchEventArgs.ParserMatchEnums Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.debug.MatchEventArgs.ParserMatchEnums
    MismatchedCharException.CharTypeEnum Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.MismatchedCharException.CharTypeEnum
    MismatchedTokenException.TokenTypeEnum Missing <summary> documentation for T:Spring.Expressions.Parser.antlr.MismatchedTokenException.TokenTypeEnum
    ObjectRole Missing <summary> documentation for T:Spring.Objects.Factory.Config.ObjectRole