Required parameters to blazor components

[montyclt]

Is your feature request related to a problem? Please describe.

I'm building a component where optional parameter doesn't make sense.

Describe the solution you'd like

Add required parameter to Parameter attribute

[Parameter(required = true)]
protected string Name { get; set; }

[Andrzej-W]

This is an old idea. It was moved from original Blazor repository to this #5455. Unfortunately it is now closed.

[montyclt]

Thank you @Andrzej-W. I close it as duplicate.

[Andrzej-W]

@montyclt Maybe you shouldn't close. As I wrote above issue #5455 was closed a few months ago but I'm afraid [Parameter(required = true)] hasn't been implemented yet and I cannot find any other tracking item for this.

[rynowak]

Reopening this. We do plan to do a feature like this but it won't happen in 3.0.

[mikewodarczyk]

The implementation of this may need to mix with the #nullable variable feature in c# 8. The null checks will flag [Parameter(required = true)] protected T myVar {get; set;} as uninitialized, but in fact this attribute is saying that the variable must be initialized; but it is initialized elsewhere.

[danroth27]

Clearing the milestone as I'd like to consider this for 5.0 now that we have a bunch of components that have required parameters.

[buddyfavors]

This could have came in handy for me too, for now I just wrapped the property.

        [Parameter]
        public string MessageText
        {
            get => _MessageText ?? throw new NotImplementedException();
            set => _MessageText = value;
        }

        private string _MessageText { get; set; }

[kattunga]

Is not possible to add this to 3.1?
now we to set #nullable disable in each params section to disable nullable warnings.

[ZimM-LostPolygon]

now we to set #nullable disable in each params section to disable nullable warnings.
@kattunga

Use null! instead, much more nice:

    [Parameter]
    public UserEditViewModel UserEdit { get; set; } = null!;

[chucker]

Use null! instead, much more nice:

That works, but it really just tells the compiler to ignore the problem.

It'd be nicer if we can have the compiler surface the problem on the component consumer's end:

<MyComponent /> <!-- compiler warning: UserEdit isn't set -->
<MyComponent UserEdit="@foo" /> <!-- no warning! -->

[JvanderStad]

I have solved this in a basic way with the following extension method during runtime:

#nullable enable

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;
using FluentAssertions.Common;
using Microsoft.AspNetCore.Components;

namespace Blazor
{
	public static class ComponentExtension
	{
		public record ParameterInfo(PropertyInfo PropertyInfo, bool IsRequired);
		private static readonly ConcurrentDictionary<Type, ParameterInfo[]> _typeInfo = new();

		/// <summary>
		/// Validate parameters
		/// </summary>
		/// <param name="component"></param>
		public static void ValidateParameters(this IComponent component)
		{
#if DEBUG
			var componentType = component.GetType();
			if (!_typeInfo.TryGetValue(componentType, out var parameterInfo))
			{
				var props = componentType
					.GetProperties()
					.Where(x => x.IsDecoratedWith<ParameterAttribute>());

				var list = new List<ParameterInfo>();
				foreach (var prop in props)
				{
					list.Add(new ParameterInfo(prop, prop.GetCustomAttribute<RequiredAttribute>() != null));
				}

				_typeInfo[component.GetType()] = parameterInfo = list.ToArray();
			}

			foreach (var property in parameterInfo.Where(x=>x.IsRequired) )
			{
				var value = property.PropertyInfo.GetValue(component);
				if (value == null)
					throw new ArgumentNullException(property.PropertyInfo.Name);

				switch (property.PropertyInfo.PropertyType)
				{
					case Type t when t == typeof(Guid):
					{
						if ((Guid)value == default)
							throw new ArgumentNullException(property.PropertyInfo.Name);

						break;
					}
				}
			}
#endif
		}
	}
}

In every component where I want to have validation I call this method

[Parameter] [Required] public Guid Id { get; set; } = default!;
protected override void OnInitialized()
{
	this.ValidateParameters();
}

[mrpmorris]

@JvanderStad the issue isn't checking in the component at runtime, but checking in the consumer at compile time.

[JvanderStad]

@JvanderStad the issue isn't checking in the component at runtime, but checking in the consumer at compile time.

I'm aware of this, but it's better than nothing. I'm just sharing what works for me right now.
With a little luck the compile-time version will use the same attribute.

[stefanloerwald]

Solving it at compile time has been possible (and stable) for many months now (see above comments). No need to work with runtime-only. The only real question is whether this should be a separate attribute ([Required][Parameter] public T Value {get;set;}) or as part of the Parameter attribute ([Parameter(required=true)] public T Value {get;set;}).

[JvanderStad]

Didn't see that. Ah wel ¯_(ツ)_/¯

[mikewodarczyk]

The only real question is whether this should be a separate attribute ([Required][Parameter] public T Value {get;set;}) or as part of the Parameter attribute ([Parameter(required=true)] public T Value {get;set;}).

Would one ever use a [Required] attribute without a [Parameter] attribute? I don't think so. Based on that, it seems like the [Parameter(required=true)] makes more sense. The "required" modifies the "Parameter" attribute, but is not an attribute on its own.

[stefanloerwald]

I'm not in the position to make that decision, nor do I have a strong preference either way. But there is a reason for a separate attribute, and that is precedent and existing code: RequiredAttribute (System.ComponentModel.DataAnnotations) https://docs.microsoft.com/en-us/dotnet/api/system.componentmodel.dataannotations.requiredattribute?view=net-5.0

[mrpmorris]

One attribute = fewer reflection calls

[stefanloerwald]

At compile time, there's no concern about reflection. It doesn't matter to a source generator whether there are one or two attributes.

[Dalqin]

What precedent is there? In data annotations, [Required] is independent; it doesn't rely on any other attribute to define its usefulness.
In this case, [Required] would only mean something if [Parameter] is present, yeah?

[montyclt]

I think using [Required] could be confusing because [Required] is used by some components like EditForm in other properties. I vote for using [Parameter(Required = true)].