private static void ChildClassTypeVerifyTest()
{
BaseClass childA = new DerivedClassA();
BaseClass childB = new DerivedClassB();
if (childA is DerivedClassB)
{
Console.WriteLine("childA is DerivedClassB");
}
else
{
Console.WriteLine(@"childA is DerivedClassA");
}
if (childB is DerivedClassB)
{
Console.WriteLine("childB is DerivedClassB");
}
else
{
Console.WriteLine(@"childB is DerivedClassA");
}
if (childB is BaseClass)
{
Console.WriteLine("childB is derived from BaseClass");
}
else
{
Console.WriteLine(@"Where childB comes from?");
}
}
public void should_not_violate_ploymorphism()
{
DerivedClassA[] subClassArray = { new DerivedClassA() };
BaseClass[] baseClassArray = ToBaseClassArray(subClassArray);
var derivedClassB = new DerivedClassB();
baseClassArray[0] = derivedClassB;
Assert.Same(derivedClassB, baseClassArray[0]);
}
private static void VerifyModifiers()
{
DerivedClassA class_a = new DerivedClassA();
DerivedClassB class_b = new DerivedClassB();
BaseClass base_a = class_a;
BaseClass base_b = class_b;
Debug.Assert(class_a.GetCode() == "CODE-2", "class_a.GetCode() should return CODE-2");
Debug.Assert(class_b.GetCode() == "CODE-3", "class_b.GetCode() should return CODE-3");
Debug.Assert(base_a.GetCode() == "CODE-1", "base_a.GetCode() should return CODE-1");
Debug.Assert(base_b.GetCode() == "CODE-1", "base_b.GetCode() should return CODE-1");
Debug.Assert(class_a.GetDescription() == "CLASS-A", "class_a.GetDescription() sould return CLASS-A");
Debug.Assert(class_b.GetDescription() == "B", "class_b.GetDescription() should return B");
Debug.Assert(base_a.GetDescription() == "CLASS-A", "base_1.GetDescription() should return CLASS-A");
Debug.Assert(base_b.GetDescription() == "B", "base_b.GetDescription() should return B");
}
public static void Main()
{
/*
* If base class referrence is pointing to dirived class object with virtual and override keywork then
* derived class method will be invoked then it is called method overriding.
*/
BaseClass b = new DerivedClassA();
b.Print();
/*
* If base class referrence is pointing to dirived class object with virtual (Optional) and new keywork then
* base class method will be invoked then it is called method hidding.
*/
BaseClass b1 = new DerivedClassB();
b1.Print();
}
public void AAAA()
{
// Arrange
var config = new AutoMapper.MapperConfiguration(cfg =>
{
cfg.CreateMap <BaseClass, ClassAggregate>().IncludeAllDerived();
cfg.CreateMap <DerivedClassA, ClassAggregate>().IncludeAllDerived();
cfg.CreateMap <DerivedClassB, ClassAggregate>().IncludeAllDerived();
});
var obj = new DerivedClassB
{
Prop1 = "aa",
Prop3 = "333"
};
var mapper = new AutoMapper.Mapper(config);
// var result = mapper.Map<ClassAggregate>(obj, opts => opts.CreateMissingTypeMaps = true);
}
public DerivedClassA()
{
DerivedClassB otherObject = new DerivedClassB();
otherObject.sharedMember = sharedMember; //Compiler error, cannot access protected member
}
