AutoYumYum 1.1.2

AutoYumYum

AutoYumYum makes dependency injection in .NET a breeze.
Register your services with a simple attribute and let AutoYumYum do the rest.

Free to use for personal and commercial projects. This package is closed source.

Features

• Attribute-driven service registration (Singleton, Scoped, Transient)
• Supports Microsoft.Extensions.DependencyInjection
• No more bloated DI setup code

Usage

RegisterAs - Singleton

[RegisterAs<IMyService>(lifetime: RegisterScopeType.Singleton)]
public class MyService : IMyService
{
    // Implementation
}

Then, in your startup:

services.AddAttributedServices(typeof(Program).Assembly);

More Usage Examples:

RegisterAs - Transient

[RegisterAs<ILogger>(lifetime: RegisterScopeType.Transient)]
public class ConsoleLogger : ILogger
{
    public void Log(string message) => Console.WriteLine(message);
}

RegisterAs - Scoped

[RegisterAs<IOrderService>(lifetime: RegisterScopeType.Scoped)]
public class OrderService : IOrderService
{
    // Implementation
}

RegisterAsSelf

[RegisterAsSelf(lifetime: RegisterScopeType.Singleton)]
public class CacheManager
{
    public void Clear() => Console.WriteLine("Cache cleared.");
}

RegisterWithFactory

public interface ISpecialService
{
    string Info { get; }
}

public class SpecialService : ISpecialService
{
    public string Info { get; }

    public SpecialService(string info)
    {
        Info = info;
    }
}

public static class SpecialServiceFactory
{
    public static ISpecialService Create(IServiceProvider sp)
    {
        return new SpecialService("Created via factory");
    }
}

[RegisterWithFactory(typeof(SpecialServiceFactory), lifetime: RegisterScopeType.Singleton)]
public class SpecialServiceMarker : ISpecialService
{
    public string Info => throw new NotImplementedException("Marker class should never be instantiated directly.");
}

RegisterWithFactory (Advanced Example)

You can register services using a factory class that contains a Create(IServiceProvider) method. This is useful when:

• You have conditional logic for which implementation to return
• The service's constructor needs runtime configuration or custom logic
• You want to keep instantiation centralized

Interface + Implementations

public interface ISpecialService
{
    string Info { get; }
}

public class FastSpecialService : ISpecialService
{
    public string Info => "I am FastSpecialService";
}

public class SecureSpecialService : ISpecialService
{
    public string Info => "I am SecureSpecialService";
}

The Factory Class

public static class SpecialServiceFactory
{
    public static ISpecialService Create(IServiceProvider sp)
    {
        // Choose based on any app condition, injected service, env var, etc.
        var useSecure = true; // hardcoded for clarity in this example

        return useSecure
            ? new SecureSpecialService()
            : new FastSpecialService();
    }
}

The factory can use logic to determine which implementation to return at runtime.

The Marker Class

[RegisterWithFactory(typeof(SpecialServiceFactory), lifetime: RegisterScopeType.Singleton)]
public class SpecialServiceMarker : ISpecialService
{
    public string Info => throw new NotImplementedException("This is a factory-registered service and should not be constructed directly.");
}

The SpecialServiceMarker class serves as a declarative marker so that AutoYumYum knows:

• What interface to register
• What factory to call
• What lifetime to use

The marker class is never actually instantiated.

Consuming the Service

public class HomeController
{
    private readonly ISpecialService _special;

    public HomeController(ISpecialService special)
    {
        _special = special;
    }

    public string Index()
    {
        return _special.Info;
    }
}

Summary

• Use [RegisterWithFactory] to register services with conditional or complex construction logic
• The marker class ensures discovery and DI compatibility
• The factory method controls instantiation at runtime

Support / Donate

AutoYumYum by DC Tek Solutions is currently free, and user support keeps it that way!
If you find them helpful, please consider supporting future development:

Thank you for your support!