Summary

This release introduces a new, high-performance dependency resolver designed for AOT (Ahead-of-Time) compilation compatibility, while significantly reducing the trimming attribute burden on your applications.

What Changed

1. New Dependency Resolver Implementation

We've replaced the previous dependency resolver with a new AOT-compatible, generic-first implementation that provides:

• Better Performance: See benchmark results in the README showing significant improvements in service resolution speed
• True AOT Compatibility: Works seamlessly with Native AOT compilation without reflection warnings
• Reduced Memory Allocations: More efficient memory usage during service resolution

2. Simplified Trimming Attributes (Major Developer Experience Improvement)

This is a big win for you as an end user!

Previously, using Splat's dependency injection features required you to annotate your code with various DynamicallyAccessedMembers attributes to satisfy the trimmer. This was burdensome and easy to get wrong.

Now: We've removed the need for almost all trimming attributes!

• ✅ No more [DynamicallyAccessedMembers] attributes required on your service types
• ✅ No more trimming warnings when registering and resolving services
• ⚠️ Only exception: Lazy registrations still require the attribute (due to framework limitations)

Before (you had to do this):

public void RegisterServices(
  [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
  Type serviceType)
{
  AppLocator.RegisterLazySingleton(() => Activator.CreateInstance(serviceType));
}

Now (clean and simple):

public void RegisterServices<T>() where T : class, new()
{
  AppLocator.RegisterLazySingleton<T>(() => new T());
}

3. Improved Test Isolation

We've enhanced our test infrastructure with proper scope isolation to prevent state leakage between tests, particularly for:

• Log4Net logger tests (fixed global repository state issues)
• Locator tests (proper InternalLocatorScope usage)

This doesn't affect you directly, but ensures higher quality and more reliable releases.

Breaking Changes

Container Swap

The internal dependency resolver implementation has changed. If you're using the public AppLocator API as documented, you should see no breaking changes.

Potential issues only if you:

• Directly instantiated ModernDependencyResolver (now use InstanceGenericFirstDependencyResolver)
• Relied on specific internal resolver behaviors

Migration Guide

For most users: No changes needed - the public API remains the same.

If you were using internal APIs:

• Replace new ModernDependencyResolver() with new InstanceGenericFirstDependencyResolver()
• Review and remove unnecessary [DynamicallyAccessedMembers] attributes from your code
• Use the new generic DI methods, they are first class citizens now.

Benefits

• Faster - Improved performance across the board
• Cleaner - Less boilerplate trimming attributes
• AOT-Ready - True Native AOT support without warnings
• More Reliable - Better test coverage and isolation

Benchmark Results

See the updated README for detailed benchmark comparisons showing performance improvements in:

• Service registration
• Service resolution
• Memory allocation