Явный и неявный оператор с числовыми типами и неожиданные результаты

Question

Я никогда не проводил обширной работы с операторами перегрузки, особенно с неявными и явными преобразованиями.

Однако у меня есть несколько числовых параметров, которые используются часто, поэтому я создаю структуру как оболочку вокруг числового типа, чтобы сильно набирать эти параметры. Вот пример реализация:

public struct Parameter 
{ 
    private Byte _value; 
    public Byte Value { get { return _value; } } 

    public Parameter(Byte value) 
    { 
     _value = value; 
    } 

    // other methods (GetHashCode, Equals, ToString, etc) 

    public static implicit operator Byte(Parameter value) 
    { 
     return value._value; 
    } 
    public static implicit operator Parameter(Byte value) 
    { 
     return new Parameter(value); 
    } 

    public static explicit operator Int16(Parameter value) 
    { 
     return value._value; 
    } 
    public static explicit operator Parameter(Int16 value) 
    { 
     return new Parameter((Byte)value); 
    } 
} 

Как я экспериментировал с моей реализацией теста, чтобы получить навык явных и неявных операторов, я попытался явно бросить Int64 моего Parameter типа и мои удивлен, что не бросало исключение и, что еще более удивительно, просто урезало число и перешло. Я попытался исключить пользовательский явный оператор, и он по-прежнему вел себя так же.

public void TestCast() 
{ 
    try 
    { 
     var i = 12000000146; 
     var p = (Parameter)i; 
     var d = (Double)p; 

     Console.WriteLine(i); //Writes 12000000146 
     Console.WriteLine(p); //Writes 146 
     Console.WriteLine(d); //Writes 146 
    } 
    catch (Exception ex) 
    { 
     Console.WriteLine(ex.Message); //Code not reached 
    } 
} 

Так что я повторил свой эксперимент с простым Byte вместо моей структуры и имеет такое же точное поведение, так что, очевидно, это ожидаемое поведение, но я думал, что явное приведение, что приводит к терять данные будут бросать исключение.

Answer 1

Когда компилятор анализирует явную пользователем определенного преобразование допускается поместить явный встроенный преобразования на «обе стороны» (или оба) преобразования. Так, например, если у вас есть определенный пользователь преобразование INT Фреды, и у вас есть:

int? x = whatever; 
Fred f = (Fred)x; 

то причины компилятора «существует явное преобразование INT Фред, так что я могу сделать явное преобразование из int в int, а затем преобразование int в Fred.

В вашем примере есть встроенное явное преобразование от длинного к короткому, и есть явное преобразование, определяемое пользователем, от short до Parameter, поэтому преобразование long в параметр является законным.

То же самое относится к неявным преобразованиям, компилятор может вставлять встроенные неявные преобразования на e итерационной части пользовательского неявного преобразования.

Компилятор никогда не связывает два пользовательских конверсий.

Правильное построение собственных явных преобразований - сложная задача на C#, и я рекомендую вам прекратить попытки сделать это, пока не получите полное и глубокое понимание всей главы спецификации, которая охватывает преобразования.

Для некоторых интересных аспектов прикованных конверсий см моих статей на эту тему:

http://blogs.msdn.com/b/ericlippert/archive/2007/04/16/chained-user-defined-explicit-conversions-in-c.aspx

http://blogs.msdn.com/b/ericlippert/archive/2007/04/18/chained-user-defined-explicit-conversions-in-c-part-two.aspx

Answer 2

Эта цель:

так я создаю-структуру в качестве обертки вокруг числового типа сильно введите эти параметры

И этот код:

public static implicit operator Byte(Parameter value) 
{ 
    return value._value; 
} 
public static implicit operator Parameter(Byte value) 
{ 
    return new Parameter(value); 
} 

находятся в полное противоречие. Добавляя двухсторонние неявные операторы, вы аннулируете любую безопасность типа, которую может принести оболочка.

Так что оставьте неявные преобразования. Вы можете изменить их на явные.