Casting między typami danych w języku C#

Question

mam (na przykład) obiekt typu A, że chcę być w stanie oddać do typu b (podobny do tego, jak można rzucić int do float)

typów danych A i B są moimi własnymi.

Czy można zdefiniować reguły, według których występuje ten rzut?

Przykład

int a = 1; 
float b = (float)a; 
int c = (int)b; 

Answer 1

Tak jest to możliwe przy użyciu C# przeciążenia operatora. Dostępne są dwie wersje: explicit i implicit.

Oto pełny przykład:

class Program 
{ 
    static void Main(string[] args) 
    { 
     A a1 = new A(1); 
     B b1 = a1; 

     B b2 = new B(1.1); 
     A a2 = (A)b2; 
    } 
} 

class A 
{ 
    public int Foo; 

    public A(int foo) 
    { 
     this.Foo = foo; 
    } 

    public static implicit operator B(A a) 
    { 
     return new B(a.Foo); 
    } 
} 

class B 
{ 
    public double Bar; 

    public B(double bar) 
    { 
     this.Bar = bar; 
    } 

    public static explicit operator A(B b) 
    { 
     return new A((int)b.Bar); 
    } 
} 

typu A mogą być oddane w sposób dorozumiany do typu B, lecz typu B muszą być oddane bezpośrednio do typu A.

Answer 2

Zakładając, że chcesz być operacja explcit musisz napisać jawnego operatora cast tak:

public static explicit operator MyTypeOne(MyTypeTwo i) 
{ 
    // code to convert from MyTypeTwo to MyTypeOne 
} 

następnie można go używać tak:

MyTypeOne a = new MyTypeOne(); 
MyTypeTwo b = (MyTypeTwo)a; 

Zastanawiam się, czy chcesz rzucić jeden typ na inny, czy też zamiast tego faktycznie chcesz dokonać konwersji. Powiedziałbym, że powinieneś unikać pisania operatorów obsady dla konwersji, jeśli chcesz tylko skorzystać z ładnej składni :)

Ogólnie, zaleca się, aby nie używać niejawnych rzutów, ponieważ pozwalają one na niezamierzony typ konwergencje. Od MSDN documentation on implicit:

Jednakże, ponieważ konwersje niejawne może nastąpić bez programatora ich określania, należy zachować ostrożność, aby uniknąć przykrych niespodzianek . W przypadku ogólne, niejawne operatory konwersji nigdy nie powinny wyrzucać wyjątków, a nigdy nie tracą informacji, aby można je było bezpiecznie używać bez znajomości programisty.

Answer 3

Cant przeciążać operatora oddanych w C#, ale można zamiast używać operatorów konwersji jawnych i ukrytych:

"Using Conversion Operators (C# Programming Guide)"