Switch case and generics checking

Question

I want to write a function that format int and decimal differently into string

I have this code:

and I want to rewrite it to generics:

    public static string FormatAsIntWithCommaSeperator(int value)
    {
        if (value == 0 || (value > -1 && value < 1))
            return "0";
        return String.Format("{0:#,###,###}", value);
    }

    public static string FormatAsDecimalWithCommaSeperator(decimal value)
    {
        return String.Format("{0:#,###,###.##}", value);
    }


    public static string FormatWithCommaSeperator<T>(T value) where T : struct
    {
        string formattedString = string.Empty;

        if (typeof(T) == typeof(int))
        {
            if ((int)value == 0 || (value > -1 && value < 1))
            return "0";

            formattedString = String.Format("{0:#,###,###}", value);
        }

        //some code...
    }

    /// <summary>
    /// If the number is an int - returned format is without decimal digits
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    public static string FormatNumberTwoDecimalDigitOrInt(decimal value)
    {
        return (value == (int)value) ? FormatAsIntWithCommaSeperator(Convert.ToInt32(value)) : FormatAsDecimalWithCommaSeperator(value);
    }

How can i use T in the function body?

What syntax should I use?

Answer 1

You can use the TypeCode enum for switch:

switch (Type.GetTypeCode(typeof(T)))
{
    case TypeCode.Int32:
       ...
       break;
    case TypeCode.Decimal:
       ...
       break;
}

Since C# 7.0 you can use pattern matching:

switch (obj)
{
    case int i:
       ...
       break;
    case decimal d:
       ...
       break;
    case UserDefinedType u:
       ...
       break;
}

Beginning with C# 8.0 you can use switch expressions:

string result = obj switch {
    int i => $"Integer {i}",
    decimal d => $"Decimal {d}",
    UserDefinedType u => "User defined {u}",
    _ => "unexpected type"
};

Answer 2

Another way to do switch on generic is:

switch (typeof(T))
{
    case Type intType when intType == typeof(int):
        ...
    case Type decimalType when decimalType == typeof(decimal):
        ...
    default:
        ...
}

Note that when as a case guard in switch expressions was introduced in C# 7.0/Visual Studio 2017.

Answer 3

In modern C#:

public static string FormatWithCommaSeperator<T>(T value) where T : struct
{
    switch (value)
    {
        case int i:
            return $"integer {i}";
        case double d:
            return $"double {d}";
    }
}

Answer 4

I had a similar question, but with custom classes rather than built-in data types. Here's how I went about it:

switch (typeof(T).Name)
{
    case nameof(Int32):
        break;
    case nameof(Decimal):
        break;
}

I modified it to use the types you are using (i.e., int and decimal). I like this approach more than hard coding strings, as a refactor of a class name will not break this code.

With newer versions of C#, you could also do this some of the time:

switch (Activator.CreateInstance(typeof(T)))
{
    case int _:
        break;
    case decimal _:
        break;
}

I say "some of the time" because that would only really work with types that have a default constructor. This approach uses pattern matching and discards. I don't really like it since you need to create an instance of the object (that you then throw away) and because of the default constructor requirement.

Answer 5

If you have an object, you can use C# 7 pattern matching. But if you don't have an object and want to switch on a generic type T, the best and fastest solution is just a ternary if operator.

public string TernaryIf<T>() =>
    typeof(T) == typeof(int) ? "#,###,###" :
    typeof(T) == typeof(decimal) ? "#,###,###.##" :
    null;

public string TrueSwitch<T>() =>
    true switch
    {
        true when typeof(T) == typeof(int) => "#,###,###",
        true when typeof(T) == typeof(decimal) => "#,###,###.##",
        _ => null,
    };

public string DefaultSwitch<T>() =>
    default(T) switch
    {
        int => "#,###,###",
        decimal => "#,###,###.##",
        _ => null,
    };

public string When_Switch<T>() =>
    typeof(T) switch
    {
        Type _ when typeof(T) == typeof(int) => "#,###,###",
        Type _ when typeof(T) == typeof(decimal) => "#,###,###.##",
        _ => null,
    };

public string TypeCodeSwitch<T>() =>
    Type.GetTypeCode(typeof(T)) switch
    {
        TypeCode.Int32 => "#,###,###",
        TypeCode.Decimal => "#,###,###.##",
        _ => null,
    };

public string WhenSwitch<T>() =>
    typeof(T) switch
    {
        Type intType when intType == typeof(int) => "#,###,###",
        Type decimalType when decimalType == typeof(decimal) => "#,###,###.##",
        _ => null,
    };

public string NameOfSwitch<T>() =>
    typeof(T).Name switch
    {
        nameof(Int32) => "#,###,###",
        nameof(Decimal) => "#,###,###.##",
        _ => null,
    };

public string ActivatorSwitch<T>() =>
    Activator.CreateInstance(typeof(T)) switch
    {
        int => "#,###,###",
        decimal => "#,###,###.##",
        _ => null,
    };

Benchmarks:

Method	Time
TernaryIf	0.37 ns
TrueSwitch	0.37 ns
DefaultSwitch	0.48 ns
When_Switch	1.92 ns
TypeCodeSwitch	3.85 ns
WhenSwitch	3.96 ns
NameOfSwitch	7.98 ns
ActivatorSwitch	12.10 ns

Answer 6

Edit: If you only want to handle exactly int and double, just have two overloads:

DoFormat(int value)
{
}

DoFormat(double value)
{
}

---

If you insist on using generics:

switch (value.GetType().Name)
{
    case "Int32":
        break;
    case "Double":
        break;
    default:
        break;
}

OR

if (value is int)
{
    int iValue = (int)(object)value;
}
else if (value is double)
{
    double dValue = (double)(object)value;
}
else
{
}

Answer 7

more formatted way to do switch on generic is:

switch (true)
{
    case true when typeof(T) == typeof(int):
        ...
    case true when typeof(T) == typeof(decimal):
        ...
    default:
        ...
}

Answer 8

From C# 8 it's possible to do it this way which also works with Nullable:

switch ((Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T)).Name)
{
    case nameof(Int32):
        ...

    case nameof(Decimal):
        ...

    case nameof(Boolean):  // You can also switch types like 'bool' or Nullable 'bool?'
        ...

    case nameof(String):   // Why not to use 'string'?
        ...

    default:
        ...
}

If you prefer switch expressions you can use:

return (Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T)).Name switch
{
    nameof(Int32) => ...,
    nameof(Decimal) => ...,
    nameof(Boolean) => ...,  // You can also switch types like 'bool' or Nullable 'bool?'
    nameof(String) => ...,   // Why not to use 'string'?
    _ => ...,
};

Answer 9

In C# 8 you can use (replace "..." with the relevant code):

... type switch
{
    Type _ when type == typeof(int) => ...,
    Type _ when type == typeof(decimal) => ...,
    _ => ... // default case
};

Another elegant option (replace "..." with the relevant code):

... Type.GetTypeCode(type) switch
{
    TypeCode.Int32 => ...,
    TypeCode.Decimal => ...,
    _ => ...
};

For more info: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/switch-expression

Answer 10

Alternatively you could always do:

public static string FormatWithCommaSeparator<T>(T[] items)
{
    var itemArray = items.Select(i => i.ToString());

    return string.Join(", ", itemArray);
}

Answer 11

You could check the type of the variabele;

    public static string FormatWithCommaSeperator<T>(T value)
    {
        if (value is int)
        {
            // Do your int formatting here
        }
        else if (value is decimal)
        {
            // Do your decimal formatting here
        }
        return "Parameter 'value' is not an integer or decimal"; // Or throw an exception of some kind?
    }

Answer 12

You could instead of using generics use IConvertible

    public static string FormatWithCommaSeperator(IConvertible value)
    {
            IConvertible convertable = value as IConvertible;
            if(value is int)
            {
                int iValue = convertable.ToInt32(null);
                //Return with format.
            }
            .....
    }