dependency-injection - library - spring net github

Configuración Spring.Net con fluidez

Question

Tengo la necesidad de utilizar Spring .Net en un proyecto y estoy explorando las opciones de configuración. Todo lo que puedo encontrar sobre la configuración de Spring .Net es cosas del archivo de configuración. ¿Spring admite la configuración en el código? He usado Castle y Ninject, y ambos parecen ofrecer esto de forma nativa. He encontrado proyectos que pretenden agregar soporte, pero no quiero un proyecto falso que muera en 6 meses. ¡He encontrado referencias en blogs que parecen indicar que Spring admite esto, pero no puedo encontrar ninguna documentación!

La parte 2 de esto podría ser ¿recomendaría Spring .Net a Windsor sabiendo que no puede soportar una configuración fluida? Sé que ambos son excelentes contenedores de IoC, pero he trabajado en proyectos que tienen archivos de configuración masivos para la configuración de Spring y lo odio.

Answer 1

No, la versión actual (1.3) de Spring.NET solo es compatible con la configuración XML . Se ha hablado de admitir Code as Configuration en versiones futuras, pero esto aún no se ha materializado.

En mi opinión, Castle Windsor es muy superior a Spring.NET. No puedo pensar en una característica única de Spring.NET que Castle Windsor no tenga. Por otro lado, Castle Windsor tiene las siguientes características que no están disponibles en Spring.NET:

• Código como configuración
• Configuración basada en la convención
• Más vidas
• Vidas personalizadas
• Desmantelamiento del gráfico de objetos
• Cartografía explícita de interfaces / clases base para tipos concretos
• Resolución basada en tipo
• Configuración modular (Instaladores)
• Soporte integrado para decoradores
• Mecanografiado

Probablemente haya otras características que olvidé ...

Parece que fui demasiado rápido en el gatillo aquí, aunque para mi defensa, la documentación de Spring.NET también indica que solo hay configuración XML en la versión actual.

Sin embargo, resulta que si para ciertos contextos, una API muy primitiva está disponible que le permite configurar un contexto sin XML. Aquí hay un ejemplo:

var context = new GenericApplicationContext();
context.RegisterObjectDefinition("EggYolk", 
    new RootObjectDefinition(typeof(EggYolk)));
context.RegisterObjectDefinition("OliveOil",
    new RootObjectDefinition(typeof(OliveOil)));
context.RegisterObjectDefinition("Mayonnaise", 
    new RootObjectDefinition(typeof(Mayonnaise), 
        AutoWiringMode.AutoDetect));

Observe cómo esta API refleja muy de cerca el esquema de configuración XML. Por lo tanto, no obtiene ninguna API fluida de la interfaz IObjectDefinitionRegistry , pero al menos hay una API que está desacoplada de XML. Construir una API fluida además de esto es al menos teóricamente posible.

Answer 2

Encontrarás una API de primavera completamente operativa para spring.net en github:

https://github.com/thenapoleon/Fluent-API-for-Spring.Net

Esta API ofrece una configuración fluida y pronto admitirá la configuración basada en la convención.

Answer 3

En respuesta a la primera parte de su pregunta: el equipo de springsource parece estar trabajando en un proyecto de configuración de código en github: https://github.com/SpringSource/spring-net-codeconfig . Fue anunciado (pero no incluido) en el lanzamiento 1.3.1 (diciembre de 2010).

Desde el ejemplo de MovieFinder :

[Configuration]
public class MovieFinderConfiguration
{

    [Definition]
    public virtual MovieLister MyMovieLister()
    {
        MovieLister movieLister =  new MovieLister();
        movieLister.MovieFinder = FileBasedMovieFinder();
        return movieLister;

    }

    [Definition]
    public virtual IMovieFinder FileBasedMovieFinder()
    {
        return new ColonDelimitedMovieFinder(new FileInfo("movies.txt"));
    }
}

Answer 4

Utilizando Fluent-API-for-Spring.Net , la configuración podría ser algo así como:

    private void ConfigureMovieFinder()
    {

        FluentApplicationContext.Clear();

        FluentApplicationContext.Register<ColonDelimitedMovieFinder>("ColonDelimitedMovieFinder")
            .BindConstructorArgument<FileInfo>().To(new FileInfo("movies.txt"));

        // By default, fluent spring will create an identifier (Type.FullName) when using Register<T>()
        FluentApplicationContext.Register<MovieLister>()
            .Bind(x => x.MovieFinder).To<IMovieFinder>("ColonDelimitedMovieFinder");
    }

Answer 5

Hay otra opción usando Spring.AutoRegistration. El mismo concepto utilizado con Unity AutoRegistration.

https://www.nuget.org/packages/Spring.AutoRegistration

http://autoregistration.codeplex.com/

    var context = new GenericApplicationContext();
    context.Configure()
                .IncludeAssembly(x => x.FullName.StartsWith("Company.ApplicationXPTO"))
                .Include(x => x.ImplementsITypeName(), Then.Register().UsingSingleton()
                      .InjectByProperty(If.DecoratedWith<InjectAttribute>))
                .ApplyAutoRegistration();

Answer 6

También es posible utilizar el proyecto Spring.FluentContext .

Con él, la configuración de MovieFinder se vería de la siguiente manera:

// Configuration
private static IApplicationContext Configure()
{
    var context = new FluentApplicationContext();

    context.RegisterDefault<MovieLister>()
            .BindProperty(l => l.MovieFinder).ToRegisteredDefaultOf<ColonDelimitedMovieFinder>();

    context.RegisterDefault<ColonDelimitedMovieFinder>()
            .UseConstructor((FileInfo fileInfo) => new ColonDelimitedMovieFinder(fileInfo))
            .BindConstructorArg().ToValue(new FileInfo("movies.txt"));

    return context;
}

// Usage
static void Main(string[] args)
{
    IApplicationContext context = Configure();

    var movieLister = context.GetObject<MovieLister>();

    foreach (var movie in movieLister.MoviesDirectedBy("Roberto Benigni"))
        Console.WriteLine(movie.Title);

    Console.ReadLine();
}

No requiere ningún ID literal codificado para objetos (pero permite eso), es seguro y contiene documentación con muestras en la wiki de GitHub .