/// <summary>
/// Initializes a new instance of the <see cref="ObjectDefinitionParser"/> class.
/// </summary>
/// <param name="domainObjectType">Type of the domain object you are going to configure for DI.</param>
/// <param name="identifier">An identifier to use when declaring several configuration for the same domain type.</param>
public ObjectDefinitionParser(Type domainObjectType, string identifier)
{
_domainObjectType = domainObjectType;
_identifier = identifier;
_autoWiringMode = FluentStaticConfiguration.DefaultWiringMode;
_dependencyCheckMode = FluentStaticConfiguration.DefaultDependencyCheckingMode;
}
protected AbstractObjectDefinition(SerializationInfo info, StreamingContext context)
{
constructorArgumentValues = (ConstructorArgumentValues)info.GetValue("constructorArgumentValues", typeof(ConstructorArgumentValues));
propertyValues = (MutablePropertyValues)info.GetValue("propertyValues", typeof(MutablePropertyValues));
eventHandlerValues = (EventValues)info.GetValue("eventHandlerValues", typeof(EventValues));
methodOverrides = (MethodOverrides)info.GetValue("methodOverrides", typeof(MethodOverrides));
resourceDescription = info.GetString("resourceDescription");
isSingleton = info.GetBoolean("isSingleton");
isPrototype = info.GetBoolean("isPrototype");
isLazyInit = info.GetBoolean("isLazyInit");
isAbstract = info.GetBoolean("isAbstract");
scope = info.GetString("scope");
role = (ObjectRole)info.GetValue("role", typeof(ObjectRole));
var objectTypeName = info.GetString("objectTypeName");
objectType = objectTypeName != null?Type.GetType(objectTypeName) : null;
autowireMode = (AutoWiringMode)info.GetValue("autowireMode", typeof(AutoWiringMode));
dependencyCheck = (DependencyCheckingMode)info.GetValue("dependencyCheck", typeof(DependencyCheckingMode));
dependsOn = (IList <string>)info.GetValue("dependsOn", typeof(IList <string>));
autowireCandidate = info.GetBoolean("autowireCandidate");
primary = info.GetBoolean("primary");
qualifiers = (IDictionary <string, AutowireCandidateQualifier>)info.GetValue("qualifiers", typeof(IDictionary <string, AutowireCandidateQualifier>));
initMethodName = info.GetString("initMethodName");
destroyMethodName = info.GetString("destroyMethodName");
factoryMethodName = info.GetString("factoryMethodName");
factoryObjectName = info.GetString("factoryObjectName");
}
/// <summary>
/// Creates a new instance of the
/// <see cref="Oragon.Spring.Objects.Factory.Support.RootObjectDefinition"/> class
/// for a singleton using the supplied
/// <see cref="Oragon.Spring.Objects.Factory.Config.AutoWiringMode"/>.
/// </summary>
/// <param name="type">
/// The <see cref="System.Type"/> of the object to instantiate.
/// </param>
/// <param name="autowireMode">
/// The autowiring mode.
/// </param>
/// <param name="dependencyCheck">
/// Whether to perform a dependency check for objects (not
/// applicable to autowiring a constructor, thus ignored there)
/// </param>
public RootObjectDefinition(
Type type, AutoWiringMode autowireMode, bool dependencyCheck)
{
ObjectType = type;
AutowireMode = autowireMode;
if (dependencyCheck &&
ResolvedAutowireMode != AutoWiringMode.Constructor)
{
DependencyCheck = DependencyCheckingMode.Objects;
}
}
/// <summary>
/// Creates a new instance of the
/// <see cref="Oragon.Spring.Objects.Factory.Support.RootObjectDefinition"/> class
/// for a singleton using the supplied
/// <see cref="Oragon.Spring.Objects.Factory.Config.AutoWiringMode"/>.
/// </summary>
/// <param name="type">
/// The <see cref="System.Type"/> of the object to instantiate.
/// </param>
/// <param name="autowireMode">
/// The autowiring mode.
/// </param>
public RootObjectDefinition(Type type, AutoWiringMode autowireMode)
{
ObjectType = type;
AutowireMode = autowireMode;
}
/// <summary>
/// Sets the autowire mode for this definition.
/// </summary>
/// <param name="autowireMode">The autowire mode.</param>
/// <returns>The current <code>ObjectDefinitionBuilder</code>.</returns>
public ObjectDefinitionBuilder SetAutowireMode(AutoWiringMode autowireMode)
{
objectDefinition.AutowireMode = autowireMode;
return(this);
}
/// <summary>
/// Sets the autowire mode for this definition.
/// </summary>
/// <param name="autowireMode">The autowire mode.</param>
/// <returns>The current <code>ObjectDefinitionBuilder</code>.</returns>
public ObjectDefinitionBuilder SetAutowireMode(AutoWiringMode autowireMode)
{
objectDefinition.AutowireMode = autowireMode;
return this;
}
/// <summary>
/// Autowire the object properties of the given object instance by name or
/// <see cref="System.Type"/>.
/// </summary>
/// <param name="instance">
/// The existing object instance.
/// </param>
/// <param name="autowireMode">
/// The desired autowiring mode.
/// </param>
/// <param name="dependencyCheck">
/// Whether to perform a dependency check for the object.
/// </param>
/// <exception cref="Spring.Objects.ObjectsException">
/// If the wiring fails.
/// </exception>
/// <exception cref="System.ArgumentException">
/// If the supplied <paramref name="autowireMode"/> is not one of the
/// <seealso cref="Spring.Objects.Factory.Config.AutoWiringMode.ByName"/> or
/// <seealso cref="Spring.Objects.Factory.Config.AutoWiringMode.ByType"/>
/// values.
/// </exception>
/// <seealso cref="Spring.Objects.Factory.Config.AutoWiringMode"/>
public virtual void AutowireObjectProperties(object instance, AutoWiringMode autowireMode, bool dependencyCheck)
{
if (autowireMode != AutoWiringMode.ByName && autowireMode != AutoWiringMode.ByType)
{
throw new ArgumentException("Just AutoWiringMode.ByName and AutoWiringMode.ByType allowed.");
}
RootObjectDefinition rod = new RootObjectDefinition(instance.GetType(), autowireMode, dependencyCheck);
PopulateObject(instance.GetType().Name, rod, new ObjectWrapper(instance));
}
/// <summary>
/// Create a new object instance of the given class with the specified
/// autowire strategy.
/// </summary>
/// <param name="type">
/// The <see cref="System.Type"/> of the object to instantiate.
/// </param>
/// <param name="autowireMode">
/// The desired autowiring mode.
/// </param>
/// <param name="dependencyCheck">
/// Whether to perform a dependency check for objects (not applicable to
/// autowiring a constructor, thus ignored there).
/// </param>
/// <returns>The new object instance.</returns>
/// <exception cref="Spring.Objects.ObjectsException">
/// If the wiring fails.
/// </exception>
/// <seealso cref="Spring.Objects.Factory.Config.AutoWiringMode"/>
public virtual object Autowire(Type type, AutoWiringMode autowireMode, bool dependencyCheck)
{
RootObjectDefinition rod = new RootObjectDefinition(type, autowireMode, dependencyCheck);
if (rod.ResolvedAutowireMode == AutoWiringMode.Constructor)
{
return AutowireConstructor(type.Name, rod, null, null).WrappedInstance;
}
object obj = InstantiationStrategy.Instantiate(rod, string.Empty, this);
PopulateObject(obj.GetType().Name, rod, new ObjectWrapper(obj));
return obj;
}
/// <summary>
/// 如果某个类型未在容器注册，则注册该类型
/// </summary>
/// <param name="container"></param>
/// <param name="alias"></param>
/// <param name="registerType"></param>
/// <param name="registerAsSingleton"></param>
/// <param name="autoWiringMode"></param>
public static void RegisterTypeIfMissing(this IApplicationContext container, string alias, Type registerType, bool registerAsSingleton, AutoWiringMode autoWiringMode, bool lazyInit = false)
{
Type typeToRegister = registerType;
if (!container.ContainsObjectDefinition(alias))
{
DefaultObjectDefinitionFactory definitionFactory = new DefaultObjectDefinitionFactory();
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.RootObjectDefinition(definitionFactory, typeToRegister);
builder.SetSingleton(registerAsSingleton);
builder.SetAutowireMode(autoWiringMode);
builder.SetLazyInit(lazyInit);
IConfigurableApplicationContext configurableContext = container as IConfigurableApplicationContext;
IObjectDefinitionRegistry definitionRegistry = container as IObjectDefinitionRegistry;
if (definitionRegistry != null)
{
definitionRegistry.RegisterObjectDefinition(alias, builder.ObjectDefinition);
//if (configurableContext != null)
//{
// configurableContext.Refresh();
//}
}
}
}
/// <summary>
/// 如果某个类型未在容器注册，则注册该类型
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="container"></param>
/// <param name="alias"></param>
/// <param name="registerAsSingleton"></param>
/// <param name="autoWiringMode"></param>
public static void RegisterTypeIfMissing <T>(this IApplicationContext container, string alias, bool registerAsSingleton, AutoWiringMode autoWiringMode) where T : class
{
Type typeToRegister = typeof(T);
RegisterTypeIfMissing(container, alias, typeToRegister, registerAsSingleton, autoWiringMode);
}
public IObjectConfigurationBuildStage <TObject> Autowire(AutoWiringMode mode)
{
_definition.AutowireMode = mode;
return(this);
}
public ICanConfigureObject <T> AutoWire(AutoWiringMode wiringMode)
{
_configurationParser.AutoWire(wiringMode);
return(this);
}
public void AutoWire(AutoWiringMode wiringMode)
{
_autoWiringMode = wiringMode;
}
public static void SetSpringDefault(AutoWiringMode wiringMode, DependencyCheckingMode dependencyCheckMode)
{
FluentStaticConfiguration.DefaultWiringMode = wiringMode;
FluentStaticConfiguration.DefaultDependencyCheckingMode = dependencyCheckMode;
}
/// <summary>
/// Creates a new instance of the
/// <see cref="Spring.Objects.Factory.Support.RootObjectDefinition"/> class
/// for a singleton using the supplied
/// <see cref="Spring.Objects.Factory.Config.AutoWiringMode"/>.
/// </summary>
/// <param name="type">
/// The <see cref="System.Type"/> of the object to instantiate.
/// </param>
/// <param name="autowireMode">
/// The autowiring mode.
/// </param>
/// <param name="dependencyCheck">
/// Whether to perform a dependency check for objects (not
/// applicable to autowiring a constructor, thus ignored there)
/// </param>
public RootObjectDefinition(
Type type, AutoWiringMode autowireMode, bool dependencyCheck)
{
ObjectType = type;
AutowireMode = autowireMode;
if (dependencyCheck
&& ResolvedAutowireMode != AutoWiringMode.Constructor)
{
DependencyCheck = DependencyCheckingMode.Objects;
}
}
/// <summary>
/// Creates a new instance of the
/// <see cref="Spring.Objects.Factory.Support.RootObjectDefinition"/> class
/// for a singleton using the supplied
/// <see cref="Spring.Objects.Factory.Config.AutoWiringMode"/>.
/// </summary>
/// <param name="type">
/// The <see cref="System.Type"/> of the object to instantiate.
/// </param>
/// <param name="autowireMode">
/// The autowiring mode.
/// </param>
public RootObjectDefinition(Type type, AutoWiringMode autowireMode)
{
ObjectType = type;
AutowireMode = autowireMode;
}
