WinUI 3 Class Library Dependency Injection

WinUI controls (user controls, pages etc) are expected to have a parameterless constructor.

The standard way to use DI in the UI side (user controls, pages, windows) etc. is to initialize the dependencies via static access to the service provider (see this example).

This boils down to WinUI's Frame.Navigate(Type sourcePageType, object parameter) which doesn't natively support the standard MS DI.
This feature has been requested here, please vote!).

However there are a few solutions, one of them mentioned in this comment - WinUI.DependencyInjection.

Another option is to create an additional constructor that takes all dependencies and delegate the parameterless constructor to it (I'm not sure but a private constructor is maybe supported by WinUI):

public class MyUserControl
{
    public MyUserControl() // check if private works
        this(App.GetService<IMyServiceA>(), App.GetService<IMyServiceB>())
    {
    }    

    public MyUserControl(IMyServiceA serviceA, IMyServiceB serviceB)
    {
    }
}

public partial App : Application
{
    public IHost Host { get; }

    public static T GetService<T>() where T : notnull =>
        ((App)Current).Host.Services.GetRequiredService<T>();
}

This is at least helpful in organizing the initialization stuff in one spot instead of scattering them around through the file. In addition enables you in easily mocking and substituting those dependencies in your tests.

IMHO, your user controls shouldn't depend directly on DataAccessUtil. Instead, expose relevant properties as DependencyProperty, and inject services, which can access DataAccessUtil, into view models.

The sample code below uses the CommunityToolkit.Mvvm NuGet package for MVVM but should help clarify what I mean.

AwesomeUserControl

<UserControl
    x:Class="WinUIDemoApp.AwesomeUserControl"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:local="using:WinUIDemoApp"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">
    <Grid>
        <ComboBox x:Name="AwesomeComboBox" ItemsSource="{x:Bind ComboBoxOptions, Mode=OneWay}" />
    </Grid>
</UserControl>

using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;

namespace WinUIDemoApp;

public sealed partial class AwesomeUserControl : UserControl
{
    public static readonly DependencyProperty ComboBoxOptionsProperty =
        DependencyProperty.Register(
            nameof(ComboBoxOptions),
            typeof(object),
            typeof(AwesomeUserControl),
            new PropertyMetadata(default));

    public AwesomeUserControl()
    {
        InitializeComponent();
    }

    public object ComboBoxOptions
    {
        get => (object)GetValue(ComboBoxOptionsProperty);
        set => SetValue(ComboBoxOptionsProperty, value);
    }
}

ComboBoxOptionsService

public interface IComboBoxOptionsService
{
    string[] GetComboBoxOptions();
}

public class ComboBoxOptionsService : IComboBoxOptionsService
{
    public string[] GetComboBoxOptions()
    {
        // Replace this demo code with options from DataAccessUtil.
        int item1 = Random.Shared.Next(0, 10);
        return
        [
            $"Option {item1}",
            $"Option {item1 + 1}",
            $"Option {item1 + 2}",
        ];
    }
}

AwesomeViewModel

public partial class ShellViewModel : ObservableObject
{
    private readonly IComboBoxOptionsService _comboBoxOptionsService;

    public ShellViewModel(IComboBoxOptionsService comboBoxOptionsService)
    {
        this._comboBoxOptionsService = comboBoxOptionsService;
        ComboBoxOptions = _comboBoxOptionsService.GetComboBoxOptions();
    }

    [ObservableProperty]
    public partial string[] ComboBoxOptions { get; set; }
}

AwesomePage

<local:AwesomeUserControl ComboBoxOptions="{x:Bind ViewModel.ComboBoxOptions, Mode=OneWay}" />

public sealed partial class Shell : Page
{
    public Shell()
    {
        InitializeComponent();
    }

    public AwesomeViewModel ViewModel { get; } = App.GetService<AwesomeViewModel>();
}