146

Why does the first and second Write work but not the last? Is there a way I can allow all 3 of them and detect if it was 1, (int)1 or i passed in? And really why is one allowed but the last? The second being allowed but not the last really blows my mind.

Demo to show compile error

using System;
class Program
{
    public static void Write(short v) { }
    static void Main(string[] args)
    {
        Write(1);//ok
        Write((int)1);//ok
        int i=1;
        Write(i);//error!?
    }
}
Improve this question
2
  • 2
    I too am stumped by this, i often have to cast ints to short in function calls although they should be castable...
    – Mathieu Dumoulin
    Commented Jul 11, 2012 at 12:19
  • 2
    @MathieuDumoulin they are castable, that's why you can cast them. But it's a lossfull conversion (there are many ints that don't fit in a short), so implicit cast is not possible, that's why you have to write (short) i.
    – Abel
    Commented Jul 19, 2012 at 8:25

8 Answers 8

Reset to default
186

The first two are constant expressions, the last one isn't.

The C# specification allows an implicit conversion from int to short for constants, but not for other expressions. This is a reasonable rule, since for constants the compiler can ensure that the value fits into the target type, but it can't for normal expressions.

This rule is in line with the guideline that implicit conversions should be lossless.

6.1.8 Implicit constant expression conversions

An implicit constant expression conversion permits the following conversions:

  • A constant-expression (§7.18) of type int can be converted to type sbyte, byte, short, ushort, uint, or ulong, provided the value of the constant-expression is within the range of the destination type.
  • A constant-expression of type long can be converted to type ulong, provided the value of the constant-expression is not negative.

(Quoted from C# Language Specification Version 3.0)

Improve this answer
0
67

There is no implicit conversion from int to short because of the possibility of truncation. However, a constant expression can be treated as being of the target type by the compiler.

1? Not a problem: it’s clearly a valid short value. i? Not so much – it could be some value > short.MaxValue for instance, and the compiler cannot check that in the general case.

Improve this answer
11
  • So... it does not matter how explicit i am... >_<. Do you have any idea if i can detect if a litereal was passed or a int variable?
    – user34537
    Commented Jul 11, 2012 at 12:21
  • @acidzombie24 You cannot. But why would you want to do that?
    – Adam Houldsworth
    Commented Jul 11, 2012 at 12:21
  • @acidzombie24 I don’t think you can detect that. You can however use a template argument and then use reflection to get at its type.
    – Konrad Rudolph
    Commented Jul 11, 2012 at 12:22
  • 3
    @acidzombie24 There is no way a literal could to be passed in during runtime. So you can just use your eyes to check at compile time.
    – Justin
    Commented Jul 11, 2012 at 12:22
  • 1
    @acidzombie24 In that case, would it be an option to accept the argument as an Expression<Func<int>>? Then you could pass () => 1 or () => i and inside the function you could inspect whether the passed entity contained a captured variable or a constant value.
    – Konrad Rudolph
    Commented Jul 11, 2012 at 12:28
8

an int literal can be implicitly converted to short. Whereas:

You cannot implicitly convert nonliteral numeric types of larger storage size to short

So, the first two work because the implicit conversion of literals is allowed.

Improve this answer
1
  • 3
    Your answer is slightly wrong. You shouldn't use literal but constant-expression. In particular the second example is not a literal.
    – CodesInChaos
    Commented Jul 11, 2012 at 13:17
6

I believe it is because you are passing in a literal/constant in the first two, but there is not automatic type conversion when passing in an integer in the third.

Edit: Someone beat me to it!

Improve this answer
4

The compiler has told you why the code fails:

cannot convert `int' expression to type `short'

So here's the question you should be asking: why does this conversion fail? I googled "c# convert int short" and ended up on the MS C# page for the short keyword:

http://msdn.microsoft.com/en-us/library/ybs77ex4(v=vs.71).aspx

As this page says, implicit casts from a bigger data type to short are only allowed for literals. The compiler can tell when a literal is out of range, but not otherwise, so it needs reassurance that you've avoided an out-of-range error in your program logic. That reassurance is provided by a cast.

Write((short)i)
Improve this answer
3

Because there will not be any implicit conversion between Nonliteral type to larger sized short.

Implicit conversion is only possible for constant-expression.

public static void Write(short v) { }

Where as you are passing integer value as an argument to short 

int i=1;
Write(i);  //Which is Nonliteral here
Improve this answer
0
0

Converting from int -> short might result in data truncation. Thats why.

Improve this answer
0

Conversion from short --> int happens implicitly but int -> short will throw compile error bcoz it might result in data truncation.

Improve this answer