C# custom extension method that reads properties attributes

I have a class with several different properties of all types, some are int, some ulong, some string and so on, they are pretty basic and just have a default get and set.

I want those properties to have a custom method that returns a specific formatted string, but that format is decided by each property itself (I want to write the format for each property, on the property itself)

The approach I was going to use is to set a custom attribute on each property with the return format, something like this

    class Users {

        [retFormat("You traveled {0:#,0}km")]
        public int Traveled { get; set; }

        [retFormat("This name is #")]
        public string Name { get; set; } 

    }

And then add a extension method to that data type that will read the attribute property and use it to format the return, is that possible?

    public static string ToUseFormat(this int self) {
        return string.Format("{0:#,0}", self);
        // this method has to read the property attribute retFormat and use it
    }

So far my questions are:

1. is this the best way to do it? I do not want to leverage the format to the consumer of the class, I want each property to be able to return both the real value and the formatted value, and possible more than 1 formatted value, like "long text" and "short"

2. How can I read the custom attribute of each property on the method extension?

3. Is there any way to create a method extension for several types, or i have to create it for all the data types I am going to use it for? like int, ulong, string, short, etc...

> And then add a extension method to that data type that will read the attribute property and use it to format the return, is that possible?

No, it is not possible by using method with public static string ToUseFormat(this int self) signature - it will have no good way to determine which exact property from which exact class instance was passed to it, it allows passing literally any integer, hence 42.ToUseFormat(), i.e. even no properties/classes involved.

There are at least 2 possible solutions here:

1. Use expression trees and reflection. Something to get you started (will need a lot of improvement, including null-checks for example):

class Users {

    [RetFormat("You traveled {0:#,0}km")]
    public int Traveled { get; set; }

    [RetFormat("This name is {0}")]
    public string Name { get; set; } 

}

internal class RetFormatAttribute : Attribute
{
    public string Format { get; }

    public RetFormatAttribute(string format)
    {
        Format = format;
    }
}

public static class Exts
{
    public static string GetFormatted<T, TProp>(this T item, Expression<Func<T, TProp>> getter)
    {
        var memberExpression = getter.Body as MemberExpression;
        var retFormatAttribute = memberExpression.Member.GetCustomAttribute<RetFormatAttribute>();
        if (retFormatAttribute is not null)
        {
            return string.Format(retFormatAttribute.Format, getter.Compile()(item));
        }

        return getter.Compile()(item).ToString();
    }
}

And usage:

var users = new Users
{
    Name = "Foo",
    Traveled = 42
};

Console.WriteLine(users.GetFormatted(static u => u.Name)); // prints "This name is Foo"
Console.WriteLine(users.GetFormatted(static u => u.Traveled)); // prints "You traveled 42km"

Note that this approach will introduce some performance hit (though it can be just fine for quite a lot of apps).

2. Use source generators to generate formatted members like string TraveledFormatted during compilation time.

You can try using the DisplayFormat annotation:

[DisplayFormat(DataFormatString = "{0:dd/MM/yyy}")]

https://learn.microsoft.com/en-us/dotnet/api/system.componentmodel.dataannotations.displayformatattribute?view=net-7.0