[MartinZikmund]

What

Uno.Core.Extensions.Logging.Singleton is referenced by Uno.WinUI, so its dependency on CommonServiceLocator ends up shipping CommonServiceLocator.dll inside every Uno application. This PR removes that dependency by swapping the service locator lookup for System.IServiceProvider.

Why

Two reasons, one legal and one architectural.

Licensing. CommonServiceLocator is licensed under the MS-PL, which the FSF classifies as incompatible with the GPL. Every GPL/AGPL-licensed Uno app currently redistributes an assembly it cannot relicense under its own terms. This came up while producing third-party licence notices for an AGPL-licensed Uno app — it is the only non-permissive licence in the entire shipped dependency graph.

Age. The package is Microsoft.Practices.ServiceLocation, copyright Microsoft 2008 — the patterns & practices service locator, predating Microsoft.Extensions.DependencyInjection.

Verified it genuinely ships (not a dev-time dependency): CommonServiceLocator.dll is copied to the output for net10.0-desktop, net10.0-windows10.0.26100 (including AppX/) and net10.0-android in a stock Uno app.

How

The entire dependency was one optional lookup in GetFactory():

if (ServiceLocator.IsLocationProviderSet)
{
    var service = ServiceLocator.Current.GetService(typeof(ILoggerFactory));

Replaced with System.IServiceProvider — in the BCL on every target framework here, and the abstraction Microsoft.Extensions.DependencyInjection already implements. No new package reference, and nothing reflective (so no trimming or AOT cost).

• Adds LogExtensionPoint.ServiceProvider, an optional IServiceProvider used to resolve the ambient ILoggerFactory on first use
• GetFactory() resolves through it, keeping the existing fallback to a default LoggerFactory
• Exception behaviour preserved exactly: NullReferenceException and InvalidOperationException fall back to a default factory, anything else still propagates — now expressed as an exception filter instead of catch-and-rethrow
• Drops the CommonServiceLocator PackageReference

Breaking change

Consumers that supplied an ILoggerFactory via ServiceLocator.SetLocatorProvider(...) must now assign LogExtensionPoint.ServiceProvider instead:

// before
ServiceLocator.SetLocatorProvider(() => myLocator);

// after
LogExtensionPoint.ServiceProvider = myServiceProvider;

Consumers that never set a locator provider — every app using Microsoft.Extensions.DependencyInjection — are unaffected, since that path already fell through to new LoggerFactory().

Scope

Deliberately limited to Uno.Core.Extensions.Logging.Singleton, the only app-shipped package that referenced CommonServiceLocator (Collections, Disposables, Equality and Logging never did).

Uno.Core.Extensions.Compatibility keeps its reference: it exposes IServiceLocator in its public API by design (IServiceLocatorProvider, ServiceLocatorProviderExtensions), and it is not shipped as part of Uno applications. Removing it there would be a much larger API break for no redistribution benefit — happy to follow up separately if you'd like it gone repo-wide.

Testing

The replaced branch had no test coverage. Added 5 tests to LogExtensionPointTests covering resolution from a stub provider, both fallback paths, exception propagation, and the property round-trip.

dotnet test Uno.Core.Tests — 267 passed, 1 failed, 2 skipped.

The single failure is pre-existing and unrelated: ValidationHelperFixture.CurrencyValidation asserts IsCurrency("1 121,2", fr-fr) using a plain space (U+0020), but ICU on modern Windows returns U+202F (narrow no-break space) as the fr-FR group separator. It touches no logging code. Happy to file that separately.

🤖 Generated with Claude Code

https://claude.ai/code/session_01XD6CXamcmygU1ErZvjfc9v

[Copilot]

🟡 Changes recommended

The PR description does not include a required linked GitHub issue, and the reported dotnet test Uno.Core.Tests run indicates a failing test that should be addressed before merging.

Once you've addressed the issues Copilot identified, you can request another Copilot review.

Pull request overview

This PR removes the runtime dependency on CommonServiceLocator from Uno.Core.Extensions.Logging.Singleton by switching the ambient ILoggerFactory lookup to an optional System.IServiceProvider, avoiding shipping CommonServiceLocator.dll in downstream Uno apps and reducing licensing risk.

Changes:

• Removed the CommonServiceLocator package reference and ServiceLocator usage from LogExtensionPoint.
• Added LogExtensionPoint.ServiceProvider for optional first-use resolution of ILoggerFactory, preserving the existing fallback behavior to a default LoggerFactory.
• Added unit tests covering service-provider resolution, fallback paths, and exception behavior.

File summaries

File	Description
src/Uno.Core.Extensions.Logging.Singleton/LogExtensionPoint.cs	Replaces service-locator-based factory resolution with an optional IServiceProvider and retains fallback logic.
src/Uno.Core.Extensions.Logging.Singleton/Uno.Core.Extensions.Logging.Singleton.csproj	Drops the CommonServiceLocator package reference so it no longer ships transitively.
src/Uno.Core.Tests/LogExtensionPointTests.cs	Adds tests validating ServiceProvider behavior, default fallback, and exception propagation.

Review details

• Files reviewed: 3/3 changed files
• Comments generated: 0
• Review effort level: Lite

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[MartinZikmund]

/azp run

[azure-pipelines]

Azure Pipelines successfully started running 1 pipeline(s).

[mergify]

Tick the box to add this pull request to the merge queue (same as @mergifyio queue).

• Queue this pull request

[morning4coffe-dev]

Reviewed at df01d38.

The IServiceProvider substitution is scoped to Logging.Singleton and preserves optional first-use resolution, cached-factory behavior, the existing interceptor path, and the expected fallback/exception-propagation policy. The Compatibility package retains its legacy locator contracts, and the breaking configuration migration is explicitly documented.

No blocking findings.