microsoft/aspire · error · ArgumentException

Object must implement IManifestExpressionProvider

Error message

Object must implement IManifestExpressionProvider

What it means

AppendValueProvider requires its argument to implement both IValueProvider and IManifestExpressionProvider. This second check throws when the object (after unwrapping IResourceBuilder) implements IValueProvider but not IManifestExpressionProvider, so its value could be resolved at run time but has no stable expression for the published manifest. An ArgumentException naming 'valueProvider' is thrown.

Solutions

Add IManifestExpressionProvider to the custom type and return a stable '{resource}.value' style expression from ManifestExpression.
Pass a built-in resource type (parameter, connection string, endpoint-as-expression) that already implements both interfaces.
If only the literal/resolved value is needed, append the value as a string or use ReferenceExpression.Create with a supported provider instead.
Verify the object isn't an IResourceBuilder wrapping a resource that lacks IManifestExpressionProvider; unwrap and check the resource's interfaces.

Example fix

// before
class MyValueSource : IValueProvider
{
    public ValueTask<string?> GetValueAsync(...) => ...; // no IManifestExpressionProvider
}

// after
class MyValueSource : IValueProvider, IManifestExpressionProvider
{
    public ValueTask<string?> GetValueAsync(...) => ...;
    public ManifestExpression ManifestExpression => new("{myValueSource.value}");
}

Defensive patterns

Strategy: type-guard

Type guard

static bool HasManifestSupport(object? v) =>
    (v is IResourceBuilder<IResource> rb ? rb.Resource : v) is IManifestExpressionProvider;
// require both: is IValueProvider and IManifestExpressionProvider

Try / catch

try
{
    builder.AppendValueProvider(provider);
}
catch (ArgumentException ex) when (ex.ParamName == "valueProvider")
{
    // type lacks IManifestExpressionProvider; fall back or fix the provider type
}

Prevention

Pair IValueProvider with IManifestExpressionProvider on every custom value source.
Prefer built-in resource types whose manifest support is guaranteed.
Run a publish/manifest generation step in tests to catch missing manifest support early.

When it happens

Trigger: Calling AppendValueProvider (directly or via AppendFormatted in ReferenceExpression.Create interpolation) with a custom class that implements IValueProvider (or IValueProvider via IResourceBuilder) but omits IManifestExpressionProvider, so publishing manifests cannot render its placeholder.

Common situations: Hand-written custom resource value providers that implement only the runtime-resolution interface; types copied from older Aspire samples before IManifestExpressionProvider became required; passing an endpoint reference or custom annotation object that resolves values but doesn't participate in manifest generation.

Understand the failure class

Background: "Must be a positive integer", "Invalid value", "Unsupported": the invalid-argument-value error family, when a library rejects the value you pass — this error's family across 35 libraries.

Related errors

AI-assisted analysis of microsoft/aspire@25830f84bd (2026-09-16). Data as JSON: /api/errors/c6cc4c1c348d5a3c. Report an issue: GitHub.

Appendix: source

Thrown at src/Aspire.Hosting/ApplicationModel/ReferenceExpression.cs:604

    /// </summary>
    /// <ats-summary>Appends a value provider to the reference expression</ats-summary>
    /// <param name="valueProvider">An object that implements both interfaces, or an IResourceBuilder wrapping such an object.</param>
    /// <ats-param name="valueProvider">The value provider to append.</ats-param>
    /// <param name="format">Optional format specifier.</param>
    /// <exception cref="ArgumentException">Thrown if the object doesn't implement the required interfaces.</exception>
    [AspireExport]
    public void AppendValueProvider(object valueProvider, string? format = null)
    {
        // Unwrap IResourceBuilder<T> to get the underlying resource (covariant interface)
        var unwrapped = valueProvider is IResourceBuilder<IResource> rb ? rb.Resource : valueProvider;

        if (unwrapped is not IValueProvider vp)
        {
            throw new ArgumentException($"Object must implement IValueProvider", nameof(valueProvider));
        }
        if (unwrapped is not IManifestExpressionProvider mep)
        {
            throw new ArgumentException($"Object must implement IManifestExpressionProvider", nameof(valueProvider));
        }

        var index = _valueProviders.Count;
        _builder.Append(CultureInfo.InvariantCulture, $"{{{index}}}");

        _valueProviders.Add(vp);
        _manifestExpressions.Add(mep.ValueExpression);
        _stringFormats.Add(format);
    }

    /// <summary>
    /// Builds the <see cref="ReferenceExpression"/>.
    /// </summary>
    /// <ats-summary>Builds the reference expression</ats-summary>
    [AspireExport]
    public ReferenceExpression Build() =>
        ReferenceExpression.Create(_builder.ToString(), [.. _valueProviders], [.. _manifestExpressions], [.. _stringFormats]);

View on GitHub (pinned to 25830f84bd)