Recurring "No parameterless constructor" errors after package updates across various CommunityToolkit.Maui components #2669
-
|
Hello Community Toolkit team, I'm consistently encountering compatibility issues when updating packages in my .NET MAUI applications that use CommunityToolkit.Maui. The error message typically appears as: This issue isn't isolated to one specific control - I've experienced it with different components at different times, including:
The pattern seems to be:
Questions:
Workarounds I've found:
This recurring issue creates significant friction during maintenance and updates. Any guidance or improvements to make version transitions smoother would be greatly appreciated. Environment:
Thank you for your work on this excellent toolkit! |
Beta Was this translation helpful? Give feedback.
Replies: 4 comments 18 replies
-
|
To help me understand this a little better from your section "the pattern seems to be" are you only updating one of the items? I suspect this comes back to manifests and specific TFMs. We saw this issue a lot when .NET 9 preview came out. Do you also have a global.json file that states which .NET version to be using and whether you can use newer versions? |
Beta Was this translation helpful? Give feedback.
-
|
Thank you for your response and additional details. Let me clarify and expand based on your follow-up questions: Regarding the update pattern:
Current environment specifics:
|
Beta Was this translation helpful? Give feedback.
-
|
Sorry I may not have been clear with my first question. You may have answered it elsewhere but I'll elaborate just in case... When you update your nuget packages do you also update MAUI at the same time or are these separate activities? Sadly the MAUI dependency doesn't get shown in Nuget for you to know which version it was built with so we usually recommend upgrading to the latest version of MAUI when you take the latest version of the toolkit. In terms of explicit TFMs, I wasn't actually referring to your codebase but ours. In the past we have see developers report similar issues and a possible solution was for us to explicitly target a TFM (e.g. net9.0-ios18.0) rather than the implicit (e.g. net9.0-iOS). |
Beta Was this translation helpful? Give feedback.
-
|
Thank you. 1. Package Update Practice:
2. TFM Implementation Status:
Critical Findings:
Would you like me to test any specific version combinations or provide additional environment details? |
Beta Was this translation helpful? Give feedback.
-
On the topic of DI registration - there is no use of DI around things like converters. You are seeing this when XAML is loaded which isn't DI. What might be helpful is to try and decompile the built libraries in the obj folder to see what is actually inside of the toolkit DLL on your system. Also to double check (I haven't checked) is that version of MAUI compatible with that version of Xcode? |
Beta Was this translation helpful? Give feedback.
-
|
I'm currently encountering parameterless constructor exceptions in my .NET MAUI project under the following versions:
However, the same project works fine when I upgrade to:
Environment
|
Beta Was this translation helpful? Give feedback.
-
|
Also many other peoples i think facing same issues when they are upgrading their packages. do i also need to move my converters to backend of page instead xaml? |
Beta Was this translation helpful? Give feedback.
-
|
You're right — even with versions like 9.1.1 and 11.2.0, you still need to match them with specific .NET MAUI versions, otherwise issues can still occur. I tried 9.1.1 myself and faced the same problem, and based on the internals dependency, I believe 11.2.0 will also break unless used with a matching MAUI version. This compatibility issue is definitely frustrating, and until the Toolkit removes its dependency on MAUI internals (which they’re aiming for in .NET 10), we’ll need to be very careful about version alignment. Hopefully things will stabilize soon with future releases. |
Beta Was this translation helpful? Give feedback.
-
|
Thanks both. Surely it shouldn't keep breaking unless the MAUI team keep changing things? The way I see it the MAUI version should be lower than the breaking change until we compiled the toolkit against the breaking version? @jfversluis do you know which workload version this breaking internal change shipped? |
Beta Was this translation helpful? Give feedback.
-
|
I was comparing the decompiled code (via Rider) between a working converter class and a non-working one, and I noticed something interesting — The non-working version has a private constructor, while the working one doesn’t (it’s either protected or public). This might be the reason behind the "no parameterless constructor" issue we're getting. Since classes initialized from XAML or through reflection need to have at least a protected or public parameterless constructor, having it marked as If this is indeed the cause, we’ll need to:
Let me know what you think — I can help start identifying and fixing the impacted ones if this sounds like the root cause. Also attaching working class code in next comment so you also identify difference between that. |
Beta Was this translation helpful? Give feedback.
-
|
I might be repeating myself here but I somehow missed this thread. I don't think this is the issue as the private constructor is in the base class and not the subclass (e.g. From what Gerald has highlighted it sounds like we have a toolkit version which is compatible with a maximum MAUI version and then with the next MAUI version the next toolkit version becomes compatible. I haven't worked out what these versions are yet but I'll try and see if I can work it out this week and then somehow confirm it. |
Beta Was this translation helpful? Give feedback.
-
|
Yes you're right, it's not an case. yes also i think Gerald is right at this point. |
Beta Was this translation helpful? Give feedback.
-
|
here you can find my stack trace: 2025-05-26 11:46:58.476 [2478:841756] Unhandled managed exception: Position 15:14. No parameterless constructor defined for type 'CommunityToolkit.Maui.Converters.InvertedBoolConverter'. (Microsoft.Maui.Controls.Xaml.XamlParseException) |
Beta Was this translation helpful? Give feedback.
-
|
When it is broken like this are you able to find the CommunityToolkit.Maui.dll file from the obj folder? If we can decompile that it may help to understand what is wrong |
Beta Was this translation helpful? Give feedback.
-
|
When initializing the page's components, I encountered this issue. <toolkit:InvertedBoolConverter x:Key="InvertedBoolConverter" x:Name="InvertedBoolConverter" />I'm attaching the For reference, here's the decompiled constructor code from Rider: using System.Globalization;
namespace CommunityToolkit.Maui.Converters;
/// <summary>
/// Converts true to false and false to true
/// </summary>
[AcceptEmptyServiceProvider]
public partial class InvertedBoolConverter : BaseConverter<bool, bool>
{
/// <inheritdoc/>
public override bool DefaultConvertReturnValue { get; set; } = false;
/// <inheritdoc />
public override bool DefaultConvertBackReturnValue { get; set; } = false;
/// <summary>
/// Converts a <see cref="bool"/> to its inverse value.
/// </summary>
/// <param name="value">The value to convert.</param>
/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
/// <returns>An inverted <see cref="bool"/> from the one coming in.</returns>
public override bool ConvertFrom(bool value, CultureInfo? culture = null) => !value;
/// <summary>
/// Converts a <see cref="bool"/> to its inverse value.
/// </summary>
/// <param name="value">The value to convert.</param>
/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
/// <returns>An inverted <see cref="bool"/> from the one coming in.</returns>
public override bool ConvertBackTo(bool value, CultureInfo? culture = null) => !value;
}using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using CommunityToolkit.Maui.Extensions;
namespace CommunityToolkit.Maui.Converters;
/// <summary>
/// Abstract class used to implement converters that implement the ConvertBack logic.
/// </summary>
/// <typeparam name="TFrom">Type of the input value.</typeparam>
/// <typeparam name="TTo">Type of the output value.</typeparam>
/// <typeparam name="TParam">Type of parameter</typeparam>
public abstract class BaseConverter<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TFrom, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TTo, TParam> : ValueConverterExtension, ICommunityToolkitValueConverter
{
private protected BaseConverter()
{
}
/// <summary>
/// Default value to return when <see cref="IValueConverter.Convert(object?, Type, object?, CultureInfo?)"/> throws an <see cref="Exception"/>.
/// This value is used when <see cref="Maui.Options.ShouldSuppressExceptionsInConverters"/> is set to <see langword="true"/>.
/// </summary>
public abstract TTo DefaultConvertReturnValue { get; set; }
/// <summary>
/// Default value to return when <see cref="IValueConverter.ConvertBack(object?, Type, object?, CultureInfo?)"/> throws an <see cref="Exception"/>.
/// This value is used when <see cref="Maui.Options.ShouldSuppressExceptionsInConverters"/> is set to <see langword="true"/>.
/// </summary>
public abstract TFrom DefaultConvertBackReturnValue { get; set; }
/// <inheritdoc/>
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
public Type FromType { get; } = typeof(TFrom);
/// <inheritdoc/>
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
public Type ToType { get; } = typeof(TTo);
/// <summary>
/// Type of TParam
/// </summary>
public Type ParamType { get; } = typeof(TParam);
object? ICommunityToolkitValueConverter.DefaultConvertReturnValue => DefaultConvertReturnValue;
object? ICommunityToolkitValueConverter.DefaultConvertBackReturnValue => DefaultConvertBackReturnValue;
/// <summary>
/// Method that will be called by <see cref="IValueConverter.Convert(object?, Type, object?, CultureInfo?)"/>.
/// </summary>
/// <param name="value">The object to convert <typeparamref name="TFrom"/> to <typeparamref name="TTo"/>.</param>
/// <param name="parameter">Optional Parameters</param>
/// <param name="culture">Culture Info</param>
/// <returns>An object of type <typeparamref name="TTo"/>.</returns>
public abstract TTo ConvertFrom(TFrom value, TParam parameter, CultureInfo? culture);
/// <summary>
/// Method that will be called by <see cref="IValueConverter.ConvertBack(object?, Type, object?, CultureInfo?)"/>.
/// </summary>
/// <param name="value">Value to be converted from <typeparamref name="TTo"/> to <typeparamref name="TFrom"/>.</param>
/// <param name="parameter">Optional Parameters</param>
/// <param name="culture">Culture Info</param>
/// <returns>An object of type <typeparamref name="TFrom"/>.</returns>
public abstract TFrom ConvertBackTo(TTo value, TParam parameter, CultureInfo? culture);
/// <inheritdoc/>
object? ICommunityToolkitValueConverter.ConvertBack(object? value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type targetType, object? parameter, CultureInfo? culture)
{
try
{
ValidateTargetType<TFrom>(targetType, false);
var converterParameter = ConvertParameter<TParam>(parameter);
var converterValue = ConvertValue<TTo>(value);
return ConvertBackTo(converterValue, converterParameter, culture);
}
catch (Exception ex) when (Options.ShouldSuppressExceptionsInConverters)
{
Trace.TraceInformation("{0}", ex);
return DefaultConvertBackReturnValue;
}
}
/// <inheritdoc/>
object? ICommunityToolkitValueConverter.Convert(object? value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type targetType, object? parameter, CultureInfo? culture)
{
try
{
ValidateTargetType<TTo>(targetType, true);
var converterParameter = ConvertParameter<TParam>(parameter);
var converterValue = ConvertValue<TFrom>(value);
return ConvertFrom(converterValue, converterParameter, culture);
}
catch (Exception ex) when (Options.ShouldSuppressExceptionsInConverters)
{
Trace.TraceInformation("{0}", ex);
return DefaultConvertReturnValue;
}
}
}
/// <summary>
/// Abstract class used to implement converters that implement the ConvertBack logic.
/// </summary>
/// <typeparam name="TFrom">Type of the input value.</typeparam>
/// <typeparam name="TTo">Type of the output value.</typeparam>
public abstract class BaseConverter<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TFrom, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TTo> : ValueConverterExtension, ICommunityToolkitValueConverter
{
private protected BaseConverter()
{
}
/// <summary>
/// Default value to return when <see cref="IValueConverter.Convert(object?, Type, object?, CultureInfo?)"/> throws an <see cref="Exception"/>.
/// This value is used when <see cref="Maui.Options.ShouldSuppressExceptionsInConverters"/> is set to <see langword="true"/>.
/// </summary>
public abstract TTo DefaultConvertReturnValue { get; set; }
/// <summary>
/// Default value to return when <see cref="IValueConverter.ConvertBack(object?, Type, object?, CultureInfo?)"/> throws an <see cref="Exception"/>.
/// This value is used when <see cref="Maui.Options.ShouldSuppressExceptionsInConverters"/> is set to <see langword="true"/>.
/// </summary>
public abstract TFrom DefaultConvertBackReturnValue { get; set; }
/// <inheritdoc/>
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
public Type FromType { get; } = typeof(TFrom);
/// <inheritdoc/>
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
public Type ToType { get; } = typeof(TTo);
object? ICommunityToolkitValueConverter.DefaultConvertReturnValue => DefaultConvertReturnValue;
object? ICommunityToolkitValueConverter.DefaultConvertBackReturnValue => DefaultConvertBackReturnValue;
/// <summary>
/// Method that will be called by <see cref="IValueConverter.Convert(object?, Type, object?, CultureInfo?)"/>.
/// </summary>
/// <param name="value">The object to convert <typeparamref name="TFrom"/> to <typeparamref name="TTo"/>.</param>
/// <param name="culture">Culture Info</param>
/// <returns>An object of type <typeparamref name="TTo"/>.</returns>
public abstract TTo ConvertFrom(TFrom value, CultureInfo? culture);
/// <summary>
/// Method that will be called by <see cref="IValueConverter.ConvertBack(object?, Type, object?, CultureInfo?)"/>.
/// </summary>
/// <param name="value">Value to be converted from <typeparamref name="TTo"/> to <typeparamref name="TFrom"/>.</param>
/// <param name="culture">Culture Info</param>
/// <returns>An object of type <typeparamref name="TFrom"/>.</returns>
public abstract TFrom ConvertBackTo(TTo value, CultureInfo? culture);
/// <inheritdoc/>
object? ICommunityToolkitValueConverter.ConvertBack(object? value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type targetType, object? parameter, CultureInfo? culture)
{
try
{
ValidateTargetType<TFrom>(targetType, false);
var converterValue = ConvertValue<TTo>(value);
return ConvertBackTo(converterValue, culture);
}
catch (Exception ex) when (Options.ShouldSuppressExceptionsInConverters)
{
Trace.TraceInformation("{0}", ex);
return DefaultConvertBackReturnValue;
}
}
/// <inheritdoc/>
object? ICommunityToolkitValueConverter.Convert(object? value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type targetType, object? parameter, CultureInfo? culture)
{
try
{
ValidateTargetType<TTo>(targetType, true);
var converterValue = ConvertValue<TFrom>(value);
return ConvertFrom(converterValue, culture);
}
catch (Exception ex) when (Options.ShouldSuppressExceptionsInConverters)
{
Trace.TraceInformation("{0}", ex);
return DefaultConvertReturnValue;
}
}
}Let me know if this helps or if you need anything else. |
Beta Was this translation helpful? Give feedback.
-
|
Working class : using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using CommunityToolkit.Maui.Extensions;
namespace CommunityToolkit.Maui.Converters;
/// <summary>
/// Abstract class used to implement converters that implement the ConvertBack logic.
/// </summary>
/// <typeparam name="TFrom">Type of the input value.</typeparam>
/// <typeparam name="TTo">Type of the output value.</typeparam>
/// <typeparam name="TParam">Type of parameter</typeparam>
public abstract class BaseConverter<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TFrom, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TTo, TParam> : ValueConverterExtension, ICommunityToolkitValueConverter
{
/// <summary>
/// Default value to return when <see cref="IValueConverter.Convert(object?, Type, object?, CultureInfo?)"/> throws an <see cref="Exception"/>.
/// This value is used when <see cref="Maui.Options.ShouldSuppressExceptionsInConverters"/> is set to <see langword="true"/>.
/// </summary>
public abstract TTo DefaultConvertReturnValue { get; set; }
/// <summary>
/// Default value to return when <see cref="IValueConverter.ConvertBack(object?, Type, object?, CultureInfo?)"/> throws an <see cref="Exception"/>.
/// This value is used when <see cref="Maui.Options.ShouldSuppressExceptionsInConverters"/> is set to <see langword="true"/>.
/// </summary>
public abstract TFrom DefaultConvertBackReturnValue { get; set; }
/// <inheritdoc/>
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
public Type FromType { get; } = typeof(TFrom);
/// <inheritdoc/>
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
public Type ToType { get; } = typeof(TTo);
/// <summary>
/// Type of TParam
/// </summary>
public Type ParamType { get; } = typeof(TParam);
object? ICommunityToolkitValueConverter.DefaultConvertReturnValue => DefaultConvertReturnValue;
object? ICommunityToolkitValueConverter.DefaultConvertBackReturnValue => DefaultConvertBackReturnValue;
/// <summary>
/// Method that will be called by <see cref="IValueConverter.Convert(object?, Type, object?, CultureInfo?)"/>.
/// </summary>
/// <param name="value">The object to convert <typeparamref name="TFrom"/> to <typeparamref name="TTo"/>.</param>
/// <param name="parameter">Optional Parameters</param>
/// <param name="culture">Culture Info</param>
/// <returns>An object of type <typeparamref name="TTo"/>.</returns>
public abstract TTo ConvertFrom(TFrom value, TParam parameter, CultureInfo? culture);
/// <summary>
/// Method that will be called by <see cref="IValueConverter.ConvertBack(object?, Type, object?, CultureInfo?)"/>.
/// </summary>
/// <param name="value">Value to be converted from <typeparamref name="TTo"/> to <typeparamref name="TFrom"/>.</param>
/// <param name="parameter">Optional Parameters</param>
/// <param name="culture">Culture Info</param>
/// <returns>An object of type <typeparamref name="TFrom"/>.</returns>
public abstract TFrom ConvertBackTo(TTo value, TParam parameter, CultureInfo? culture);
/// <inheritdoc/>
object? ICommunityToolkitValueConverter.ConvertBack(object? value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type targetType, object? parameter, CultureInfo? culture)
{
try
{
ValidateTargetType<TFrom>(targetType, false);
var converterParameter = ConvertParameter<TParam>(parameter);
var converterValue = ConvertValue<TTo>(value);
return ConvertBackTo(converterValue, converterParameter, culture);
}
catch (Exception ex) when (Options.ShouldSuppressExceptionsInConverters)
{
Trace.TraceInformation("{0}", ex);
return DefaultConvertBackReturnValue;
}
}
/// <inheritdoc/>
object? ICommunityToolkitValueConverter.Convert(object? value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type targetType, object? parameter, CultureInfo? culture)
{
try
{
ValidateTargetType<TTo>(targetType, true);
var converterParameter = ConvertParameter<TParam>(parameter);
var converterValue = ConvertValue<TFrom>(value);
return ConvertFrom(converterValue, converterParameter, culture);
}
catch (Exception ex) when (Options.ShouldSuppressExceptionsInConverters)
{
Trace.TraceInformation("{0}", ex);
return DefaultConvertReturnValue;
}
}
}
/// <summary>
/// Abstract class used to implement converters that implement the ConvertBack logic.
/// </summary>
/// <typeparam name="TFrom">Type of the input value.</typeparam>
/// <typeparam name="TTo">Type of the output value.</typeparam>
public abstract class BaseConverter<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TFrom, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TTo> : ValueConverterExtension, ICommunityToolkitValueConverter
{
/// <summary>
/// Default value to return when <see cref="IValueConverter.Convert(object?, Type, object?, CultureInfo?)"/> throws an <see cref="Exception"/>.
/// This value is used when <see cref="Maui.Options.ShouldSuppressExceptionsInConverters"/> is set to <see langword="true"/>.
/// </summary>
public abstract TTo DefaultConvertReturnValue { get; set; }
/// <summary>
/// Default value to return when <see cref="IValueConverter.ConvertBack(object?, Type, object?, CultureInfo?)"/> throws an <see cref="Exception"/>.
/// This value is used when <see cref="Maui.Options.ShouldSuppressExceptionsInConverters"/> is set to <see langword="true"/>.
/// </summary>
public abstract TFrom DefaultConvertBackReturnValue { get; set; }
/// <inheritdoc/>
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
public Type FromType { get; } = typeof(TFrom);
/// <inheritdoc/>
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
public Type ToType { get; } = typeof(TTo);
object? ICommunityToolkitValueConverter.DefaultConvertReturnValue => DefaultConvertReturnValue;
object? ICommunityToolkitValueConverter.DefaultConvertBackReturnValue => DefaultConvertBackReturnValue;
/// <summary>
/// Method that will be called by <see cref="IValueConverter.Convert(object?, Type, object?, CultureInfo?)"/>.
/// </summary>
/// <param name="value">The object to convert <typeparamref name="TFrom"/> to <typeparamref name="TTo"/>.</param>
/// <param name="culture">Culture Info</param>
/// <returns>An object of type <typeparamref name="TTo"/>.</returns>
public abstract TTo ConvertFrom(TFrom value, CultureInfo? culture);
/// <summary>
/// Method that will be called by <see cref="IValueConverter.ConvertBack(object?, Type, object?, CultureInfo?)"/>.
/// </summary>
/// <param name="value">Value to be converted from <typeparamref name="TTo"/> to <typeparamref name="TFrom"/>.</param>
/// <param name="culture">Culture Info</param>
/// <returns>An object of type <typeparamref name="TFrom"/>.</returns>
public abstract TFrom ConvertBackTo(TTo value, CultureInfo? culture);
/// <inheritdoc/>
object? ICommunityToolkitValueConverter.ConvertBack(object? value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type targetType, object? parameter, CultureInfo? culture)
{
try
{
ValidateTargetType<TFrom>(targetType, false);
var converterValue = ConvertValue<TTo>(value);
return ConvertBackTo(converterValue, culture);
}
catch (Exception ex) when (Options.ShouldSuppressExceptionsInConverters)
{
Trace.TraceInformation("{0}", ex);
return DefaultConvertBackReturnValue;
}
}
/// <inheritdoc/>
object? ICommunityToolkitValueConverter.Convert(object? value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type targetType, object? parameter, CultureInfo? culture)
{
try
{
ValidateTargetType<TTo>(targetType, true);
var converterValue = ConvertValue<TFrom>(value);
return ConvertFrom(converterValue, culture);
}
catch (Exception ex) when (Options.ShouldSuppressExceptionsInConverters)
{
Trace.TraceInformation("{0}", ex);
return DefaultConvertReturnValue;
}
}
} |
Beta Was this translation helpful? Give feedback.
-
|
That private constructor was removed recently #2573 so it might be that your working version includes that change? The compiler/runtime shouldn't be instantiating the base class though, only the sub class - InvertedBoolConverter |
Beta Was this translation helpful? Give feedback.
-
|
Please follow the For reference, here are the requirements for v11.2.0: https://github.com/CommunityToolkit/Maui/releases/tag/11.2.0 We will continue to post the requirements for each version of .NET MAUI Community Toolkit in the Release Notes for each new version RequirementsThe following tools are now required for CommunityToolkit.Maui:
global.json |
Beta Was this translation helpful? Give feedback.
-
|
The issue I can see here is knowing what the latest .MAUI workload version was at the point in time a release is made. That's the bit I was hoping to workout and document. |
Beta Was this translation helpful? Give feedback.
Please follow the
Requirementssection in the Release Notes of each version ofCommunityToolkit.Maui.For reference, here are the requirements for v11.2.0: https://github.com/CommunityToolkit/Maui/releases/tag/11.2.0
We will continue to post the requirements for each version of .NET MAUI Community Toolkit in the Release Notes for each new version
Requirements
The following tools are now required for CommunityToolkit.Maui: