Check if value is 0 with extension method

Question

I have an extension method which looks like

public static T ThrowIfObjectIsNull<T>(this T argument) where T : class
{
  if (argument == null)
      throw new ArgumentNullException(nameof(argument));

   return argument;
}

This basically check if the object that's being passed isn't null. What I am trying to do is create another extension method where the int value which is being passed in isn't 0. So I have gone ahead and created:

public static T ThrowIfZero<T>(this T argument) where T : struct
{
   if (argument == 0)
     throw new ArgumentOutOfRangeException("some error here");

   return argument;
}

Of course the above does not compile suggesting the error:

Error CS0019 Operator '==' cannot be applied to operands of type 'T' and 'int'

Can someone point me to the right direction on how I would check if the argument value isn't 0?

Why is it generic at all? Just use `int`. But then again, why even have an extension method at all? — DavidG, May 16 '18 at 13:37
Why not just `public static int ThrowIfZero(this int argument) { ... }` ? — Lasse V. Karlsen, May 16 '18 at 13:38
You can't do `==` comparison for generic struct values. so `if (argument == default(T))` doesn't compile. — Lasse V. Karlsen, May 16 '18 at 13:39
@DmitryPavliv care to make that an answer? (btw, it could work for value types and reference types in a single method...) — Zohar Peled, May 16 '18 at 13:39
Also, your extension methods lose the context so when you use `nameof`, it's completely unrelated. — DavidG, May 16 '18 at 13:39
Why not simply `argument.Equals(default(T))` with `where T : struct` constraint ? — Fabjan, May 16 '18 at 13:48

Tim Schmelter · Accepted Answer · 2018-05-17T07:37:37.670

22

You could simply use Equals:

public static T ThrowIfZero<T>(this T argument) where T : struct
{
    if (argument.Equals(0))
        throw new ArgumentOutOfRangeException("some error here");

    return argument;
}

But that will not really work well if the argument is for example a decimal 0.0m which is not equal to the integer 0 as Peter has commented correctly.

So if you want a version that works for any number you could use this approach:

public static T ThrowIfZero<T>(this T argument) where T : struct
{
    bool isZero = Decimal.Compare(0.0m, Convert.ToDecimal(argument)) == 0;
    if (isZero)
        throw new ArgumentOutOfRangeException("some error here");

    return argument;
}

edited May 17 '18 at 07:37

answered May 16 '18 at 13:43

Tim Schmelter

450,073
74
686
939

4

or `IEquatable`, and I'm not sure you need the cast, `argument.CompareTo(0)` should compile just fine. – Lasse V. Karlsen May 16 '18 at 13:43
Thanks for this, I will have a go at it and let you know how I get on – Izzy May 16 '18 at 13:45
1

@LasseVågsætherKarlsen: or simply using `Equals` without additional constraint :) – Tim Schmelter May 16 '18 at 13:49
@TimSchmelter Ah ok... I wonder what is the point of checking for example whether the `DateTime` struct is 0 though ? – Fabjan May 16 '18 at 13:53
@Fabjan: OP didn't want to use it for DateTime. You could use it with it though, but it would not throw an exception because a DateTime is never 0 – Tim Schmelter May 16 '18 at 13:54
2

This solution will only really work for `int`. With `0L` or `0.0` the `CompareTo(0)` version will throw a runtime error because `0` is not of type `Int64` or `Double`. In the `Equals(0)` version the type of `0L` or `0.0` is not the type of `0` and therefor argument is not treated as equal to `0` and the exception is not thrown. In the end this is not better than adding an `int` type constraint to `T`. – heijp06 May 16 '18 at 14:17
@PetervanderHeijden: fixed – Tim Schmelter May 17 '18 at 11:37

score 12 · Answer 2 · answered May 16 '18 at 14:23

12

You can use EqualityComparer as well.

public static T ThrowIfZero<T>(this T argument) where T : struct
{   
     if (EqualityComparer<T>.Default.Equals(argument, default(T)))   
        throw new ArgumentOutOfRangeException("some error here");

     return argument;
}

You can refer answer of this post (credit should go to @Mehrdad).

answered May 16 '18 at 14:23

par

1,061
1
11
29

This sounds like the better solution. It can also handle zeros on custom structs. – Arturo Torres Sánchez May 16 '18 at 18:24
@ArturoTorresSánchez: but that was not a requirement. Why `ThrowIfZero` should throw an exception with non-zero values, for example if you pass `new DateTime()`? Neither OP wanted this nor the name of the method suggests that it behaves like that. If i needed a `ThrowIfDefault` i'd use this. – Tim Schmelter May 17 '18 at 07:29

score 4 · Answer 3 · answered May 22 '18 at 00:33

It doesn’t look like you need generics at all. If the variable is just an int as you suggest, just use:

public static int ThrowIfZero(this int argument)
{
    if (argument == 0)
    {
        throw new ArgumentOutOfRangeException("some error here");
    }

    return argument;
}

score 1 · Answer 4 · answered May 16 '18 at 20:40

int, decimal etc. implement IComparable so something like this also works:

public static T ThrowIfZero<T>(this T argument) 
    where T : struct, IComparable
{
   if (argument.CompareTo(default(T)) == 0)
     throw new ArgumentOutOfRangeException("some error here");

   return argument;
}

score 0 · Answer 5 · answered May 17 '18 at 02:49

Another way I saw recently:

public static int ThrowIfZero<T>(this T param)
    where T : struct
{
    var o = (object)param;
    int i;

    try   { i = (int)o; }
    catch { throw new ArgumentException("Param must be of type int");  }

    if (i == 0) throw new ArgumentException("Must be not be zero");

    return (int)(object)param;
}

We can trick the compiler into letting us cast T into int by casting it to object first. This works fine for int, but the downside is this only works for int, and won't work for a float.

If you want it to work with all numerable types, you can use pattern matching and do something like this:

public static T ThrowIfZero<T>(this T param)
    where T : struct
{
    switch (param)
    {
        case int     i:  if (i == 0)  throwException(); break;
        case double  d:  if (d == 0)  throwException(); break;
        case float   f:  if (f == 0)  throwException(); break;
        case decimal c:  if (c == 0)  throwException(); break;
        case long    l:  if (l == 0)  throwException(); break;
        case uint    ui: if (ui == 0) throwException(); break;
        case ulong   ul: if (ul == 0) throwException(); break;
        case byte    b:  if (b == 0)  throwException(); break;
        default: throw new ArgumentException("Invalid Type");
    }

    return param;

    // ---- Local Functions ---- //
    void throwException() => throw new ArgumentException("Must not be zero");
}

Of course, the best solution would be if they took Jon Skeet up on his offer and did a where T : numeric that constraints it to basically the types above, and maybe some custom types too, so we could include our own ComplexNumber or SuperBigInteger.

To be honest, I wouldn't do it either of these ways, because the first way has casting, and the second way just leads to missing cases and having to maintain the switch if you need, just thought I'd show the more options, though.

Check if value is 0 with extension method

5 Answers5