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);
}
