Casting moją klasę do Int64, Double itp

Question

Powiązane pytanie: Accessing a Class property without using dot operator

I utworzeniu klasy o nazwie MyDouble wygląda to

class MyDouble 
{ 
    double value; 
    //overloaded operators and methods 
} 

jestem w stanie wykonać wszystkie rodzaje operacji na MyDouble. Przykłady:

MyDouble a = 5.0; 
a += 3.0; 
...etc 

to jednak nadal zgłasza błąd

MyDouble a = 5.0; 
long b = (Int64)a; //error 
long b = (int64)a.value; //works 

Jak mogę zdefiniować ją tak, że operacja jak (Int64)a automatycznie konwertuje do (Int64)a.value? Nie chcę, aby użytkownik kiedykolwiek musiał się martwić o istnienie właściwości value.

Answer 1

Aby ta konwersja zadziałała, potrzebowałbyś explicit conversion na Int64.

to będzie wyglądać:

class MyDouble 
{ 
    double value; 

    public static explicit operator Int64(MyDouble value) 
    { 
     return (Int64)value.value; 
    } 
} 

Answer 2

Istnieje wyraźna konwersja z double do Int64, ale nie ze swojej klasy Int64. wszystko, co musisz zrobić, to zdefiniować jeden. Lub, jeśli masz konwersję z klasy na podwójną, co, jak przypuszczam, możesz zrobić:

długa x = (długa) (podwójna) a;

Jednak jest to uciążliwe; Zdefiniuję operatora konwersji jawnej.

Konwersja powinna być wyraźna, a nie domniemana, chyba że masz dobry powód, aby ją jasno wyrazić.

Konwersja języka z podwójnej na długą jest jawna , ponieważ konwersja może spowodować utratę informacji. Możesz utracić informacje związane z tą konwersją, ponieważ istnieją pewne liczby podwójne, takie jak 0,5, , które nie są konwertowane dokładnie na długie. Nazywa się to przekształcaniem zwężającym .

W przypadku konwersji według języka zawężanie konwersji jest jawne. Gdyby były niejawne, programiści mogliby przypadkowo utracić informacje, przypisując wartość jednego typu do zmiennej innego typu. Zdefiniowanie tej konwersji jako niejawnej narusza tę całkowicie rozsądną zasadę, więc musiałoby to być przekonujące.

Oto przykład pokazujący wartość tej zasady. Jeśli zawężenie konwersji było niejawne, spowodowałoby to, że kod byłby bardziej kruchy. Załóżmy, że konwersja podwójna na int jest domyślna:

class Family 
{ 
    ICollection<Person> Children { get; set; } 
} 

int GetAverageNumberOfChildren(IEnumerable<Family> families) 
{ 
    return families.Sum(f => f.Children.Count)/families.Count(); 
} 

void SomeMethod(IEnumerable<Family> families) 
{ 
    int averageNumberOfChildren = GetAverageNumberOfChildren(families); 
    //... 
} 

Ups! Mamy błąd! GetAverageNumberOfChildren powinien zwrócić double! Naprawmy to!

double GetAverageNumberOfChildren(IEnumerable<Family> families) 
{ 
    return families.Average(f => f.Children.Count); 
} 

Uff, wszystko się kompiluje i działa! Na szczęście cieliśmy się tym błędem!

Ale, niestety, nie. Nadal mamy błąd!SomeMethod niejawnie konwertuje wartość podwójną na int, więc jeśli oczekiwana wartość to 2.4, faktyczna wartość to 2.

Ponieważ konwersja podwójna na int jest jawna, kompilator ratuje nas przed nami. Po naprawieniu błędu GetAverageNumberOfChildren, błędny program nie zostanie skompilowany.

Teraz, jeśli twoja klasa MyDouble miał jakieś walidacji że ograniczony ją do liczby całkowitej wartości z zakresu równego lub mniejszego niż zakres long, wtedy będzie bezpieczna, aby konwersja niejawna. Ale w takim przypadku powinieneś oczywiście używać long, a nie double.

Answer 3

Niejawna konwersja zadziała tak samo, jak wyraźna konwersja.

public static implicit operator long(MyDouble m) 
{ 
    return (long) m.value; 
} 

Mając to na miejscu można zrobić:

long b = (Int64) a; 

lub po prostu

long b = a; 

To jest po prostu pokazują, że konwersja nie musi być jednoznaczna. Jak jednak wspomniano, to powinno być jednoznaczne ze względu na możliwość utraty danych.