/// <summary> /// Saves the ObjectDefinition instance using the specific key. /// </summary> /// <param name="key">The specific key to use</param> /// <param name="definition">The ObjectDefinition instance to save</param> /// <exception cref="ObjectSourceException"> /// Wraps any implementation specific exceptions that may occur while saving the definition /// info but may also indicate incomplete definition info (missing type name), parsing errors /// if the source uses string representations or some other implementation specific error. /// </exception> /// <exception cref="ArgumentNullException">If the key is null or definition is null.</exception> /// <exception cref="ArgumentException">If the key is empty.</exception> public abstract void SaveDefinition(string key, ObjectDefinition definition);
/// <summary> /// <para> /// Saves the given object definition in NESTED hierarchical structure. /// </para> /// </summary> /// /// <param name="key"> /// The key of the object definition. /// </param> /// <param name="definition"> /// The object definition to be saved. /// </param> private void SaveNestedObjectDefinition(string key, ObjectDefinition definition) { // The root config of the definition IConfiguration objectConfig = AddRootConfig(ConfigObject, key); // Write all simple attributes of the definition AddNewNestedConfig(objectConfig, ConfigAppDomain, definition.AppDomain); AddNewNestedConfig(objectConfig, ConfigAssembly, definition.Assembly); AddNewNestedConfig(objectConfig, ConfigTypeName, definition.TypeName); AddNewNestedConfig(objectConfig, ConfigIgnoreCase, definition.IgnoreCase); AddNewNestedConfig(objectConfig, ConfigInstantiationLifetime, definition.InstantiationLifetime); AddNewNestedConfig(objectConfig, ConfigMethodName, definition.MethodName); // Get the method call definitions MethodCallDefinition[] methods = definition.MethodCalls; if (methods.Length > 0) { // The methods config IConfiguration methodsConfig = new DefaultConfiguration(ConfigMethods); // Write each method call definition int index = 0; foreach (MethodCallDefinition method in methods) { SaveNestedMethodDefinition(methodsConfig, ConfigMethod + (++index), method); } // Add the methods config into root config objectConfig.AddChild(AbstractConfiguration.Synchronized(methodsConfig)); } if (definition.ParamTypes.Length > 0) { // Write the parameter definitions of the object SaveNestedParameters(objectConfig, definition.ParamTypes, definition.ParamValues); } }
/// <summary> /// <para> /// Saves the specified object definition in <see cref="IConfiguration"/> /// object with the specified key. /// </para> /// </summary> /// /// <remarks> /// <para> /// If an object with the same key already exists, the old definition will be overwritten. /// </para> /// /// <para> /// The structure used to save the definition depends on <see cref="ConfigurationType"/>. /// </para> /// </remarks> /// /// <param name="key"> /// The key to use. Can't be null or empty. /// </param> /// <param name="definition"> /// The definition to be saved. /// </param> /// /// <returns> /// The object definition info. /// </returns> /// /// <exception cref="ArgumentNullException"> /// If the key or definition is null. /// </exception> /// <exception cref="ArgumentException"> /// If the key is an empty string. /// </exception> public override void SaveDefinition(string key, ObjectDefinition definition) { ValidateNotNullOrEmpty(key, "key"); ValidateNotNull(definition, "definition"); // Try to remove the object definition first DeleteDefinition(key); if (configurationType == ConfigurationType.Flat) { SaveFlatObjectDefinition(key, definition); } else { SaveNestedObjectDefinition(key, definition); } }
/// <summary> /// <para> /// Saves the object definition into FLAT structure. /// </para> /// </summary> /// /// <param name="nameSpace"> /// The namespace of the configuration. /// </param> /// <param name="definition"> /// The object definition to be saved. /// </param> private void SaveFlatObjectDefinition(string nameSpace, ObjectDefinition definition) { IConfiguration objectConfig = AddRootConfig(ConfigNamespace, nameSpace); int propertyIndex = 0; // Save simple attributes into "property" nodes AddNewFlatConfig(objectConfig, ++propertyIndex, ConfigAppDomain, definition.AppDomain); AddNewFlatConfig(objectConfig, ++propertyIndex, ConfigAssembly, definition.Assembly); AddNewFlatConfig(objectConfig, ++propertyIndex, ConfigTypeName, definition.TypeName); AddNewFlatConfig(objectConfig, ++propertyIndex, ConfigIgnoreCase, definition.IgnoreCase); AddNewFlatConfig(objectConfig, ++propertyIndex, ConfigInstantiationLifetime, definition.InstantiationLifetime); AddNewFlatConfig(objectConfig, ++propertyIndex, ConfigMethodName, definition.MethodName); MethodCallDefinition[] methods = definition.MethodCalls; if (methods.Length > 0) { // The method name list object[] methodNames = new string[methods.Length]; for (int i = 0; i < methodNames.Length; ++i) { // Write method definitions methodNames[i] = methods[i].MethodName; SaveFlatMethodDefinition(nameSpace + "." + methods[i].MethodName, methods[i]); } AddNewFlatConfig(objectConfig, ++propertyIndex, ConfigMethods, methodNames); } if (definition.ParamTypes.Length > 0) { // Write parameter definitions SaveFlatParameters( nameSpace + "." + ConfigParameters, definition.ParamTypes, definition.ParamValues); } }