How can I make a strongly typed set of string values?

Question

I know enums can't be strings

I would like a data structure with the utility of an enum, but one which returns strings instead of integers. To be clear, I want the return type to be the enum-like type, not string. Basically, I want to be able to force a property to be usable as a string but is only allowed to be set to a value in a defined set of strings. Something like

stringenum Unit {
    Pixels = "px",
    Inches = "in"
}

class Settings {
    public Unit Unit { get; set; }
}

var settings = new Settings() { Unit = Unit.Pixels };

...

unitLabel.Text = settings.Unit;

I've seen some solutions that just create a class with properties that return a certain string. However, I need the return type to be limited to a set, not just any string.

EDIT FOR CLARIFICATION

Consider my previous example in addition to this method:

public void WriteUnit(Unit unit)
{
    Console.WriteLine(unit);
}

// Calling
WriteUnit(Unit.Pixels); // Prints "px"
WriteUnit("px"); // ARGUMENT EXCEPTION

This method will throw an ArgumentException if you pass it a string. It only accepts the type. This is specifically what I'm looking for.

Answer 1

As mentioned in the comments, you cannot directly map an enum to a string.

That said, there is nothing preventing you from creating a map of enum to string values, that can only be accessed via the enum. If you maintain the mapping, you can guarantee that the value always exist.

public enum Unit
{
    Pixels,
    Inches
}

public static class UnitMapper
{
    private static readonly Dictionary<Unit, string> _map
        = new Dictionary<UserQuery.Unit, string>()
        {
            { Unit.Pixels, "px" },
            { Unit.Inches, "in" }
        }
        
    public static string GetUnit(Unit unit)
    {
        return _map[unit];
    }
}

---

Based on your additional comments, this can be combined with a custom user-defined implicit operator to give you the type of functionality you are looking for, although you will still have to call the overridden .ToString() to output a string.

public struct UnitWrapper
{
    private readonly string _unitString;
    private readonly Unit _unit;
    
    public UnitWrapper(Unit unit)
    {
        _unit = unit;
        _unitString = UnitMapper.GetUnit(_unit);
    }

    public static implicit operator UnitWrapper(Unit unit)
    {
        return new UnitWrapper(unit);
    }
    

    public override string ToString() => _unitString;
}

This can then be used as follows:

public class Settings
{
    public UnitWrapper UnitWrapper { get; set; }
}

var settings = new Settings { UnitWrapper = Unit.Pixels };
string px = settings.UnitWrapper.ToString();