how user define conversion happen in c#

Question

Can any one explain the following program that how user define conversion happen both explicitly and implicitly?

Please also see my comments at the explicitly conversion method and implicit conversion method.

/*** conversion.cs ***/

using System;
using System;

struct RomanNumeral {
    public RomanNumeral(int value) {
        this.value=value; // what happen here?? 
    }

    static public implicit operator RomanNumeral(int value) {
        // here the default constructor is called  and the parameter in the 
        // argument is passed for the conversion to RomanNumeral but the 
        // constructor is of the type int so how it happen please explain?? 
        return new RomanNumeral(value); 
    }

    static public explicit operator int(RomanNumeral roman) {
        return roman.value;//how it is  happen here??
    }

    static public implicit operator string(RomanNumeral roman) {
        return ("Conversion not yet implemented");
    }

    private int value;
}

class Test {
    static public void Main() {
        RomanNumeral numeral;

        numeral=10;


        Console.WriteLine((int)numeral);


        Console.WriteLine(numeral);


        short s=(short)numeral;

        Console.WriteLine(s);
    }
}

It's not at all clear what you mean by "how it is happen here". — Jon Skeet, Mar 08 '13 at 18:26
@jon keet i a mean how it access the value int constrauctor?? — Irfan Ul Haq, Mar 08 '13 at 18:31
Why would it not be able to call the constructor? It's declared in the same class. (And anyway, it's a public constructor.) — Jon Skeet, Mar 08 '13 at 18:49

score 2 · Answer 1 · answered Mar 08 '13 at 18:29

Let's look at this example to start with:

static public implicit operator RomanNumeral(int value)
{
    // here the default constructor is called  and the argument is passed for
    // the conversion to RomanNumeral but the parameter in the constructor is
    // of the type int so how it happen please explain ??
    return new RomanNumeral(value);
}

I've moved and reformatted your comment for readability.

Firstly, no, the default constructor is not called (directly, anyway). The RomanNumeral(int) constructor is called.

It's useful to think of the implicit operator as just a method which is called automatically. So imagine we had a static method like this:

// Note: body is the same as the implicit conversion
public static RomanNumeral FromInt32(int value)
{
    return new RomanNumeral(int value);
}

Then you can think of this:

int x = 10;
RomanNumeral numeral = x;

as being compiled to:

int x = 10;
RomanNumeral numeral = RomanNumeral.FromInt32(x);

It's just that the operator a method which doesn't have a name you can refer to in C#.

Ken Kin · Accepted Answer · 2013-03-08T22:50:10.243

/*** Answer with the comments in code ***/
// You can imagine that conversion operator as `cast constructor`, though 
// it can output an instance of target type in the ways other than a real 
// constructor. 
// The semantic model is `OutputType(InputType value)`
// which means the LHS is of `OutputType` and RHS is of `InputType`. 
// For more information, see 
//      http://msdn.microsoft.com/en-us/library/85w54y0a.aspx
struct RomanNumeral {
    public RomanNumeral(int value) {
        // here the parameter `value` assiged to the field value ----+
        this.value=value;                                         // |
    }                                                             // |
    //                                                               |
    static public implicit operator RomanNumeral(int value) {     // |
        // RomanNumeral(int value) is semantically tells that it     |
        // outputs a `RomanNumeral` from taking an `int` like        |
        // the constructor.                                          |
        // Thus if there was a method `M(RomanNumeral x)`            |
        // and called with M(3), then it's called with               |
        // M((RomanNumeral)3) by effection of this implicit operator |
        // and because it's implicit, you don't need to explicitly   |
        // cast it.                                                  |
        return new RomanNumeral(value);                           // |
    }                                                             // |
    //                                                               |
    static public explicit operator int(RomanNumeral roman) {     // |
        // Here the explicit operator just does the reverse thing    |
        // of what the implicit operator does                        |
        // However, because it's declared as explicit, you'll need   |
        // to tell the compiler you want to cast explicitly, or the  |
        // compiler treats statement like `int x=myRoman;` as an     |
        // error where `myRoman` is assumed a `RomanNumeral`         |
        // So you would write the statement as `int x=(int)myRoman;` |
        // and it compiles.                                          |
        return roman.value;                                       // |
    }                                                             // |
    //                                                               |
    static public implicit operator string(RomanNumeral roman) {  // |
        return ("Conversion not yet implemented");                // |
    }                                                             // |
    //                                                               |
    private int value; // <------------------------------------------+ 
}

thanks ken kin you made it too easy. – Irfan Ul Haq Mar 12 '13 at 07:33 — Irfan Ul Haq, Mar 12 '13 at 07:33

how user define conversion happen in c#

2 Answers2