public void ReturnNullIfTypeIsIncompatibleWithInstance() { var sbc = new SomeBaseClass(); var sdc = sbc as SomeDerivedClass; Assert.Null(sdc); }
public void ThrowAnInvalidCastExceptionIfTypeIsIncompatibleWithInstance() { var sbc = new SomeBaseClass(); Assert.Throws <InvalidCastException>(() => { var sdc = (SomeDerivedClass)sbc; }); Assert.Throws <InvalidCastException>(() => { var i = (SomeInterface)sbc; }); }
public void AlwaysSucceedIfInstanceIsNull() { SomeBaseClass sbc = null; // incompatible but still works on null var sdc = (SomeDerivedClass)sbc; Assert.Null(sdc); sdc = (SomeDerivedClass)null; Assert.Null(sdc); }
public void DeepCopyPolymorphicTypes() { var someBaseClass = new SomeBaseClass { SbcString = "Shaggy", SbcInteger = 13 }; var someSubClass = new SomeSubClass { SbcString = "Shaggy", SbcInteger = 13, SscString = "Zoinks!", SscInteger = -1 }; var otherSubClass = new OtherSubClass { SbcString = "sbcs", SbcInteger = 2000, OtherSubClassString = "oscs", OtherSubClassInt = 1000 }; var someSubClassChild = new SomeSubClassChild { SbcString = "a", SbcInteger = 0, SscString = "Zoinks!", SscInteger = -1, SomeSubClassChildString = "string!", SomeSubClassChildInt = 5858 }; var someBaseClassResult = DeepCopy(someBaseClass); Assert.Equal(someBaseClass.SbcString, someBaseClassResult.SbcString); Assert.Equal(someBaseClass.SbcInteger, someBaseClassResult.SbcInteger); var someSubClassResult = DeepCopy(someSubClass); Assert.Equal(someSubClass.SscString, someSubClassResult.SscString); Assert.Equal(someSubClass.SscInteger, someSubClassResult.SscInteger); Assert.Equal(someSubClass.SbcString, someSubClassResult.SbcString); Assert.Equal(someSubClass.SbcInteger, someSubClassResult.SbcInteger); var otherSubClassResult = DeepCopy(otherSubClass); Assert.Equal(otherSubClass.OtherSubClassString, otherSubClassResult.OtherSubClassString); Assert.Equal(otherSubClass.OtherSubClassInt, otherSubClassResult.OtherSubClassInt); Assert.Equal(otherSubClass.SbcString, otherSubClassResult.SbcString); Assert.Equal(otherSubClass.SbcInteger, otherSubClassResult.SbcInteger); var someSubClassChildResult = DeepCopy(someSubClassChild); Assert.Equal(someSubClassChild.SomeSubClassChildString, someSubClassChildResult.SomeSubClassChildString); Assert.Equal(someSubClassChild.SomeSubClassChildInt, someSubClassChildResult.SomeSubClassChildInt); Assert.Equal(someSubClassChild.SscString, someSubClassChildResult.SscString); Assert.Equal(someSubClassChild.SscInteger, someSubClassChildResult.SscInteger); Assert.Equal(someSubClassChild.SbcString, someSubClassChildResult.SbcString); Assert.Equal(someSubClassChild.SbcInteger, someSubClassChildResult.SbcInteger); }
public void DoSomeCasts() { Int32 iSource = 13; String sSource = "IDDQD"; SomeBaseClass someObjectSource = new SomeDerivedClass(); Object objDest1 = (Object)iSource; Object objDest2 = (Object)sSource; Object objDest3 = (Object)someObjectSource; Int32 iDest1 = (Int32)objDest1; Int32 iDest2 = (Int32)iSource; String sDest = (String)objDest2; SomeDerivedClass someObjectDest1 = (SomeDerivedClass)someObjectSource; SomeBaseClass someObjectDest2 = (SomeBaseClass)objDest3; SomeBaseClass someObjectDest3 = (SomeBaseClass)someObjectSource; SomeBaseClass someObjectDest4 = (SomeBaseClass)someObjectDest1; }
/* * NOTE: * ==== * Use is / as on only reference or nullable types. Do not use with struct * */ public static void Run() { //use try-catch to validate type conversions - this approach works but impedes performance and code-readabilty. try { SomeBaseClass someBase = new SomeBaseClass(); //error should through if below don't work SomeClass someClass = (SomeClass)someBase; //explicit SomeBaseClass baseClass = someClass; //implicit } catch (InvalidCastException ex) { Console.WriteLine(ex.Message); } //use is to validate type conversions - returns true or false. SomeClass someClass1 = new SomeClass(); if (someClass1 is SomeBaseClass) { someClass1 = new SomeClass(); } SomeBaseClass someBaseClass1 = new SomeBaseClass(); if (someBaseClass1 is SomeClass) { someBaseClass1 = new SomeBaseClass(); } //use as to validate type conversion - returns a value if true otherwise null. //apples to apples SomeBaseClass y = someBaseClass1 as SomeBaseClass; SomeClass y1 = someClass1 as SomeClass; //big apple to small apple SomeClass x1 = someBaseClass1 as SomeClass; //small apple to big apple SomeBaseClass x = someClass1 as SomeBaseClass; //explicit - as SomeClass z = (SomeClass)(someClass1 as SomeBaseClass); //implicit - as SomeBaseClass a = someClass1 as SomeClass; }
public void ReturnFalseIfTypeIsIncompatibleWithInstance() { var sbc = new SomeBaseClass(); Assert.False(sbc is SomeDerivedClass); }