Beispiel #1
0
        public static void CastingDemo()
        {
            // putting a more-specifically-typed value in a more generally-typed container
            IOutputter o = new Outputter(); // upcasting

            HelperMethod(new Outputter());  // upcasting
            // upcasting is safe, implicit (you don't have to cast with () )

            Outputter o2 = (Outputter)o; // downcasting
            // because the compiler can't know for sure that this will work,
            //    C# says, you have to declare your certainty that it should work with () operater.
            //    if you were wrong, it will throw an exception at runtime.

            // downcasting is explicit

            // other kinds of casting, like numeric conversions.
            double x = 5.5;
            int    a = (int)x; // int can't represent every possible double, so data could be lost if we want this to happen
            // (it doesn't round-to-nearest-integer, it truncates, discards the decimal places)
            double y = a;      // double can represent every possible int, so this is safe, so it's an implicit conversion

            // boxing and unboxing

            // value types behave in one way when you pass them to a new variable (copy the value)
            // reference types behave in a different way (copy the reference)

            int    x2 = 3;
            object o3 = x2;   // the value is wrapped in a object on the heap, so that o3 can have the reference-type semantics we expect.
            // that's called boxing.
            int y2 = (int)o3; // unboxing the value.

            // C# supports operator overloading
            // you can make your class work with +, ==, [], etc
            // you can even define your own custom implicit casts and explicit casts.
        }
Beispiel #2
0
 public static void HelperMethod(IOutputter o)
 {
     Outputter o2 = (Outputter)o; // downcasting
 }