Los documentos oficiales: http: //docs.autofac.org/en/latest/register/registration.html
En primer lugar, el concepto de registro
componente de registro Uso Autofac, mediante la creación de un ContainerBuilder e informar constructor de qué servicio público que los componentes.
Componentes de reflexión (por el registro de un tipo particular o genéricos .net abiertas) la creación, la creación proporcionando instancia ya hecho (una instancia de objeto que ha creado); o creados por la expresión lambda. ContainerBuilder una serie de método de Registro () que le permite alcanzar estos valores.
Mediante el uso de método que en () de ContainerBuilder, cada componente da a conocer en uno o más servicios.
// crear el contenedor de componente / servicio registrada
var = new nuevo ContainerBuilder Builder ();
// tipo de registro da a conocer Interface
builder.RegisterType <ConsoleLogger> () de Como <ILogger> () ;.
// Registro se crea una instancia de objeto
de salida var = StringWriter nuevo nuevo ();
builder.RegisterInstance (la salida) la .as <TextWriter> ();
// expresión ejecución registrada crea un objeto
builder.Register (c => new ConfigReader ( "MySection")) Como <IConfigReader> (). ;
// compilar completar el contenedor registro y preparación objetos de análisis sintáctico
var = contenedor builder.Build ();
.. // ahora se puede utilizar el servicio de resolución Autofac por ejemplo, se está a punto de realizar el registro de una expresión lambda para el servicio IConfigReader
usando (alcance var = contenedor .BeginLifetimeScope ())
{
var Lector = container.Resolve <IConfigReader> ();
}
1, el conjunto reflectante
1.1 Por tipo de registro
constructor var = nuevo ContainerBuilder (); builder.RegisterType <ConsoleLogger> (); builder.RegisterType (typeof (ConfigReader));
Cuando se utiliza un componente de reflexión, Autofac automáticamente para su clase, el constructor tiene la mayoría de los parámetros coincidentes, este parámetro puede ser obtenida a partir del recipiente.
Por ejemplo, usted tiene una clase con tres constructores:
MyComponent public class
{
MyComponent pública () {/ * ... * /}
MyComponent pública (ILogger registrador) {/ * ... * /}
MyComponent pública (ILogger registrador, IConfigReader lector) {/ * ... * /}
}
Ahora, componentes y servicios registrados en su contenedor:
constructor var = nuevo ContainerBuilder ();
builder.RegisterType <MyComponent> ();
. builder.RegisterType <ConsoleLogger> () Como <ILogger> ();
contenedor var = builder.Build ();
usando (alcance var = container.BeginLifetimeScope ())
{
componente var = container.Resolve <MyComponent> ();
}
Al analizar sus componentes, Autofac se encuentra ya registrado ILogger, pero IConfigReader no han sido registrados. En este caso, se seleccionará el segundo constructor, porque tiene la más grande es un parámetro constructor se puede encontrar en el recipiente.
Tenga en cuenta que en base a los componentes reflejados: Tipo de componente RegisterType debe ser registrado por un tipo particular. Mientras que los componentes se pueden hacer clases e interfaces abstractas públicas como un servicio, pero no se puede registrar una abstractos componentes de clase / interfaz. Si se piensa en que tiene sentido: Dentro Autofac, Autofac crear una instancia de objeto que se registre. No se puede ser una nueva clase abstracta o una interfaz. Debe tener una implementación de la misma.
1.2 Especificar un constructor
Puede seleccionar manualmente un constructor específico, y la cubierta se utiliza para seleccionar automáticamente registrar conjunto de constructor, y un conjunto de métodos que utilizan parámetro de tipo UsingConstructor indicando los constructores de tipo:
builder.RegisterType <MyComponent> ()
.UsingConstructor (typeof (ILogger), typeof (IConfigReader));
Tenga en cuenta que al analizar, sigue siendo necesario para proporcionar los parámetros necesarios, de lo contrario un error al intentar resolver el aparece objeto. Puede pasar parámetros al registrar o pasar parámetros al analizar.
2, los ejemplos del componente
A veces, es posible que desee para generar primer ejemplo de un objeto, y añadirlo al contenedor para el componente para inscribirse. Puede hacerlo utilizando el RegisterInstance método:
salida var = new StringWriter (); builder.RegisterInstance (salida) .Como <TextWriter> ();
Al hacer algunas cosas a considerar, componente de liberación proceso de inscripción automática Autofac, o usted quiere controlar su ciclo de vida en lugar de llamar Autofac Desechar para usted en su objeto. En este caso (que desea controlar el ciclo de vida), es necesario utilizar el método para registrar ejemplo ExternallyOwned:
salida var = new StringWriter ();
builder.RegisterInstance (salida)
.Como <TextWriter> ()
.ExternallyOwned ();
Cuando Autofac integrado en una aplicación existente (instancia singleton ya existe una necesidad y el uso como un componente en un recipiente), que también proporciona ejemplos de registro práctico, estos componentes no directamente relacionados con una sola realización de la , que pueden ser registrados en un recipiente como un ejemplo:
builder.RegisterInstance (MySingleton.Instance) .ExternallyOwned ();
Esto asegurará que singleton estático puede ser eliminado con el tiempo y reemplazado por una gestión de contenedores.
El servicio por defecto se da a conocer a modo de ejemplo de un tipo particular. Ver "servicios y componentes" a continuación.
3, expresiones lambda conjunto
Para la reflexión creación de componentes es una muy buena opción por defecto. Cuando se crea un componente lógico no es sólo una simple llamada al constructor, las cosas van a causar problemas.
Autofac para aceptar una expresión delegado o lambda se utiliza para crear los componentes:
builder.Register (c => new A (c.Resolve <B> ()));
Expresión parámetro c se proporciona un componente de contexto (un objeto IComponentContext), donde se crea el montaje. Se puede utilizar para resolver otros componentes del contenedor para ayudarle a crear componentes. Es importante utilizar, en lugar de un cierre para acceder al contenedor, por lo que el apoyo correcto y contenedores a la medida de limpieza.
Use dependencias parámetro de contexto adicionales pueden usarse - en este caso, A es necesario el parámetro constructor de tipo B, puede tener dependencias adicionales.
Los servicios proporcionados por componente de expresión creada por defecto es la expresión inferido tipo de retorno.
Estos son algunos ejemplos de la demanda creada por el componente reflejada es muy torpe, pero por la expresión lambda es muy agradable de tratar.
- Los parámetros complejos
Los parámetros del constructor no siempre son una sencilla declaración de valor constante. valores de configuración XML sin necesidad de utilizar algún tipo de estructura gramatical, utilizando el código:
builder.Register (c => new UserSession (DateTime.Now.AddMinutes (25)));
Por supuesto, es posible que desee especificar la sesión expira algo en el archivo de configuración.
- inyección propiedades
Aunque Autofac proporcionar una inyección propiedad de primera clase, también puede utilizar expresiones de inicialización y atributos para llenar características:
builder.Register (c => new A () {myb = c.ResolveOptional <B> ()});
Este ResolveOptional método trata de resolver los valores, pero si el servicio no se ha registrado, no se producirá una excepción. (Usted recibirá una excepción si el servicio se ha registrado pero la propiedad no ha sido resuelto). Esta es una forma de resolver el servicio.
No se recomienda para la inyección uso de la propiedad en la mayoría de los casos. Alternativamente modo de objeto nulo, volver a cargar el constructor valores por defecto o un parámetro de constructor puede crear un limpiador, "cambio" componentes pueden ser la inyección de dependencia constructor usado.
- Una implementación (Selección de una implementación por valor de parámetro) Parámetro de valores seleccionando
componentes separados para crear la mayor ventaja es el tipo específico puede cambiar, que es por lo general se realiza en marcha, y no sólo cuando se configura:
builder.Register <CreditCard> (
(c, p) =>
{
var accountId = p.Named <string> ( "accountId");
si (accountId.StartsWith ( "9"))
{
return new GoldCard (accountId);
}
otra cosa
{
return new StandardCard (ID de cuenta);
}
});
En este ejemplo, CreditCard dos clases implementan, GoldCard y StandardCardque depende de una instancia de la clase para proporcionar el tiempo de ejecución accountId.
En este ejemplo, el método de crear el segundo parámetro proporcionado por el parámetro p.
Utilice el siguiente código para registrarse:
tarjeta var = container.Resolve <CreditCard> (nuevo NamedParameter ( "accountId", "12345"));
Si crea un delegado CreditCard declaración de instancia y una fábrica de delegado, puede obtener un tipo limpio, seguro de la sintaxis.
4, los componentes comunes revelados (Open componentes genéricos)
apoyo Autofac abierta tipo genérico, utilice RegisterGeneric () constructor:
builder.RegisterGeneric (typeof (NHibernateRepository <>))
.Como (typeof (IRepository <>))
.InstancePerLifetimeScope ();
Cuando las necesidades de contenedores para escribir un servicio de búsqueda, autofac se asignará a un equivalente de cerca de lograr el tipo de versión.
// Autofac devolverá un NHibernateRepository <> tarea tareas var = container.Resolve <IRepository <Tarea >> ();
Tipo de propiedad de servicio (por ejemplo IRepository <persona>) el registro volverá a escribir la versión genérica.
5, servicios y componentes (Servicios) Componentes vs.
Cuando se registra componentes, que debe contar el componente autofac servicio público, por defecto, a sí mismos registrada sólo los más públicamente como el tipo de registro.
// Esto expone el servicio "CallLogger" builder.RegisterType <CallLogger> ();
Los componentes sólo se puede resolver sus servicios públicos, en este ejemplo sencillo, que significa:
// Este trabajo, debido a que las reuniones públicas por defecto de este tipo scope.Resolve <CallLogger> (); // esto no va a funcionar, porque no hemos registrado ni divulgar ILogger interfaces de scope.Resolve <ILogger> ();
Se puede utilizar cualquier número de componente de servicio público.
builder.RegisterType <CallLogger> ()
.Como <ILogger> ()
.Como <ICallInterceptor> ();
Una vez que un servicio público, puede resolver los servicios basados en componentes. Nótese, sin embargo, una vez que se abre como un componente de un determinado servicio, el servicio predeterminado (tipo de componente) se cubrirá:
// estos trabajos voluntad, porque abrimos un servicio correspondiente en el registro scope.Resolve <ILogger> (); scope.Resolve <ICallInterceptor> (); // Esto no va a funcionar, porque hemos desarrollado un especial reescribir el servicio de componente scope.Resolve <CallLogger> ();
Si desea abrir un componente es un conjunto de servicios y el uso del servicio por defecto, puede utilizar el método AsSelf:
builder.RegisterType <CallLogger> ()
.AsSelf ()
.Como <ILogger> ()
.Como <ICallInterceptor> ();
Ahora, todo lo cual va a funcionar:
// Estos hará todo el trabajo, ya expusimos // los servicios apropiados en el registro: scope.Resolve <ILogger> (); scope.Resolve <ICallInterceptor> (); scope.Resolve <CallLogger> ();
6, el registro por defecto (por defecto Las inscripciones)
Si hay varios componentes con un servicio público, autofac utilizarán el componente final registrado como el proveedor de servicios predeterminado:
. builder.Register <ConsoleLogger> () Como <ILogger> (); . builder.Register <FileLogger> () Como <ILogger> ();
En este caso se FileLogger proveedor de ILogger como el servicio por defecto, ya que se registró por última vez.
Con el fin de derrocar este caso, se puede utilizar el PreserveExistingDefaults()método de modificar:
. builder.Register <ConsoleLogger> () Como <ILogger> (); builder.Register <FileLogger> () Como <ILogger> () PreserveExistingDefaults ()..;
En este caso, el proveedor ConsoleLogger se ILogger como el servicio por defecto, porque la última FileLogger registrada utilizada PreserveExistingDefaults ().
7, el registro de configuración (Configuración de Registros)
Puede configurar "módulos" para proporcionar un conjunto de registro de inscripción o cambiar en tiempo de ejecución usando XML o de programación. módulos autofac se pueden usar para generar o proporcionar dinámica lógica registro de condición de registro.