Adding public properties to ColumnHeaderAttribute, ColumnOrderAttribute, etc.

[jonsagara]

Hi,

Would it be possible to add public properties to the various attributes to capture their constructor arguments?

My use case is that, on app initialization, I generate a list of column names from properties on my row model, and having easy access to the constructor values would be tremendously helpful instead of having to use reflection to look at the constructor arguments. Similarly, I'd like to have easy access to column ordering info.

An example would be:

/// <summary>
/// Instructs the SpreadCheetah source generator about what header name to use for a column.
/// The source generator creates columns from properties, and using the attribute on a property will set the header name for the resulting column.
/// Header names are written to a worksheet with <see cref="Spreadsheet.AddHeaderRowAsync"/>.
/// </summary>
[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
public sealed class ColumnHeaderAttribute : Attribute
{
	/// <summary>
	/// Returns the name from the first constructor.
	/// </summary>
	public string? Name { get; }
	
	/// <summary>
	/// Use the value of <c>name</c> as the header name for the column.
	/// </summary>
	public ColumnHeaderAttribute(string name)
	{
		Name = name;
	}


	/// <summary>
	/// Returns the type from the second constructor.
	/// </summary>
	public Type? Type { get; }

	/// <summary>
	/// Returns the propertyName from the second constructor.
	/// </summary>
	public string? PropertyName { get; }

	/// <summary>
	/// Get the header name from a property. The property must:
	/// <list type="bullet">
	///   <item><description>Be a <see langword="static"/> property.</description></item>
	///   <item><description>Have a public getter.</description></item>
	///   <item><description>Have a return type of <see langword="string"/> (or <see langword="string?"/>).</description></item>
	/// </list>
	/// </summary>
	public ColumnHeaderAttribute(Type type, string propertyName)
	{
		Type = type;
		PropertyName = propertyName;
	}
}

Thanks!

[sveinungf]

Hi,

Sure, that should be easy enough to add. But you would still have to use reflection to read the properties, no?

[jonsagara]

Yep, that's correct, it would still require reflection, but the calling code would be slightly simpler:

(Please forgive any errors in this pseudocode, as I typed it out quickly in LINQPad before running out the door.)

void Main()
{
	var personModelType = typeof(PersonModel);
	
	foreach (var (ixProperty, property) in personModelType.GetProperties(BindingFlags.Public | BindingFlags.Instance).Index())
	{
		//
		// Instead of this:
		//

		var customAttrsData = property.GetCustomAttributesData();
		var columnHeaderAttrData = customAttrsData.SingleOrDefault(cad => cad.AttributeType == typeof(ColumnHeaderAttribute));
		
		string columnName = "";
		
		if (columnHeaderAttrData is not null)
		{
			if (columnHeaderAttrData.ConstructorArguments is [{ Value: string name }])
			{
				// Declared as [ColumnHeader("Age")]. Use the name argument value, or, if null, default to the property name.
				columnName = name ?? property.Name;
			}
			else if (columnHeaderAttrData.ConstructorArguments is [{ Value: Type } type, { Value: string } propertyName])
			{
				// Declared as [ColumnHeader(typeof(MyResourceFile), nameof(MyResourceFile.AgeColumnName))]. Invoke the static
				//   string getter to retrieve the resource value. Default to the property name if null.
				columnName = GetColumnNameFromResourceFile(type, propertyName) ?? property.Name;
			}
			else
			{
				throw new NotSupportedException($"{personModelType.FullName}'s property {property.Name} has a {nameof(ColumnHeaderAttribute)} declared with unknown number of constructor parameters {columnHeaderAttrData.ConstructorArguments.Count}.");
			}
		}
		
		
		//
		// We could have this:
		//
		
		var columnHeaderAttr = property.GetCustomAttribute<ColumnHeaderAttribute>();
		string columnName2 = "";
		
		if (columnHeaderAttr?.Name is not null)
		{
			// Declared as [ColumnHeader("Age")]. Use the name argument value, or, if null, default to the property name.
			columnName2 = columnHeaderAttr.Name ?? property.Name;
		}
		else if (columnHeaderAttr?.Type is not null && columnHeaderAttr?.PropertyName is not null)
		{
			// Declared as [ColumnHeader(typeof(MyResourceFile), nameof(MyResourceFile.AgeColumnName))]. Invoke the static
			//   string getter to retrieve the resource value. Default to the property name if null.			
			columnName2 = GetColumnNameFromResourceFile2(columnHeaderAttr.Type, columnHeaderAttr.PropertyName) ?? property.Name;
		}
	}
}

private static string? GetColumnNameFromResourceFile(CustomAttributeTypedArgument type, CustomAttributeTypedArgument propertyName)
{
	if (type.Value is null)
	{
		throw new ArgumentNullException($"When using {nameof(ColumnHeaderAttribute)} to retrieve the column name from a resource file, you must provide the Type of the resource file.");
	}

	// Ensure the caller has correctly declared the ColumnHeaderAttribute.
	var propertyNameStr = propertyName.Value?.ToString();

	if (string.IsNullOrWhiteSpace(propertyNameStr))
	{
		throw new InvalidOperationException($"When using {nameof(ColumnHeaderAttribute)} to retrieve the column name from a resource file, you must provide a non-null, non-white space propertyName.");
	}

	var resourceFileType = (Type)type.Value;
	var resourceFileProperty = resourceFileType.GetProperty(propertyNameStr, BindingFlags.Public | BindingFlags.Static);

	if (resourceFileProperty is null)
	{
		throw new InvalidOperationException($"Unable to find a public, static property named {propertyNameStr} on the {resourceFileType.Name} resource file to use as a column name.");
	}

	// Resx file properties are string, but not string?
	if (resourceFileProperty.PropertyType != typeof(string))
	{
		throw new InvalidOperationException($"The public, static property named {propertyNameStr} on the {resourceFileType.Name} resource file must be of type {typeof(string).FullName}; it is a {resourceFileProperty.PropertyType.FullName}.");
	}

	return (string?)resourceFileProperty.GetValue(obj: null, index: null);
}

private static string? GetColumnNameFromResourceFile2(Type resourceFileType, string resourcePropertyName)
{
	var resourceFileProperty = resourceFileType.GetProperty(resourcePropertyName, BindingFlags.Public | BindingFlags.Static);
	if (resourceFileProperty is null)
	{
		throw new InvalidOperationException($"Unable to find a public, static property named {resourcePropertyName} on the {resourceFileType.Name} resource file to use as a column name.");
	}

	// Resx file properties are string, but not string?
	if (resourceFileProperty.PropertyType != typeof(string))
	{
		throw new InvalidOperationException($"The public, static property named {resourcePropertyName} on the {resourceFileType.Name} resource file must be of type {typeof(string).FullName}; it is a {resourceFileType.FullName}.");
	}
	
	return (string?)resourceFileProperty.GetValue(obj: null, index: null);
}


public class PersonModel
{
	[ColumnHeader("First Name")]
	public string FirstName { get; set; } = null!;
	
	[ColumnHeader("Age In Years")]
	public int Age { get; set; }
}

But I concede that it's not a monumental savings, and since I already have it working, it falls squarely in the "nice to have" camp.

If we can have it, great -- I can even submit a pull request --, and if not, no worries.

I love the library, especially the source generator stuff. Nice work, and thank you for putting it out there.

[sveinungf]

Thanks for the feedback!

I agree, this would go in the "nice to have" camp. But it's also so simple to support so I don't see why not. I think it would make sense to use nullable types for the properties of all the attributes, even for the attributes that only have a single constructor. The reason is just to avoid potential problems later, if the attributes would get additional constructors in the future.

I won't have much time to work on the project for the next couple of weeks, but after that I can look into it. PRs are also welcome :)

[jonsagara]

Adding the properties to the attribute classes caused the public API to change, and now those tests are failing. I have never used PublicApiGenerator before. Is there a specific command I should use to regenerate the "verified" public API text file?

ETA: Nevermind, I think I got it.