The top-level element for the configuration section is defined by the name that you specify in the <configSections> tag when adding it to the configuration file. Typically, the element is <unity>, as shown in the following XML example. However, you can choose another name for this section.

XML	Copy Code
<configSections> <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration"/> </configSections> <unity xmlns="http://schemas.microsoft.com/practices/2010/unity"> <alias alias="ILogger" type="MyApp.ILogger, MyApp" /> <namespace name="MyApp.Implementations" /> <assembly name="MyApp" /> <container> … </container> </unity>

The following attribute is the only attribute available for the Unity section:

The following child elements are available for the <unity> section:

The <container> Element

The <container> element contains a set of configurations for a Unity container instance. Within that element, there can be child elements describing type mapping, injection configuration, instance creation, container extensions, or other options made available through any added section extensions. The following table lists the attribute for the <container> element.

The following example shows the usage of the <container> element.

XML	Copy Code
<unity xmlns="http://schemas.microsoft.com/practices/2010/unity"> <container> <!-- default container --> … content here ... </container> <container name="otherContainer"> ... content here ... </container> </unity>

The following table lists the child elements for the <container> element.

For more information see the following:

• The <register> Element
• The <instance> Element
• The <extension> Element

The <register> element is the basic building block for any configuration file. It enables you to specify type mappings and injection configuration for a type. If you specify a name, that name is used for the type mapping. If you do not specify a name, it creates a default mapping for the specified types. You can specify a lifetime manager for each mapping. If no explicit lifetime manager is configured for a type, it uses the transient lifetime manager.

The following table lists the attributes for the <register> element.

The following example shows the common usage for the <register> element.

XML	Copy Code
<container> <register type="MyService"> ... </register> <!-- Default registration for type MyService --> <register type="ILogger" mapTo="EventLogLogger" /> <!-- type mapping --> <register type="ILogger" mapTo="PageAdminLogger" name="emergency" /> <!-- named registration --> </container>

To register a type mapping at run time, use the RegisterType method. The following example registers EventLogLogger at run time.

C#	Copy Code
// Register a default (un-named) type mapping with a transient lifetime // Specify the registered type as an interface or object type // and the target type you want returned for that type myContainer.RegisterType<ILogger, EventLogLogger>();

Visual Basic	Copy Code
' Register a default (un-named) type mapping with a transient lifetime ' Specify the registered type as an interface or object type ' and the target type you want returned for that type myContainer.RegisterType(Of ILogger, EventLogLogger)()

For more information on registering a type at run time see Registering Types and Type Mappings.

The following table lists the child elements for the <register> element. When using interception configuration extension, Microsoft.Practices.Unity.InterceptionExtension.Configuration.InterceptionConfigurationExtension, additional elements are valid children of a <register> element. For more information see Interception Configuration Schema Elements.

For more information see the following:

• The <lifetime> Element
• The <constructor> Element
• The <property> Element
• The <method> Element

The <lifetime> element specifies which lifetime manager will be used to manage instances created for a type. If omitted, lifetime defaults to the TransientLifetimeManager. See Understanding Lifetime Managers for details about lifetime managers. The following example shows the common usage for the <lifetime> element

XML

Copy Code

<register type="ILogger" mapTo="SerialPortLogger"> <!-- Simple use of lifetime - singleton instance --> <lifetime type="singleton" /> </register> <register type="TypeWithCustomLifetime"> <!-- Use a Lifetime manager instance created by a type converter. Type converter gets passed extra information provided in in value attribute --> <lifetime type="SessionLifetimeManager" value="Session#1" typeConverter="SessionLifetimeConverter" /> </register>

The following table lists the attributes for the <lifetime> element.

The <lifetime> element has no valid child elements.

The <constructor>element configuration for the constructor for this type and contains details of the constructor injection requirements for this object type. The constructor element has no attributes. You can include only one <constructor> element in each register section. The example shows the common usage for the <constructor> element.

XML	Copy Code
<register type="ILogger" mapTo="SerialPortLogger"> <!-- Call the constructor with one parameter named "port" --> <constructor> <param name="port" value="COM1:" /> </constructor> </register>

The following table lists the child element for the <constructor> element.

For more information see The <param> Element.

You can specify a constructor for the injection of a specific named instance. In the following example, InjectionConstructor indicates which constructor to use based on its arguments, the string "UI," and causes the TraceSourceLogger constructor with a single string parameter to be invoked.

C#	Copy Code
container.RegisterType<ILogger, TraceSourceLogger>( "UI", new InjectionConstructor("UI")); container.RegisterType<DriveController>( new InjectionProperty("MyProperty")); container.RegisterType<DriveController>( new InjectionMethod("InitializeMe", 42.0, new ResolvedParameter(typeof(ILogger), "SpecialLogger")));

Visual Basic	Copy Code
container.RegisterType(Of ILogger, TraceSourceLogger) _ ("UI", New InjectionConstructor("UI")) container.RegisterType(Of DriveController) _ (New InjectionProperty("MyProperty")) container.RegisterType(Of DriveController) _ (New InjectionMethod ( _ "InitializeMe", _ 42, _ New ResolvedParameter(GetType(ILogger), "SpecialLogger")))

For more information on using injection at run time see Registering Injected Parameter and Property Values.

The <property>element configures a property for injection. It contains details of the property injection requirements for this object type. You can include one or more <property>elements in each <register> element. See Specifying Values for Injection for details on how to specify what value to inject for the property. No explicit value means to inject the default value for the type of the property.

XML	Copy Code
<register type="ILogger" mapTo="SerialPortLogger"> <!-- Inject the property "Settings" --> <property name="Settings" /> </register>

The following table lists the attributes for the <property> element.

The <property> element can take a single child element, which can be one of the following:

For information about the child elements of the <property> element, see the following:

• The <dependency> Element
• The <value> Element
• The <optional> Element
• The <array> Element

The <method> element configures a method that will be called as part of creating an instance. It contains details of the method injection requirements for this object type. You can include one or more <method> elements for each <register> element.

XML	Copy Code
<register type="MyLogger"> <method name="Initialize"> <param name="loggerSettings" /> </method> </register>

The following table lists the attributes for the <method> element.

The <method> element can take the following child elements. These correspond to the parameters of the method you want to specify.

For more information see the <param> element.

The <param> element specifies a parameter for constructor or method injection. It is used to determine which constructor or method overload is called, based on the names (and optionally types) of the parameters for the constructor or method.

XML	Copy Code
<constructor> <param name="param1" /> <param name="param2" value="Hello World!" /> </constructor>

See Specifying Values for Injection for more information about how the values for the parameters are provided.

The following table lists the attributes for the <param> element.

The <param> element can take one of the following child elements. Only one child element is allowed.

For information about the child elements of the <param> element, see the following:

• The <value> Element
• The <dependency> Element
• The <optional> Element
• The <array> Element

Value elements are a schema extension point, so other child elements may be allowed depending on which schema extensions are available. See Extending the Unity Configuration Schema.

The <dependency> element is used when a value is to be resolved through the container. By default, with no other configuration, this element results in a callback into the container for the default value of the type of the containing parameter or property. Attributes may be used to customize what is resolved. If the value cannot be resolved, then an exception is thrown at resolve time. The following example shows the common usage for the <dependency> element.

XML	Copy Code
<constructor> <param name="param1"> <dependency name="otherRegistration" /> </param> </constructor>

The following table lists the attributes for the <dependency> element.

The <dependency> element has no valid child elements.

The <value> element is used to specify a specific value for a parameter or property. This element lets you specify a string that is then passed through a TypeConverter to create the actual object to be injected. If no specific type converter type is given, then the default type converter for the type of parameter or property is used.

The string is converted to an object using the invariant culture; if you wish to use a locale-specific culture you must provide a custom TypeConverter to do so.

The following table lists the attributes for the <value> element.

The following example shows the common usage of the <value> element.

XML	Copy Code
<constructor> <param name="param1"> <value value="42" /> </param> <param name="param2"> <value value="aieou" typeConverter="VowelTypeConverter" /> </param> </constructor>

The <value> element has no valid child elements.

The <optional> element is used when a value should be resolved through the container but its presence is optional. The container will try to resolve this parameter or property using the types and mappings registered in the container, but if the resolution fails, the container returns null instead of throwing an exception.

The following table lists the attributes for the <optional> element.

XML	Copy Code
<constructor> <param name="param1"> <optional name="otherRegistration" /> </param> </constructor>

The <optional> element has no valid child elements.

The <array> element can be used to customize which elements are returned in the array if a parameter or property is of an array type. See Specifying Values for Injection for more details.

The <array> element takes no attributes.

The <array> element has a collection of zero or more child elements. If there are no child elements, an empty, zero-length array for both generic and non-generic types is injected. If there is more than one child, any value element such as <dependency>, <optional>, or <value> may be used, and each one corresponds to an element in the returned array.

If you want to have the default container behavior for arrays, do not specify the <array> element; use the <dependency> element instead.

The following example shows the common usage of the <array> element.

XML

Copy Code

<register type="ILogger" mapTo="NetworkLogger"> <!-- Empty array --> <property name="noSettings"> <array /> </property> <!-- Type NetworkSettings[], get default array injection --> <property name="allSettings" /> <!--Type NetworkSettings[], get only the specified three values --> <property name="someSettings"> <array> <dependency name="fastSettings" /> <optional name="turboSettings" /> <value value="port=1234;protocol=tcp;timeout=60” typeConverter="ConnectionSettingsTypeConverter" /> </array> </property> </register>

The <extension> element is used to add a Unity container extension to a container and contains the list of extensions to register with the Unity container.

The following example shows the common usage for the <extension> element.

XML	Copy Code
<container> <extension type="Microsoft.Practices.Unity.Interception.InterceptionExtension, Microsoft.Practices.Unity.Interception" /> </container>

The following example adds an extension at run time. This code creates a new instance of an extension class named MyCustomExtension that you have previously created, and which resides in this or a referenced project, and adds it to the container.

C#	Copy Code
IUnityContainer container = new UnityContainer(); container.AddNewExtension<MyCustomExtension>();

Visual Basic	Copy Code
Dim container As IUnityContainer = New UnityContainer() container.AddNewExtension(Of MyCustomExtension)()

For more information on adding extensions at run time see Registering Container Extensions.

The following table describes the single attribute for the <extension> element.

There are no child elements for the <extension> element.

The <instance> element is used to specify a value to be placed in the container and to indicate that you do not want that value to be created by the container but that it will be created by using a TypeConverter and then placed in the container by using the RegisterInstance method.

Instances added through configuration tend to be simple because it is hard to represent them with a string value, but they could be arbitrarily complex if there is a type converter that can handle the conversion from a string.

Note:
You cannot use an existing instance with the <instance> element. The <instance> section results in the creation of a new instance, much like something registered with RegisterType would. This is in contrast to the use of RegisterInstance, which requires the user to create the instance manually and then register it.

The following table lists the attributes for the <instance> element.

The following example shows how the <instance> element is used in a configuration file.

XML	Copy Code
<container> <!-- A named string value --> <instance name="NorthwindDb" value="SqlConnectionStringHere" /> <!-- A typed value --> <instance type="ConnectionSettings" value="port=1234" typeConverter="ConnectionSettingsTypeConverter" /> </container>

The following example shows how you can register instances at run time. The following example creates a default (unnamed) registration for an object of type EmailService that implements the IMyService interface.

C#	Copy Code
EmailService myEmailService = new EmailService(); myContainer.RegisterInstance<IMyService>(myEmailService);

Visual Basic	Copy Code
Dim myEmailService As New EmailService() myContainer.RegisterInstance(Of IMyService)(myEmailService)

The <instance> element has no child elements.

The <namespace> element is used to declare namespaces that will be automatically searched for types, as explained in the section Specifying Types in the Configuration File.

The following table lists the attribute for the <namespace> element.

The following example shows how the <namespace> element is used.

XML	Copy Code
<namespace name="ObjectsInstancesExamples.MyTypes" />

See Specifying Types in the Configuration File for more examples.

The <namespace> element has no allowed child elements.

The <assembly> element is used to declare assemblies that Unity will automatically search for types, as described in the section Specifying Types in the Configuration File.

The following table lists the attribute for the <assembly> element.

The following example shows how the <assembly> element is used. See Specifying Types in the Configuration Filefor more examples.

XML	Copy Code
<assembly name="ObjectsInstancesExamples" />

See the Automatic Type Lookup section for the search rules for matches.

The <assembly> element has no allowed child elements.

The <alias> element is used to define a type alias, as explained in the section Specifying Types in the Configuration File.

The following table lists the attributes for the <alias> element.

The following example shows how the <alias> element is used.

XML	Copy Code
<unity> <alias alias="MyLogger" type="MyNamespace.MyLogger, MyProject" /> <alias alias="AGenericType" type="MyNamespace.MyGenericType`1, MyProject" /> </unity>

The <alias> element has no valid child elements.

The <sectionExtension> element is used to load a schema extension. Unlike the <extension> element, which is used to load a container extension object to modify the run-time behavior of a Unity container instance, this element loads a schema extension, which modifies the allowed elements in the configuration file itself. This is a section-level element; it must occur outside any <container> elements.

See Extending the Unity Configuration Schema for more details.

The following table describes the attributes for the <sectionExtension> element.

XML	Copy Code
<unity> <sectionExtension type="MyProject.MySectionExtension, MyProject" /> <sectionExtension prefix="ext" type="MyOtherSectionExtension" /> ... </unity>

The <sectionExtension> element has no allowed child elements.