This attribute allows application developers to specify that an argument of the method should be cached, but it will not do any caching by itself.
In order to actually cache the result, an application developer
must apply a
You can specify this attribute multiple times on the same method in order to cache several method parameters.
This attribute allows application developers to mark that a result of the method invocation should be cached, but it will not do any caching by itself.
In order to actually cache the result, an application developer
must apply a
This attribute allows application developers to specify that each item from the collection returned by the method should be cached, but it will not do any caching by itself.
In order to actually cache the result, an application developer
must apply a
This attribute allows application developers to specify that some cache items should be evicted from cache when the method is invoked, but it will not do any eviction by itself.
In order to actually evict cache items, an application developer
must apply a
The implementations in this class are appropriate when the base
implementation does not allow
Besides basic
Each of these methods exists in two forms: one throws
an exception if the operation fails, the other returns a special
value (either
Queues typically, but do not necessarily, order elements in a
FIFO (first-in-first-out) manner. Among the exceptions are
priority queues, which order elements according to a supplied
comparator, or the elements' natural ordering, and LIFO queues (or
stacks) which order the elements LIFO (last-in-first-out).
Whatever the ordering used, the head of the queue is that
element which would be removed by a call to
The
The
The
The
Based on the back port of JCP JSR-166.
When using a capacity-restricted queue, this method is generally
preferable to
This method differs from
This method differs from
This is an abstract class, and as such has no publicly visible constructors.
This method differs from
This method differs from
ALso note that this implementation returns the result of
The queue will be empty after this call returns.
This implementation repeatedly invokes
Attempts to
This implementation iterates over the specified collection,
and adds each element returned by the iterator to this queue, in turn.
An exception encountered while trying to add an element (including,
in particular, a
When using a capacity-restricted queue, this method is generally
preferable to
You can use any object that implements the
This object overrides the
To make a
It is also standard practice that at least one of your constructors
takes an
This interface models the mathematical
Also, the
None of the
The following table summarizes the binary operators that are supported
by the
That is, the element is included if it is in either
That is, the element is included if it exists in both sets. The
This returns a set of all the elements in set
The original sets are not modified during this operation. The result set is a clone of this set containing the elements from the exclusive-or operation.
That is, the element is included if it is in either
That is, the element is included only if it exists in both
This returns a set of all the elements in set
The original sets are not modified during this operation. The
result set is a clone of one of the sets (
This will work for derived
The type of array needs to be compatible with the objects in the
In this case, "equality" means that the two sets contain the same
elements. The "==" and "!=" operators are not overridden by design.
If you wish to check for "equivalent"
Note that enumeration is inherently not thread-safe. Use the
When implementing this, if your object uses a base object, like an
The type of array needs to be compatible with the objects in the
Set this object in the constructor if you create your own
This will give the best lookup, add, and remove performance for very large data-sets, but iteration will occur in no particular order.
This is good if you are unsure about whether you data-set will be tiny or huge.
Although this class is advertised as immutable, it really isn't.
Anyone with access to the wrapped
The type of array needs to be compatible with the objects in the
Note that enumeration is inherently not thread-safe. Use the
The type of array needs to be compatible with the objects in this list, obviously.
Enumerators are fail fast.
This is the indexer for the
Note that enumeration is inherently not thread-safe. Use the
Performance is much better for very small lists than either
When using a capacity-restricted queue, this method is generally
preferable to
This gives good performance for operations on very large data-sets,
though not as good - asymptotically - as a
Elements that you put into this type of collection must implement
This
In addition to synchronizing reads, this implementation also fixes
IEnumerator/ICollection issue described at
http://msdn.microsoft.com/en-us/netframework/aa570326.aspx
(search for SynchronizedHashtable for issue description), by implementing
This class should be used whenever a truly synchronized
The implementation is extremely conservative, serializing critical
sections to prevent possible deadlocks, and locking on everything. The
one exception is for enumeration, which is inherently not thread-safe.
For this, you have to
The type of array needs to be compatible with the objects in the
Intended for use during debugging only.
Does not mandate the type of storage used for configuration, but does
implement common functionality. Uses the Template Method design
pattern, requiring concrete subclasses to implement
In contrast to a plain vanilla
An
This
Basic protocol-to-resource type mappings are also defined by this class, while others can be added either internally, by application contexts extending this class, or externally, by the end user configuring the context.
Only one resource type can be defined for each protocol, but multiple
protocols can map to the same resource type (for example, the
An
The
The handle should always be a reusable resource descriptor; this
allows one to make repeated calls to the underlying
The initial value is
This interface is to be implemented by most (if not all)
Configuration and lifecycle methods are encapsulated here to avoid
making them obvious to
Calling
In addition to standard object factory lifecycle capabilities,
This interface is the central client interface in Spring.NET's IoC container implementation. As such it does inherit a quite sizeable number of interfaces; implementations are strongly encouraged to use composition to satisfy each of the inherited interfaces (where appropriate of course).
If this is an
With the exception of
namespace ExampleNamespace
{
public class BusinessObject
{
private IDao _dao;
public BusinessObject() {}
public IDao Dao
{
get { return _dao; }
set { _dao = value; }
}
}
}
with the corresponding driver code looking like so...
IObjectFactory factory = GetAnIObjectFactoryImplementation();
BusinessObject instance = new BusinessObject();
factory.ConfigureObject(instance, "object_definition_name");
// at this point the dependencies for the 'instance' object will have been resolved...
Does not consider any hierarchy this factory may participate in.
Does consider objects created by
Does not consider any hierarchy this factory may participate in.
Does consider objects created by
Does not consider any hierarchy this factory may participate in.
This version of the IListableObjectFactory.GetObjectsOfType(type,true,true) .
ContainsObject, ignoring an object
of the given name from an ancestor object factory.
This enables the parameterization and internationalization of messages.
Spring.NET provides one out-of-the-box implementation for production use:
If the lookup is not successful, implementations are permitted to take one of two actions.
If the lookup is not successful, implementations are permitted to take one of two actions.
If the lookup is not successful, implementations are permitted to take one of two actions.
If the lookup is not successful, implementations are permitted to take one of two actions.
If the lookup is not successful, implementations are permitted to take one of two actions.
This method must use the
Examples of resources that may be resolved by this method include (but are not limited to) objects such as icons and bitmaps.
Examples of resources that may be resolved by this method include (but are not limited to) objects such as icons and bitmaps.
Resource key names are of the form
Serves as a super-interface for the
This is to be set immediately after an
If the parent context is
true
only if all components that apply are currently running.
To be invoked during context configuration.
Can be used to access specific functionality of the factory.
If no
If no
This is an
This is an
This is an
This method is invoked by
All object definitions will have been loaded, but no objects
will have been instantiated yet. This allows for the registration
of special
Called on initialization of special objects, before instantiation of singletons.
Uses any parent context's message source if one is not available in this context.
This method allows an object factory to be used as a replacement for the Singleton or Prototype design pattern.
Note that callers should retain references to returned objects. There is no guarantee that this method will be implemented to be efficient. For example, it may be synchronized, or may need to run an RDBMS query.
Will ask the parent factory if the object cannot be found in this factory instance.
ContainsObject, ignoring an object
of the given name from an ancestor object factory.
The elements of this list are instances of implementations of the
true
only if all components that apply are currently running.
Application contexts can auto-detect
Typically, post-processors that populate objects via marker interfaces
or the like will implement
The object will already be populated with property values. The returned object instance may be a wrapper around the original.
The object will already be populated with property values. The returned object instance may be a wrapper around the original.
The actual order can be interpreted as prioritization, the first object (with the lowest order value) having the highest priority.
Normally starting with 0 or 1, with
Higher value can be interpreted as lower priority, consequently the first object has highest priority.
Subclasses must implement the abstract ResolveObject
method.
Note: By default, message texts are only parsed through String.Format if arguments have been passed in for the message. In case of no arguments, message texts will be returned as-is. As a consequence, you should only use String.Format escaping for messages with actual arguments, and keep all other messages unescaped.
Supports not only IMessageSourceResolvables as primary messages but also resolution of message arguments that are in turn IMessageSourceResolvables themselves.
This class does not implement caching of messages per code, thus subclasses can dynamically change messages over time. Subclasses are encouraged to cache their messages in a modification-aware fashion, allowing for hot deployment of updated messages.
If the value of this property is
If the lookup is not successful, implementations are permitted to take one of two actions.
If the lookup is not successful throw NoSuchMessageExceptionIf the lookup is not successful throw NoSuchMessageException.
If the lookup is not successful throw NoSuchMessageException
Subclasses must implement this method to resolve an object.
Subclasses must implement this method to apply resources to an arbitrary object.
Note: In case of a IMessageSourceResolvable with multiple codes (like a FieldError) and a MessageSource that has a parent MessageSource, do not activate "UseCodeAsDefaultMessage" in the parent: Else, you'll get the first code returned as message by the parent, without attempts to check further codes.
To be able to work with "UseCodeAsDefaultMessage" turned on in the parent,
AbstractMessageSource contains special checks
to delegate to the internal GetMessageInternal method if available.
In general, it is recommended to just use "UseCodeAsDefaultMessage" during
development and not rely on it in production in the first place, though.
Alternatively, consider overriding the GetDefaultMessage
method to return a custom fallback message for an unresolvable code.
If the value of this property is
This is an
This is an
The default implementation of this method is a no-op; i.e. it does
nothing. Can be overridden in subclasses to provide custom
initialization of the supplied
The lifecycle of the object factory is handled by
The default implementation is empty. Can be overriden in subclassses to customize DefaultListableBeanFatory's standard settings.
Called for each
Examples of the format of the various strings that would be
returned by accessing this property can be found in the overview
documentation of with the
If an object's class implements more than one of the
Application contexts will automatically register this with their underlying object factory. Applications should thus never need to use this class directly.
It saves the application context reference and provides an initialization callback method. Furthermore, it offers numerous convenience methods for message lookup.
There is no requirement to subclass this class: it just makes things a little easier if you need access to the context, e.g. for access to file resources or to the message source. Note that many application objects do not need to be aware of the application context at all, as they can receive collaborating objects via object references.
Implementing this interface makes sense when an object requires access to a set of collaborating objects. Note that configuration via object references is preferable to implementing this interface just for object lookup purposes.
This interface can also be implemented if an object needs access to
file resources, i.e. wants to call
Note that
For a list of all object lifecycle methods, see the overview for the
Normally this call will be used to initialize the object.
Invoked after population of normal object properties but before an
init callback such as
This is an
This is an
This is a template method that subclasses can override for custom initialization behavior.
Gets called by the
Note that if the
This is an example of specifying a context that reads its resources from an embedded Spring.NET XML object configuration file...
This is an example of specifying a context that reads its resources from a custom configuration section within the same application / web configuration file and uses case insensitive object lookups.
Please note that you must adhere to the naming of the various sections (i.e. '<sectionGroup name="spring">' and '<section name="context">'.
And this is an example of specifying a hierarchy of contexts. The hierarchy in this case is only a simple parent->child hierarchy, but hopefully it illustrates the nesting of context configurations. This nesting of contexts can be arbitrarily deep, and is one way... child contexts know about their parent contexts, but parent contexts do not know how many child contexts they have (if any), or have references to any such child contexts.
This
If this attribute is not defined it defaults to the
Derived handlers may override this property to change their default case-sensitivity.
Defaults to 'true'.
Does not have to be fully assembly qualified, but its generally regarded
as better form if the
A singleton implementation to access one or more application contexts. Application context instances are cached.
Note that the use of this class or similar is unnecessary except (sometimes) for a small amount of glue code. Excessive usage will lead to code that is more tightly coupled, and harder to modify or test. Consider refactoring your code to use standard Dependency Injection techniques or implement the interface IApplicationContextAware to obtain a reference to an application context.
Explicit static constructor to tell C# compiler not to mark type as beforefieldinit.
This is usually called via a
The first call to GetContext will create the context as specified in the .NET application configuration file under the location spring/context.
The first call to GetContext will create the context as specified in the .NET application configuration file under the location spring/context.
Provides easy ways to store all the necessary values needed to resolve
messages from an
Spring.NET's own validation error classes implement this interface.
The last code will therefore be the default one.
This is the copy constructor for the
Simply returns the configuration section as an
If no parent
Used as placeholder
Typically implemented by object factories that work with the
Must support
Will ask the parent factory if the object cannot be found in this factory instance.
Must support
Refresh to initialize the
objects factory and its contained objects with application context
semantics (autodecting IObjectFactoryPostProcessors, etc).
Available from
Used in the first instance to supply stringified versions of
Other methods can be added here to return different representations, including XML, CSV, etc..
Spring.NET allows the registration of custom configuration parsers that can be used to create simplified configuration schemas that better describe object definitions.
For example, Spring.NET uses this facility internally in order to define simplified schemas for various AOP, Data and Services definitions.
The following example shows how to configure both this section handler and how to define custom configuration parsers within a Spring.NET config section.
...
There should not (typically) be a need to instantiate instances of this class;
Consider using
Spring allows registration of custom resource handlers that can be used to load object definitions from.
For example, if you wanted to store your object definitions in a database instead
of in the config file, you could write a custom
Afterwards, you would simply specify resource URI within the
The following example shows how to configure both this section handler, how to define custom resource within Spring config section, and how to load object definitions using custom resource handler:
An implementation of the
This method allows the object instance to perform the kind of initialization only possible when all of it's dependencies have been injected (set), and to throw an appropriate exception in the event of misconfiguration.
Please do consult the class level documentation for the
The list may contain objects of type
Mainly useful for testing.
Mainly useful for testing.
This
Uses a System.ComponentModel.ComponentResourceManager
internally to apply resources to object properties. Resource key
names are of the form
This feature is not currently supported on version 1.0 of the .NET platform.
Type aliases can be used instead of fully qualified type names anywhere a type name is expected in a Spring.NET configuration file.
This includes type names specified within an object definition, as well
as values of the properties or constructor arguments that expect
The following example shows how to configure both this section handler and how to define type aliases within a Spring.NET config section:
...
Type converters are used to convert objects from one type into another when injecting property values, evaluating expressions, performing data binding, etc.
They are a very powerful mechanism as they allow Spring.NET to automatically convert string-based property values from the configuration file into the appropriate type based on the target property's type or to convert string values submitted via a web form into a type that is used by your data model when Spring.NET data binding is used. Because they offer such tremendous help, you should always provide a type converter implementation for your custom types that you want to be able to use for injected properties or for data binding.
The standard .NET mechanism for specifying type converter for a particular type is
to decorate the type with a
This mechanism will still work and is a preferred way of defining type converters if you control the source code for the type that you want to define a converter for. However, this configuration section allows you to specify converters for the types that you don't control and it also allows you to override some of the standard type converters, such as the ones that are defined for some of the types in the .NET Base Class Library.
The following example shows how to configure both this section handler and how to define type converters within a Spring.NET config section:
...
Currently, the resources that are supported are the
You can provide custom implementations of the
Find below some examples of instantiating an
// an XmlApplicationContext that reads its object definitions from an
// XML file that has been embedded in an assembly...
IApplicationContext context = new XmlApplicationContext
(
"assembly://AssemblyName/NameSpace/ResourceName"
);
// an XmlApplicationContext that reads its object definitions from a
// number of disparate XML resources...
IApplicationContext context = new XmlApplicationContext
(
// from an XML file that has been embedded in an assembly...
"assembly://AssemblyName/NameSpace/ResourceName",
// and from a (relative) filesystem-based resource...
"file://Objects/services.xml",
// and from an App.config / Web.config resource...
"config://spring/objects"
);
In the current implementation, the
The
Invoked after population of normal object properties but
before an initializing callback such as the
It is also invoked before the
Note that
You typically need an
Invoked after population of normal objects properties but
before an init callback such as
The
This interface encapsulates a resource descriptor that abstracts away from the underlying type of resource; possible resource types include files, memory streams, and databases (this list is not exhaustive).
A
This interface, when used in tandem with the
Interfaces cannot obviously mandate implementation, but derived classes
are strongly encouraged to expose a constructor that takes a
single
This is the base interface for the abstraction encapsulated by
Spring.NET's
If
Will be
For safety, always check the value of the
For safety, always check the value of the
The description is typically used for diagnostics and other such logging when working with the resource.
Implementations are also encouraged to return this value from their
An example of a resource that physically exists would be a file on a local filesystem. An example of a resource that does not physically exist would be an in-memory stream.
Will be resolved (by those
For example, in the case of a web application this will (probably) resolve to the virtual directory of said web application.
This is an
This is an
If the supplied
GetResourceNameWithoutProtocol("http://www.mycompany.com/resource.txt");
// returns www.mycompany.com/resource.txt
The default implementation simply returns the supplied
This implementation compares
This implementation returns the hashcode of the
This method can accept either a fully qualified resource name or a relative resource name as it's parameter.
A fully qualified resource is one that has a protocol prefix and all elements of the resource name. All other resources are treated as relative to this resource, and the following rules are used to locate a relative resource:
Will be resolved (by those
For example, in the case of a web application this will (probably) resolve to the virtual directory of said web application.
The value of this property may be
This, the default implementation, always returns
This, the default implementation, always throws a
This implementation checks whether a
This will cover both directories and content resources.
This implementation will also return
This property is generally to be consulted prior to attempting
to attempting to access a resource that is relative to this
resource (via a call to
This, the default implementation, always returns
Where root resource can be taken to mean that part of the resource descriptor that doesn't change when a relative resource is looked up. Examples of such a root location would include a drive letter, a web server name, an assembly name, etc.
An example value of this property would be the name of the directory containing a filesystem based resource.
An example value of this property would be the
Any derived classes that override this method are expected to return a new array for each access of this property.
This implementation expects any resource name passed to the constructor to adhere to the following format:
assembly://assemblyName/namespace/resourceName
This implementation does support relative resource retrieval, and
so will always return
If created with the name of a configuration section, then all methods
aside from the description return
This implementation always returns
This implementation always returns
This implementation always returns
Introduced to accomodate line info tracking during parsing.
Supports resolution as both a
Also supports the use of the
Consider the example of an application that is running (has been launched
from) the
strings.txt C:\App\strings.txt
~/strings.txt C:\App\strings.txt
file://~/strings.txt C:\App\strings.txt
file://~/../strings.txt C:\strings.txt
../strings.txt C:\strings.txt
~/../strings.txt C:\strings.txt
// note that only a leading ~ character is resolved to the executing directory...
stri~ngs.txt C:\App\stri~ngs.txt
This implementation does support relative resource retrieval, and
so will always return
Should only be used if no other
In contrast to other
A resource path may contain placeholder variables of the form
Currently only supports conversion from a
On Win9x boxes, this resource path,
// assuming a user called Rick, running on a plain vanilla Windows XP setup...
// this resource path...
${userprofile}\objects.xml
// will become (after expansion)...
C:\Documents and Settings\Rick\objects.xml
This implementation resolves environment variables only.
If the mapping already exists, the existing mapping will be silently overwritten with the new mapping.
If the mapping already exists, the existing mapping will be silently overwritten with the new mapping.
Obviously supports resolution as a
Some examples of the strings that can be used to initialize a new
instance of the
Some examples of the values that the
This implementation does support relative resource retrieval, and
so will always return
Find below some examples of the XML formatted strings that this converter will sucessfully convert.
Currently only supports conversion from a
Can use a given
This is not meant to be used as a system
Currently only supports conversion from a
Currently only supports conversion from a
Handles conversion from an XML formatted string to a
This converter must be registered before it will be available. Standard
converters in this namespace are automatically registered by the
Find below some examples of the XML formatted strings that this
converter will sucessfully convert. Note that the name of the top level
(document) element is quite arbitrary... it is only the content that
matters (and which must be in the format
The following example uses a different top level (document) element name, but is equivalent to the first example.
Currently only supports conversion from an
XML formatted
Currently only supports conversion from a
Currently only supports conversion from a
Currently only supports conversion from a
Please note that this class does not implement converting
to a comma separated list of RBG values from a
Currently only supports conversion from a
Currently only supports conversion to and from a
Currently only supports conversion from a
Currently only supports conversion from a
Defaults to using the
If you want to provide your own list separator, you can set the value of the
Please note that the individual elements of a string will be passed through as is (i.e. no conversion or trimming of surrounding whitespace will be performed).
This
public class StringArrayConverterExample
{
public static void Main()
{
StringArrayConverter converter = new StringArrayConverter();
string csvWords = "This,Is,It";
string[] frankBoothWords = converter.ConvertFrom(csvWords);
// the 'frankBoothWords' array will have 3 elements, namely
// "This", "Is", "It".
// please note that extraneous whitespace is NOT trimmed off
// in the current implementation...
string csv = " Cogito ,ergo ,sum ";
string[] descartesWords = converter.ConvertFrom(csv);
// the 'descartesWords' array will have 3 elements, namely
// " Cogito ", "ergo ", "sum ".
// notice how the whitespace has NOT been trimmed.
}
}
Currently only supports conversion from a
Currently only supports conversion from a
Currently only supports conversion from a
The rationale behind the creation of this interface is to centralise
the resolution of type names to
Type parameters can be applied to classes, interfaces, structures, methods, delegates, etc...
A empty string represents a type parameter that did not have been substituted by a specific type.
A generic argument can be a type parameter or a type argument.
Simplifies configuration by allowing aliases to be used instead of fully qualified type names.
Comes 'pre-loaded' with a number of convenience alias' for the more
common types; an example would be the '
This overload does eager resolution of the
Not intended to be used directly by applications.
This is a utility class, and as such exposes no public constructors.
If you require special
Useful in AOP (as an expression of the AspectJ
Matches the whole method name.
This leaves it up to the caller to decide what matches, but is obviously less of an abstraction because the caller must know the exact format of the underlying stack trace.
Strings in attribute name format (lowercase, hyphens separating words)
into property name format (camel-cased). For example, transaction-manager is
converted into transactionManager.
Useful when filtering
The error code is a
The GUI can render this anyway it pleases, allowing for I18n etc.
If no
If the supplied
This implementation respects the inheritance chain of any parameter
This class supports checking the generic arguments count of both generic methods and constructors.
This constructor sets the
This constructor sets the
null)null if none.null if noneThis class supports checking the parameter count of both methods and constructors.
Default parameters, etc need to taken into account.
This constructor sets the
If no
If the supplied
Typically thrown when attempting to read the value of a write-only property via reflection.
Non-
Uses direct evaluation instead of
Provides some additional properties over and above the name of the
property that has changed (which is inherited from the
This is a default implementation of
This was done in order to avoid redundant
Preparing this object once and reusing it many times for expression evaluation can result in significant performance improvements, as expression parsing and reflection lookups are only performed once.
Currently only supports conversion from a
This class allows users to get or set properties, execute methods, and evaluate logical and arithmetic expressions.
Methods in this class parse expression on every invocation.
If you plan to reuse the same expression many times, you should prepare
the expression once using the static
This can result in significant performance improvements as it avoids expression parsing and node resolution every time it is called.
This
All other resources will be ignored, but you can retrieve them by calling one of
This class contains the bulk of the localizer logic, including implementation
of the
All specific localizers need to do is inherit this class and implement
Custom implementations can use whatever type of resource storage they want, such as standard .NET resource sets, custom XML files, database, etc.
Localizers are used to automatically apply resources to object's members using reflection.
The 'context' is determined by the appropriate implementation class.
An example of such a context might be a thread local bound
This is an optional operation and does not need to be implemented such that it actually does anything useful (i.e. it can be a no-op).
It tries to get the
The 'context' in this implementation is the
Often used to wire subscribers to event publishers.
This is a utility class, and as such has no publicly visible constructors.
This interface only applies to objects that have been instantiated
within the context of an
This property will be set by the relevant
null.
Typical use cases might include being used to suppress the default
instantiation of specific target objects, perhaps in favour of creating
proxies with special
The returned object may be a proxy to use instead of the target object, effectively suppressing the default instantiation of the target object.
If the object is returned by this method is not
This callback will only be applied to object definitions with an object class. In particular, it will not be applied to objects with a "factory-method" (i.e. objects that are to be instantiated via a layer of indirection anyway).
null).
he relevant property infos for the target object (with ignored
dependency types - which the factory handles specifically - already filtered out)
The object instance created, but whose properties have not yet
been set.
Name of the object.
null if not predictable.null if none specifiednull if not predictable.null if none specifiedThe returned object may be a proxy to use instead of the target object, effectively suppressing the default instantiation of the target object.
If the object is returned by this method is not
This callback will only be applied to object definitions with an object class. In particular, it will not be applied to objects with a "factory-method" (i.e. objects that are to be instantiated via a layer of indirection anyway).
null).
he relevant property infos for the target object (with ignored
dependency types - which the factory handles specifically - already filtered out)
The object instance created, but whose properties have not yet
been set.
Name of the object.
The object will already be populated with property values. The returned object instance may be a wrapper around the original.
The object will already be populated with property values. The returned object instance may be a wrapper around the original.
null).
The relevant property infos for the target object (with ignored
dependency types - which the factory handles specifically - already filtered out)
The object instance created, but whose properties have not yet
been set.
Name of the object.
Application contexts can auto-detect
Useful for custom config files targeted at system administrators that override object properties configured in the application context.
See PropertyResourceConfigurer and its concrete implementations for out-of-the-box solutions that address such configuration needs.
All object definitions will have been loaded, but no objects will have been instantiated yet. This allows for overriding or adding properties even to eager-initializing objects.
All object definitions will have been loaded, but no objects will have been instantiated yet. This allows for overriding or adding properties even to eager-initializing objects.
This (default) implementation supports resolving
If an object implements this interface, it is used as a factory,
not directly as an object.
Only makes sense in the context of a singleton object.
Please note that changing the value of this property after
this factory object instance has been created by an enclosing
Spring.NET IoC container really is a programming error. This
property should really only be set once, prior to the invocation
of the
The "variable sources" are objects containing name-value pairs that allow a variable value to be retrieved for the given name.
Out of the box, Spring.NET supports a number of variable sources, that allow users to obtain variable values from .NET config files, Java-style property files, environment, registry, etc.
Users can always write their own variable sources implementations, that will allow them to load variable values from the database or other proprietary data source.
Currently supports reading custom configuration sections and returning them as
This is a utility class, and as such has no publicly visible constructors.
When the <connectionStrings> configuration section is processed by this class, two variables are defined for each connection string: one for connection string and the second one for the provider name.
Variable names are generated by appending '.connectionString' and '.providerName'
literals to the value of the
will result in two variables being created: myConn.connectionString and myConn.providerName. You can reference these variables within your object definitions, just like any other variable.
Supports values for a specific index or parameter name (case
insensitive) in the constructor argument list, and generic matches by
Only necessary for manipulating a registered value, for example in
Because the
The following examples all assume XML based configuration, and use
inner object definitions to define the custom
The following example illustrates a complete (albeit naieve) use case
for this class, including a custom
The domain class is a simple data-only object that contains the data
required to send an email message (such as the host and user account
name). A developer would prefer to use a string of the form
namespace ExampleNamespace
{
public sealed class MailSettings
{
private string _userName;
private string _password;
private string _host;
public string Host
{
get { return _host; }
set { _host = value; }
}
public string UserName
{
get { return _userName; }
set { _userName = value; }
}
public string Password
{
get { return _password; }
set { _password = value; }
}
}
public sealed class MailSettingsConverter : TypeConverter
{
public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
if (typeof (string) == sourceType)
{
return true;
}
return base.CanConvertFrom(context, sourceType);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
string text = value as string;
if(text != null)
{
MailSettings mailSettings = new MailSettings();
string[] tokens = text.Split(',');
for (int i = 0; i < tokens.Length; ++i)
{
string token = tokens[i];
string[] settings = token.Split('=');
typeof(MailSettings).GetProperty(settings[0])
.SetValue(mailSettings, settings[1], null);
}
return mailSettings;
}
return base.ConvertFrom(context, culture, value);
}
}
// a very naieve class that uses the MailSettings class...
public sealed class ExceptionLogger
{
private MailSettings _mailSettings;
public MailSettings MailSettings {
{
set { _mailSettings = value; }
}
public void Log(object value)
{
Exception ex = value as Exception;
if(ex != null)
{
// use _mailSettings instance...
}
}
}
}
The attendant XML configuration for the above classes would be...
The
IDictionary converters = new Hashtable();
converters.Add( "System.Date", new MyCustomDateConverter() );
// a System.Type instance can also be used as the key...
converters.Add( typeof(Color), new MyCustomRBGColorConverter() );
Supports the creation of
Returns the
null
This value will be used to populate the
The default is the
Typically used for retrieving public constants.
The following example retrieves the
The previous example could also have been written using the convenience
This class also implements the
The usage for retrieving instance fields is similar. No example is shown
because public instance fields are generally bad practice; but if
you have some legacy code that exposes public instance fields, or if you
just really like coding public instance fields, then you can use this
Note that most objects will choose to receive references to collaborating objects via respective properties.
For a list of all object lifecycle methods, see the
Invoked after population of normal object properties but before an init
callback like
This method allows the object instance to perform initialization only possible when all object properties have been set and to throw an exception in the event of misconfiguration.
In the context of the
If the
The returned object instance may be a wrapper around the original.
The returned object instance may be a wrapper around the original.
null if none found
Allows for framework-internal plug'n'play, e.g. in
Provides the means to configure an object factory in addition to the
object factory client methods in the
Allows for framework-internal plug'n'play even when needing access to object factory configuration methods.
When disposed, it will destroy all cached singletons in this factory. Call
AfterPropertiesSet method).
The given instance will not receive any destruction callbacks
(like IDisposable's Dispose method) either.
null if none foundtrue
for singleton bean definitions which have not been instantiated yet.
ContainsObjectDefinition. Calling both
ContainsObjectDefinition and ContainsSingleton answers
whether a specific object factory contains an own object with the given name.
ContainsObject for general checks whether the
factory knows about an object with a given name (whether manually registered singleton
instance or created by bean definition), also checking ancestor factories.
null).To be invoked during factory configuration.
This will typically be used for dependencies that are resolved
in other ways, like
To be invoked during factory configuration.
This is typically used to support names that are illegal within XML ids (which are used for object names).
Typically invoked during factory configuration, but can also be used for runtime registration of aliases. Therefore, a factory implementation should synchronize alias access.
To be invoked during factory configuration.
Note that the parent shouldn't be changed: it should only be set outside a constructor if it isn't available when an object of this class is created.
Must support
Typically invoked at the end of factory setup, if desired.
As this is a startup method, it should destroy already created singletons if it fails, to avoid dangling resources. In other words, after invocation of that method, either all or no singletons at all should be instantiated.
This is just a minimal interface: the main intention is to allow
If
Only applicable to a singleton object.
If
This determines whether any automagical detection and setting of
object references will happen. Default is
The object factory will guarantee that these objects get initialized before.
Note that dependencies are normally expressed through object properties or constructor arguments. This property should just be necessary for other kinds of dependencies like statics (*ugh*) or database preparation on startup.
The default is
The default is
This method will be invoked with constructor arguments, or with no
arguments if none are specified. The static method will be invoked on
the specified
This value will be used to populate the
The default is the
Typically used for retrieving shared
Note that this class generally is expected to be used for accessing factory methods,
and as such defaults to operating in singleton mode. The first request to
A
Another (esoteric) use case for this factory object is when one needs to call a method
that doesn't return any value (for example, a
The following example uses an instance of this class to call a
The following example is similar to the preceding example; the only pertinent difference is the fact that a number of different objects are passed as arguments, demonstrating that not only simple value types are valid as elements of the argument list...
Named parameters are also supported... this next example yields the same results as the preceding example (that did not use named arguments).
Similarly, the following example uses an instance of this class to call an instance method...
The above example could also have been written using an anonymous inner object definition... if the object on which the method is to be invoked is not going to be used outside of the factory object definition, then this is the preferred idiom because it limits the scope of the object on which the method is to be invoked to the surrounding factory object.
Typically not used directly but via its subclasses such as
Usage: specify either the
The following example uses the
public class Foo
{
public string ToString(string name, int age, string address)
{
return string.Format("{0}, {1} years old, {2}", name, age, address);
}
public static void Main()
{
Foo foo = new Foo();
MethodInvoker invoker = new MethodInvoker();
invoker.Arguments = new object [] {"Kaneda", "18 Kaosu Gardens, Nakatani Drive, Okinanawa"};
invoker.AddNamedArgument("age", 29);
invoker.Prepare();
// at this point, the arguments that will be passed to the method invocation
// will have been resolved into the following ordered array : {"Kaneda", 29, "18 Kaosu Gardens, Nakatani Drive, Okinanawa"}
string details = (string) invoker.Invoke();
Console.WriteLine (details);
// will print out 'Kaneda, 29 years old, 18 Kaosu Gardens, Nakatani Drive, Okinanawa'
}
}
The method can be invoked any number of times afterwards.
A possible use case is to determine the return
The invoker needs to have been prepared beforehand (via a call to the
Only necessary when the target method is
Only necessary when the target method is not
Refers to either a
Ordering is significant... the order of the arguments in this
property must match the ordering of the various parameters on the target
method. There does however exist a small possibility for confusion when
the arguments in this property are supplied in addition to one or more named
arguments. In this case, each named argument is slotted into the index position
corresponding to the named argument... once once all named arguments have been
resolved, the arguments in this property are slotted into any remaining (empty)
slots in the method parameter list (see the example in the overview of the
If this property is not set, or the value passed to the setter invocation
is
Setting the value of this property to
The keys of this dictionary are the (
If this property is not set, or the value passed to the setter invocation
is a
The method can be invoked any number of times afterwards.
Returns the return value of the method that is to be invoked.
Will return the same value each time if the
If the return value of the method that this factory is to invoke is
Recognized by
Can also be used for programmatic registration of inner object
definitions. If you don't care about the functionality offered by the
Guaranteed to never return
ResolveStringValue method
The primary motivation of this class is to avoid having a client object
directly calling the
The object referred to by the value of the
The following XML configuration snippet illustrates the use of this class...
For example, objects can look up collaborating objects via the factory.
Note that most objects will choose to receive references to collaborating objects via respective properties and / or an appropriate constructor.
For a list of all object lifecycle methods, see the
Invoked after population of normal object properties but before an init
callback like
Usually, the target object will reside in a different object
definition file, using this
<alias>
tag is available that effectively achieves the same.
The target object may potentially be defined in a different object definition file.
Instances of this class override already existing values, and is
thus best suited to replacing defaults. If you need to replace
placeholder values, consider using the
In contrast to the
Each line in a referenced configuration file is expected to take the following form...
The
Please note that in the case of multiple
The following XML context definition defines an object that has a number of properties, all of which have default values...
What follows is a .NET config file snippet for the above example (assuming the need to override one of the default values)...
Useful for custom .NET .config files targetted at system administrators that override object properties configured in the application context.
Two concrete implementations are provided in the Spring.NET core library:
Please refer to the API documentation for the concrete implementations listed above for example usage.
This is an
Basically, if external locations are specified, ensure that either one or a like number of config sections are also specified.
When merging conflicting property overrides from several resources, should append an override with the same key be appended to the current value, or should the property override from the last resource processed override previous values?
The default value is
These are to be considered defaults, to be overridden by values loaded from other resources.
The target object can be specified directly or via an object name (see example below).
Please note that the
This would most likely be an inner object, but can of course be any object reference.
Please note that any leading or trailing whitespace will be
trimmed from this name prior to resolution. The implication of this is that
one cannot use the
Please note that any leading or trailing whitespace will be trimmed from this path prior to resolution. Whitespace is not a valid identifier for property names (in part or whole) in CLS-based languages, so this is a not unreasonable action. Please also note that whitespace that is embedded within the property path will be left as-is (which may or may not result in an error being thrown, depending on the context of the whitespace).
Examples of such property lookup paths can be seen below; note that property lookup paths can be nested to an arbitrary level.
name.length
accountManager.account['the key'].name
accounts[0].name
This is not necessary for directly specified target objects, or
singleton target objects, where the
It is permissable to set the value of this property to
The object name of this
This allows for concise object definitions with just an id or name.
The default placeholder syntax follows the NAnt style:
The following example XML context definition defines an object that has
a number of placeholders. The placeholders can easily be distinguished
by the presence of the
The associated XML configuration file for the above example containing the values for the placeholders would contain a snippet such as ..
The preceding XML snippet listing the various property keys and their associated values needs to be inserted into the .NET config file of your application (or Web.config file for your ASP.NET web application, as the case may be), like so...
In contrast to the
If a configurer cannot resolve a placeholder, and the value of the
The default implementation delegates to
This (the default) implementation simply looks up the value of the
supplied
Subclasses can override this for customized placeholder-to-key mappings or custom resolution strategies, possibly just using the given name value collection as fallback.
See the overview of the
Typically used for retrieving public property values.
If this property is not set, or the value passed to the setter invocation is a null or zero-length array, a property with no arguments is assumed.
Refers to either a
Because the
The
This is currently the preferred way of injecting resources into view
tier components (such as Windows Forms GUIs and ASP.NET ASPX pages).
A GUI component (typically a Windows Form) is injected with
an
For example, the root name for the resource file named "MyResource.en-US.resources" is "MyResource".
This does not mark this object as being a reference to another object in any parent factory.
This variant constructor allows a client to specifiy whether or not this object is a reference to another object in a parent factory.
This value will be used to populate the
The default is the
Normally starting with 0 or 1, with
Higher value can be interpreted as lower priority, consequently the first object has highest priority.
Because the
The
Can be added to object definitions to explicitly specify
a target type for a
This holder just stores the
Obviously if the
All object definitions will have been loaded, but no objects will have been instantiated yet. This allows for overriding or adding properties even to eager-initializing objects.
Provides object creation, initialization and wiring, supporting autowiring and constructor resolution. Handles runtime object references, managed collections, and object destruction.
The main template method to be implemented by subclasses is
This class provides singleton / prototype determination, singleton caching,
object definition aliasing,
This constructor implicitly creates an
This is an
This is an
This is an
The object definition can either define a fully self-contained object, reusing it's property values, or just property values meant to be used for existing object instances.
The object definition will already have been merged with the parent definition in case of a child definition.
All the other methods in this class invoke this method, although objects may be cached after being instantiated by this method. All object instantiation within this class is performed by this method.
Must destroy objects that depend on the given object before the object itself, nor throw an exception.
Does not consider any hierarchy this factory may participate in.
Invoked by
To be called for eager registration of singletons, e.g. to be able to resolve circular references.
Will ask the parent object factory if not found in this instance.
GetObject
to call its ObjectType property. Subclasses are encouraged to optimize
this, typically by just instantiating the FactoryObject but not populating it yet,
trying whether its ObjectType property already returns a type.
If no type found, a full FactoryObject creation as performed by this implementation
should be used as fallback.
null otherwisenull if not predictableResolveObjectType method. Subclasses may override this to use
a differnt strategy.
Will not consider
Does not consider any hierarchy this factory may participate in.
More specifically, checks the
Please note that (prototype) objects created via a factory method or
This, the default, implementation returns Spring.Objects.Factory.Support.AbstractObjectFactory.CreateObject
implementation.
Does not consider any hierarchy this factory may participate in.
Does not consider any hierarchy this factory may participate in.
Delegates to
ContainsObject, ignoring an object
of the given name from an ancestor object factory.
This method allows an object factory to be used as a replacement for the Singleton or Prototype design pattern.
Note that callers should retain references to returned objects. There is no guarantee that this method will be implemented to be efficient. For example, it may be synchronized, or may need to run an RDBMS query.
Will ask the parent factory if the object cannot be found in this factory instance.
The elements of this
null).
This is an
This is an
null if not predictable
The returned instance may be a wrapper around the original.
Must use deep copy, so that we don't permanently modify this property.
These are probably unsatisfied references to other objects in the
factory. Does not include simple properties like primitives or
To be called on shutdown of a factory.
This is like PicoContainer default, in which there must be exactly one object of the property type in the object factory. This makes object factories simple to configure for small namespaces, but doesn't work as well as standard Spring behavior for bigger applications.
The object definition will already have been merged with the parent definition in case of a child definition.
All the other methods in this class invoke this method, although objects may be cached after being instantiated by this method. All object instantiation within this class is performed by this method.
null if none specified
The method may be static, if the
Implementation requires iterating over the static or instance methods
with the name specified in the supplied
null if none (-> use constructor argument values from object definition)
Dependency checks can be objects (collaborating objects), simple (primitives
and
This means checking whether the object implements
Custom init methods are resolved in a case-insensitive manner.
This implementation invokes a no-arg method if found, else checking for a method with a single boolean argument (passing in "true", assuming a "force" parameter), else logging an error.
Can be overridden in subclasses for custom resolution of destroy methods with arguments.
Custom destroy methods are resolved in a case-insensitive manner.
Must destroy objects that depend on the given object before the object itself. Should not throw any exceptions.
Called by autowiring. If a subclass cannot obtain information about object
names by
PostProcessAfterInitialization callback of all
registered IObjectPostProcessors, giving them a chance to post-process
the object obtained from IFactoryObjects (for example, to auto-proxy them)
null if none found
This class is reserved for internal use within the framework; it is not intended to be used by application developers using Spring.NET.
Encapsulates the notion of the Method-Injection form of Dependency Injection.
Methods that are dependency injected with implementations of this
interface may be (but need not be)
Do not use this mechanism as a means of AOP. See the reference manual for examples of appropriate usages of this interface.
This is an
If
Only applicable to a singleton object.
If
This determines whether any automagical detection and setting of
object references will happen. Default is
The object factory will guarantee that these objects get initialized before.
Note that dependencies are normally expressed through object properties or constructor arguments. This property should just be necessary for other kinds of dependencies like statics (*ugh*) or database preparation on startup.
The default is
The default is
This method will be invoked with constructor arguments, or with no
arguments if none are specified. The static method will be invoked on
the specified
This is an
This is an
This is an
Setting the value of this property to
Setting the value of this property to
Setting the value of this property to
Setting the value of this property to
If
Only applicable to a singleton object.
If
This determines whether any automagical detection and setting of
object references will happen. The default is
This resolves
The default is
The object factory will guarantee that these objects get initialized before this object definition.
The default value is the
The default value is the
This method will be invoked with constructor arguments, or with no
arguments if none are specified. The
Provides common properties like the object registry to work on.
This is an
This is an
This is a utility class, and as such has no publicly visible constructors.
A direct match, i.e. type MyInteger -> arg of class MyInteger, does not increase
the result - all direct matches means weight zero (0). A match between the argument type
Therefore, with an argument of type
All argument weights get accumulated.
The result will contain public constructors first, with a decreasing number of arguments, then non-public constructors, again with a decreasing number of arguments.
Will use the
A
The remaining settings will always be taken from the child definition:
A common cause of validation failures is a missing value for the
null if none).
The explicit argument values passed in programmatically via the getBean method,
or null if none (-> use constructor argument values from object definition)
The method may be static, if the
Implementation requires iterating over the static or instance methods
with the name specified in the supplied
'Resolve' can be taken to mean that all of the
These resolved values are plugged into the supplied
This method is also used for handling invocations of static factory methods.
This class is a full-fledged object factory based on object definitions that is usable straight out of the box.
Can be used as an object factory in and of itself, or as a superclass for custom object factory implementations. Note that readers for specific object definition formats are typically implemented separately rather than as object factory subclasses.
For an alternative implementation of the
Called by autowiring. If a subclass cannot obtain information about object
names by
Called by the
null if none found
If
The default is
null
Does not support per
Allows for replaceable object definition factories using the Strategy pattern.
This class is reserved for internal use within the framework; it is not intended to be used by application developers using Spring.NET.
The core Spring.NET library already provides three implementations of this interface straight out of the box; they are...
If you have a custom collection class (i.e. a class that either implements the
Lets say one has a
using System;
using Spring.Objects.Factory.Support;
namespace MyNamespace
{
public sealed class Bag : ICollection
{
// ICollection implementation elided for clarity...
public void Add(object o)
{
// implementation elided for clarity...
}
}
public class ManagedBag : Bag, IManagedCollection
{
public ICollection Resolve(
string objectName, RootObjectDefinition definition,
string propertyName, ManagedCollectionElementResolver resolver)
{
Bag newBag = new Bag();
string elementName = propertyName + "[bag-element]";
foreach(object element in this)
{
object resolvedElement = resolver(objectName, definition, elementName, element);
newBag.Add(resolvedElement);
}
return newBag;
}
}
}
If the
Methods eligible for lookup override must not have arguments.
Note that the override mechanism is not intended as a generic means of inserting crosscutting code: use AOP for that.
This is an
By 'match' one means does this particular
This allows for argument list checking as well as method name checking.
If
Setting the value of this property to
Methods eligible for lookup override must not have arguments.
This class is Spring.NET's implementation of Dependency Lookup via Method Injection.
This class is reserved for internal use within the framework; it is not intended to be used by application developers using Spring.NET.
Classes that want to take advantage of method injection must meet some
stringent criteria. Every method that is to be method injected
must be defined as either
Does not support method injection, although it provides hooks for subclasses to override to add method injection support, for example by overriding methods.
The default implementation of this method is to throw a
Derived classes can override this method if they can instantiate an object
with the Method Injection specified in the supplied
The default implementation of this method is to throw a
Derived classes can override this method if they can instantiate an object
with the Method Injection specified in the supplied
This method dynamically generates a subclass that supports method
injection for the supplied
This class is designed as for
Exists so that clients of this class can use this name to set properties reflectively on the dynamically generated subclass.
Exists so that clients of this class can use this name to set properties reflectively on the dynamically generated subclass.
Since we are simply overridding a method (in this method injection context), all we do here is simply copy the parameters (since we want a method with the exact same parameters).
Deep copy constructoe.
The returned
ObjectDefinitionBuilder used to construct a root object definition.
ObjectDefinitionBuilder instance.ObjectDefinitionBuilder used to construct a root object definition.
ObjectDefinitionBuilder instance.ObjectDefinitionBuilder used to construct a root object definition.
ObjectDefinitionBuilder instance.ObjectDefinitionBuilder used to construct a root object definition.
ObjectDefinitionBuilder instance.ObjectDefinitionBuilder used to construct a child object definition..
ObjectDefinitionBuilder.ObjectDefinitionBuilder.ObjectDefinitionBuilder.ObjectDefinitionBuilder.ObjectDefinitionBuilder.ObjectDefinitionBuilder.ObjectDefinitionBuilder.ObjectDefinitionBuilder.ObjectDefinitionBuilder.ObjectDefinitionBuilder.ObjectDefinitionBuilder.ObjectDefinitionBuilder.ObjectDefinitionBuilder.ObjectDefinitionBuilder.
If a
This is a convenience method that registers the
This is a utility class, and as such exposes no public constructors.
The value could be :
An
A
An
An ordinary object or
Default is true.
owner.(singleton)=true
Default is false.
owner.(lazy-init)=true
Whether this is a reference to a singleton or a prototype will depend on the definition of the target object.
Similar syntax as for an
Ignores ineligible properties.
Ignores ineligible properties.
Note that this mechanism is not intended as a generic means of inserting crosscutting code: use AOP for that.
This is the most common type of object definition;
Note that
Takes an object class name to avoid eager loading of the object class.
Deep copy constructor.
Does not have support for prototype objects, aliases, and post startup object configuration.
Serves as a simple example implementation of the
The
This method allows an object factory to be used as a replacement for the Singleton or Prototype design pattern.
Note that callers should retain references to returned objects. There is no guarantee that this method will be implemented to be efficient. For example, it may be synchronized, or may need to run an RDBMS query.
Will ask the parent factory if the object cannot be found in this factory instance.
That is, will
More specifically, checks the type of object that
Will not consider
Does consider objects created by
Does not consider any hierarchy this factory may participate in.
Since this implementation of the
This version of the IListableObjectFactory.GetObjectsOfType(type,true,true) .
IObjectDefinition, you may wish to consider
the simpler convenience extensions of this class, namely
This method is never invoked if the parser is namespace aware and was called to process the root node.
This method is never invoked if the parser is namespace aware and was called to process the root node.
IsNested
parameter is false, because one typically does not want inner objects
to be registered as top level objects.
GetObjectTypeName instad, in order to avoid a direct
dependence on the object implementation class. The ObjectDefinitionParser
and its IXmlObjectDefinitionParser (namespace parser) can be used within an
IDE add-in then, even if the application classses are not available in the add-ins
AppDomain.
DoParse version without
ParameterContext argument.IObjectDefinition.
IObjectDefinition.
Navigates through an XML resource and invokes parsers registered
with the
RegisterObjectDefinitions
method, for example global settings that are defined for all object definitions
in the document.
The default implementation is empty. Subclasses can override this method to convert custom elements into standard Spring object definitions, for example. Implementors have access to the parser's object definition reader and the underlying XML resource, through the corresponding properties.
<objects>
level in a standard Spring XML object definition document:
default-lazy-init, default-autowire, etc.
Used by
<property> tag.
The
Anything else represents
Always optional.
Used primarily for user documentation of XML object definition documents.
Does not have to be fully assembly qualified, but it is recommended
that the
There are constraints on a valid XML id: if you want to reference
your object in .NET code using a name that's illegal as an XML id,
use the optional
Multiple aliases can be separated by any number of spaces,
semicolons, or commas
(
Always optional.
Singletons are most commonly used, and are ideal for multi-threaded service objects.
Scope can be defined as either application, session or request. It defines when "singleton" instances are initialized, but has no effect on prototype definitions.
The object factory will guarantee that these objects get initialized before this object definition.
The method must have no arguments.
Valid destroy methods have either of the following signatures...
Only needed to avoid ambiguities, e.g. in case of 2 single
argument constructors that can both be converted from a
Only needed to avoid ambiguities, e.g. in case of 2 arguments of the same type.
Default is
Spring.NET supports primitives, references to other objects in the same or related factories, lists, dictionaries, and name value collections.
Local references, using the "local" attribute, have to use object ids; they can be checked by a parser, thus should be preferred for references within the same object factory XML file.
If this is specified, no type attribute should be used. This should be set to the name of an object in the current or ancestor factories that contains the relevant factory method. This allows the factory itself to be configured using Dependency Injection, and an instance (rather than static) method to be used.
Use constructor-arg elements to specify arguments to the factory method, if it takes arguments. Autowiring does not apply to factory methods.
If the "type" attribute is present, the factory method will be a
static method on the type specified by the "type" attribute on
this object definition. Often this will be the same type as that
of the constructed object - for example, when the factory method
is used as an alternative to a constructor. However, it may be on
a different type. In that case, the created object will *not* be
of the type specified in the "type" attribute. This is analogous
to
If the "factory-object" attribute is present, the "type" attribute
is not used, and the factory method will be an instance method on
the object returned from a
The factory method can have any number of arguments. Use indexed constructor-arg elements in conjunction with the factory-method attribute.
Setter Injection can be used in conjunction with a factory method. Method Injection cannot, as the factory method returns an instance, which will be used when the container creates the object.
Lists are untyped, pending generics support, although references will be strongly typed.
A list can also map to an array type. The necessary conversion is
automatically performed by the
Sets are untyped, pending generics support, although references will be strongly typed.
Dictionaries may be empty.
This is used by name-value, ctor argument, and property elements.
This is used by name-value element.
Used as a convenience shortcut on property and constructor-arg elements to refer to other objects.
This is used by ctor argument and property elements.
The name of the property is given by the "key" attribute.
The property may be a string, or may be converted to the
required
Necessary because an empty "value" tag will resolve to an empty
May be empty.
The "key" attribute is the name of the property.
Defaults to
This is a form of Method Injection.
It's particularly useful as an alternative to implementing the
Often this object will be a prototype, in which case the lookup method will return a distinct instance on every invocation. This is useful for single-threaded objects.
This (again) is a form of Method Injection.
If this method is not overloaded, there's no need to use arg-type subelements.
If this method is overloaded,
This may be a singleton or prototype. If it's a prototype, a new instance will be used for each method replacement. Singleton usage is the norm.
For convenience, this may be a substring of the FQN. E.g. all the following would match
This is a utility class, and as such has no publicly visible constructors.
null if the
default have not yet been initialized.
Applications will typically want to use an
Parses object definitions according to the standard Spring.NET schema.
This schema is typically located at http://www.springframework.net/xsd/spring-objects.xsd.
This method is never invoked if the parser is namespace aware and was called to process the root node.
<property> tag.
Object elements specify their canonical name via the "id" attribute and their aliases as a delimited "name" attribute.
If no "id" is specified, uses the first name in the "name" attribute as the canonical name, registering all others as aliases.
Called when an object definition has not been explicitly defined with an id.
Please note that even though this method is named GetPropertyValue, it is called by both the property and constructor argument element handlers.
Uses a namespace manager if necessary.
Uses a namespace manager if necessary.
If the supplied
If the supplied
If the supplied
Typically applied to a
This class registers each object definition with the given object factory superclass,
and relies on the latter's implementation of the
It supports singletons, prototypes, and references to either of these kinds of object.
Delegates to
This class registers each object definition with the
Hopefully this will display enough context so that a user can pinpoint the cause of the error.
Derived classes can of course override this method in order to implement validators capable of displaying a full list of errors found in the definition.
Derived classes can of course override this method in order to implement validators capable of displaying a full list of errors found in the definition.
This is usually indicated by any of the variants of the
A circular reference with an
Typically happens when constructor autowiring matches the currently constructed object.
class attribute thet can be resolved
as a type
An example of a situation when this exception would be thrown is in the case of an XML document containing object definitions being malformed.
null
The nesting hierarchy of an object factory is taken into account by the various methods exposed by this class.
For example, if the managed object identified as foo is a
factory, getting &foo will return the factory, not the
instance returned by the factory.
If a
This is a utility class, and as such has no publicly visible constructors.
Includes counts of ancestor object factories.
Objects that are "overridden" (specified in a descendant factory with the same name) are counted only once.
Will return unique names in case of overridden object definitions.
Does consider objects created by
Will return unique names in case of overridden object definitions.
Does consider objects created by
The return list will only contain objects of this type. Useful convenience method when we don't care about object names.
Useful convenience method when we expect a single object and don't care about the object name.
Useful convenience method when we expect a single object and don't care about the object name.
Useful convenience method when we expect a single object and don't care
about the object name.
This version of
That is, does the supplied
Note that non-factory-aware initialization methods like AfterPropertiesSet () or a custom "init-method" can throw any exception.
An object is a factory if it implements (either directly or indirectly
via inheritance) the
This is an
This is an
This is an
This is an
This class merely marshals the matching of handler methods to the events exposed
by an event source, and then delegates to a concrete
Note : the order in which handler's are wired up to events is non-deterministic.
Typically not directly used by application code but rather implicitly
via an
Implementing classes have the ability to get and set property values (individually or in bulk), get property descriptors and query the readability and writability of properties.
This interface supports nested properties enabling the setting of properties on subproperties to an unlimited depth.
If a property update causes an exception, a
This is the preferred way to update an individual property.
This method is provided for convenience only. The
This is the preferred way to perform a bulk update.
Note that performing a bulk update differs from performing a single update,
in that an implementation of this class will continue to update properties
if a recoverable error (such as a vetoed property change or a type
mismatch, but not an invalid property name or the like) is
encountered, throwing a
Does not allow the setting of unknown fields. Equivalent to
Note that performing a bulk update differs from performing a single update,
in that an implementation of this class will continue to update properties
if a recoverable error (such as a vetoed property change or a type
mismatch, but not an invalid property name or the like) is
encountered, throwing a
Does not allow the setting of unknown fields.
Implementations are required to allow the type of the wrapped object to change.
Subclasses should also override
Shared state is very useful if you have data that needs to be shared by all instances
of e.g. the same webform (or other
For example,
Allows simple manipulation of properties, and provides constructors to
support deep copy and construction from a number of collection types such as
The returned instance is initially empty...
Deep copy constructor. Guarantees
The returned
The wrapped target instance will need to be set afterwards.
Please note that the
This method is provided for convenience only. The
This is the preferred way to update an individual property.
Does not allow unknown fields. Equivalent to
This method may throw a reflection-based exception, if there is a critical
failure such as no matching field... less serious exceptions will be accumulated
and thrown as a single
Do not use this (convenience) method prior to setting the
An object of this class is created at the beginning of the binding process, and errors added to it as necessary.
The binding process continues when it encounters application-level
Will return the empty array (not
Using an object here, rather than just storing all properties in a map keyed by property name, allows for more flexibility, and the ability to handle indexed properties in a special way if necessary.
Note that the value doesn't need to be the final required
Note that type conversion will not have occurred here.
It is the responsibility of the
Based on the implementation found in Concurrent Programming in Java, 2nd ed., by Doug Lea.
Based on the Jakarta Commons Pool API.
By contract, clients must return the borrowed
instance using
By contract, the object must have been obtained using
This is an optional operation. AddObject is useful for "pre-loading" a pool with idle objects.
This is an optional operation.
This is an optional operation.
This is an optional operation.
This may be considered an approximation of the number of objects that can be borrowed without creating any new instances.
This is an optional operation.
This implementation always throws a
This implementation always throws a
This implementation always throws a
The following methods summarize the contract between an
Based on the Jakarta Commons Pool API.
Invoked on every instance when it is being "dropped"
from the pool (whether due to the return value from a call to the
Invoked in an implementation-specific fashion to determine if an instance is still valid to be returned by the pool. It will only be invoked on an "activated" instance.
Invoked on every instance before it is returned from the pool.
Invoked on every instance when it is returned to the pool.
If the target object returns reference to itself -- 'this' -- we need to treat it as a special case and return a reference to a proxy object instead.
This
Note that the list is composed of instances of the actual
The following code snippets show examples of how to decorate the
the proxied class with one or more
// get a concrete implementation of an IProxyTypeBuilder...
IProxyTypeBuilder builder = ... ;
builder.TargetType = typeof( ... );
IDictionary typeAtts = new Hashtable();
builder.TypeAttributes = typeAtts;
// applies a single Attribute to the proxied class...
typeAtts = new Attribute[] { new MyCustomAttribute() });
// applies a number of Attributes to the proxied class...
typeAtts = new Attribute[]
{
new MyCustomAttribute(),
new AnotherAttribute(),
});
This dictionary must use simple
The key may be wildcarded using the
The following code snippets show examples of how to decorate the
members of a proxied class with one or more
// get a concrete implementation of an IProxyTypeBuilder...
IProxyTypeBuilder builder = ... ;
builder.TargetType = typeof( ... );
IDictionary memAtts = new Hashtable();
builder.MemberAttributes = memAtts;
// applies a single Attribute to all members of the proxied class...
memAtts ["*"] = new Attribute[] { new MyCustomAttribute() });
// applies a number of Attributes to all members of the proxied class...
memAtts ["*"] = new Attribute[]
{
new MyCustomAttribute(),
new AnotherAttribute(),
});
// applies a single Attribute to those members of the proxied class
// that have identifiers starting with 'Do' ...
memAtts ["Do*"] = new Attribute[] { new MyCustomAttribute() });
// applies a number of Attributes to those members of the proxied class
// that have identifiers starting with 'Do' ...
memAtts ["Do*"] = new Attribute[]
{
new MyCustomAttribute(),
new AnotherAttribute(),
});
The specified object can be of different type :
If the target type does not implement the interface, we return the interfaces methods as the target methods for many reasons :
The default value of this property is the
Only interfaces can be proxied using composition, so the target must implement one or more interfaces.
This implementation creates instance of the target object for delegation using constructor arguments.
Only
This implementation delegates the call to a base class constructor.
This factory method will create a dynamic property with a "safe" wrapper.
Safe wrapper will attempt to use generated dynamic property if possible, but it will fall back to standard reflection if necessary.
Use of
Used for implementation of a
Because release does not raise exceptions, it can be used in `finally' clauses without requiring extra embedded try/catch blocks. But keep in mind that as with any java method, implementations may still throw unchecked exceptions such as Error or NullPointerException when faced with uncontinuable errors. However, these should normally only be caught by higher-level error handlers.
The method has best-effort semantics: The msecs bound cannot be guaranteed to be a precise upper bound on wait time in Java. Implementations generally can only attempt to return as soon as possible after the specified bound. Also, timers in Java do not stop during garbage collection, so timeouts can occur just because a GC intervened. So, msecs arguments should be used in a coarse-grained manner. Further, implementations cannot always guarantee that this method will return at all without blocking indefinitely when used in unintended ways. For example, deadlocks may be encountered when called in an unintended context.
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.
Base class for counting semaphores based on Semaphore implementation from Doug Lea.
Conceptually, a semaphore maintains a set of permits. Each acquire() blocks if necessary until a permit is available, and then takes it.
Each release adds a permit. However, no actual permit objects are used; the Semaphore just keeps a count of the number available and acts accordingly.
A semaphore initialized to 1 can serve as a mutual exclusion lock.
Used for implementation of aCreate a Semaphore with the given initial number of permits.
Using a seed of 1 makes the semaphore act as a mutual exclusion lock.
Negative seeds are also allowed, in which case no acquires will proceed until the number of releases has pushed the number of permits past 0.
release(n) is
equivalent in effect to:
for (int i = 0; i < n; ++i) release();
But may be more efficient in some semaphore implementations.
Usually this is non issue because the same exception will be raised entering the monitor
associated with the lock (
Not intended to be used directly by applications.
ArgumentException
if the test result is false.
false
ArgumentException
if the test result is false.
false
InvalidOperationException
if the expression is false.
falseThis is a utility class, and as such exposes no public constructors.
nullnull if nonePrimary purpose of this method is to allow us to parse and load configuration sections using the same API regardless of the .NET framework version.
If Microsoft paid a bit more attention to preserving backwards compatibility we would not even need it, but... :(
Primary purpose of this method is to allow us to parse and load configuration sections using the same API regardless of the .NET framework version.
If Microsoft paid a bit more attention to preserving backwards compatibility we would not even need it, but... :(
This method will never return
The purpose of this class is to provide a simple abstraction for creating and managing dynamic assemblies.
The following excerpt from
public class DynamicProxyManager
{
public const string PROXY_ASSEMBLY_NAME = "Spring.Proxy";
public static TypeBuilder CreateTypeBuilder(string name, Type baseType)
{
// Generates type name
string typeName = String.Format("{0}.{1}_{2}", PROXY_ASSEMBLY_NAME, name, Guid.NewGuid().ToString("N"));
ModuleBuilder module = DynamicCodeManager.GetModuleBuilder(PROXY_ASSEMBLY_NAME);
return module.DefineType(typeName, PROXY_TYPE_ATTRIBUTES);
}
}
Raising events defensively means that as the raised event is passed to each handler,
any
Mainly for internal use within the framework.
This is a utility class, and as such exposes no public constructors.
Not intended to be used directly by applications.
This is a utility class, and as such exposes no public constructors.
InstantiateType(Type) fails.
As this method doesn't try to instantiate
As this method doesn't try to instantiate
Neccessary when dealing with server-activated remote objects, because the
object is of the type TransparentProxy and regular
Transparent proxy instances always return
Considers primitive wrapper classes as assignable to the corresponding primitive types.
For example used in an object factory's constructor resolution.
Used to determine properties to check for a "simple" dependency-check.
null).
null
Any (back)slashes are converted to forward slashes.
// true
PathMatcher.Match("c:/*.bat", @"c:\autoexec.bat");
PathMatcher.Match("c:\fo*\*.bat", @"c:/foobar/autoexec.bat");
PathMatcher.Match("c:\fo?\*.bat", @"c:/foo/autoexec.bat");
// false
PathMatcher.Match("c:\fo?\*.bat", @"c:/fo/autoexec.bat");
This is a utility class, and as such exposes no public constructors.
key1 = value
key2:
key3
will result in the name/value pairs:
Follows the standard .NET conventions for default values where
relevant; for example, all numeric types default to the value
[C#]
Given an array containing the following objects,
[83, "Foo", new object ()], the [Int32, String, Object].
Includes non-public methods in the methods searched.
Note that if a non-
If the
Mainly for internal use within the framework.
This is a utility class, and as such exposes no public constructors.
If
If
If
If
If the supplied
StringUtils.HasLength(null) = false
StringUtils.HasLength("") = false
StringUtils.HasLength(" ") = true
StringUtils.HasLength("Hello") = true
More specifically, returns
StringUtils.HasText(null) = false
StringUtils.HasText("") = false
StringUtils.HasText(" ") = false
StringUtils.HasText("12345") = true
StringUtils.HasText(" 12345 ") = true
More specifically, returns
StringUtils.IsNullOrEmpty(null) = true
StringUtils.IsNullOrEmpty("") = true
StringUtils.IsNullOrEmpty(" ") = true
StringUtils.IsNullOrEmpty("12345") = false
StringUtils.IsNullOrEmpty(" 12345 ") = false
The return value of this method call is always guaranteed to be non
The return value of this method call is always guaranteed to be non
This class implements template
This interface allows us to define the actions that should be executed after validation in a generic fashion.
For example, addition of error messages to validation errors collection
is performed by one specific implementation of this interface,
<property> tag.
id attribute specified are registered
as separate object definitions within application context.
Custom validators should always extend this class instead of
simply implementing
The primary motivation for this interface is to enable validation to be decoupled from the (user) interface and placed in business objects.
Application developers writing their own custom
Test can be any logical expression that is supported by the Spring.NET logical expression evaluation engine, and can use any variables that can be resolved by the variable resolver used by the validation engine.
The test expression must evaluate to a
This validator uses following rules to determine if target value is valid:
| Target |
Valid Value |
|---|---|
| A |
Not |
| A |
Not |
| One of the number types. | Not zero. |
| A |
Not |
| Any reference type other than |
Not |
You cannot use this validator to validate any value types other than the ones specified in the table above.
This validator will be valid when one or more of the validators in the
This validator will be valid only when all of the validators in the
This validator will be valid only when all of the validators in the
You can specify if you want to validate all of the collection elements regardless of the errors, by
setting the
If you set the
This validator will be valid when one and only one of the validators in the
By default, this validator group uses
If the supplied
If there are no errors for the supplied
If there are no errors for the supplied lookup
If this returns
This class groups validation errors by validator names and allows access to both the complete errors collection and to the errors for a certain validator.
If the supplied
If there are no errors for the supplied lookup
If there are no errors for the supplied lookup
If this returns
This class allows validation groups to reference validators that are defined outside of the group itself.
It also allows users to narrow the context for the referenced validator
by specifying value for the
Invoked after population of normal object properties but before an init
callback like