/// <summary>
/// Exercise in Power. Control. Power. And once more Control. Show them stupid compiler who's the boss.
/// Why? Yes.
/// </summary>
static void Main(string[] args)
{
// Casting enums work. But this is boring.
{
FooEnum fooX = FooEnum.SomeValueA;
BarEnum barX = (BarEnum)fooX;
}
// Casting structs does not compile. Obviously What a shame.
{
//FooStruct foo = new FooStruct();
//BarStruct bar = (BarStruct)foo;
}
// Screw you CLR, I'm a ninja.
{
FooStruct foo = new FooStruct
{
fieldA = "this is FooStruct.FieldA",
fieldB = "this is FooStruct.FieldB",
};
BarStruct bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From<FooStruct>.To<BarStruct>.ForScience(foo);
Console.WriteLine(string.Format("Value of BarStruct.fieldXXX: {0}", bar.fieldXXX));
Console.WriteLine(string.Format("Value of BarStruct.fieldYYY: {0}", bar.fieldYYY));
}
// And classes too! Compiles! And even works!
{
FooClass foo = new FooClass
{
fieldA = "this is FooClass.FieldA",
fieldB = "this is FooClass.FieldB",
};
BarClass bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From<FooClass>.To<BarClass>.ForScience(foo);
Console.WriteLine(string.Format("Value of BarClass.fieldXXX: {0}", bar.fieldXXX));
Console.WriteLine(string.Format("Value of BarClass.fieldYYY: {0}", bar.fieldYYY));
}
// Extra fields AND classes? Ha! Also works as expected
{
FooClass foo = new FooClass
{
fieldA = "this is FooClass.FieldA",
fieldB = "this is FooClass.FieldB",
};
BarClassWithExtraField bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From<FooClass>.To<BarClassWithExtraField>.ForScience(foo);
Console.WriteLine(string.Format("Value of BarClassWithExtraField.fieldXXX: {0}", bar.fieldXXX));
Console.WriteLine(string.Format("Value of BarClassWithExtraField.fieldYYY: {0}", bar.fieldYYY));
Console.WriteLine(string.Format("Value of BarClassWithExtraField.fieldExtra: {0}", bar.fieldExtra ?? "<null>"));
}
// Split long integeres into shorter ones. Wow :)
{
FooClassWithLong foo = new FooClassWithLong
{
fieldA = ulong.MaxValue
};
BarClassWithFourShorts bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From<FooClassWithLong>.To<BarClassWithFourShorts>.ForScience(foo);
Console.WriteLine(string.Format("Value of BarClassWithFourShorts.fieldA: {0}; max ushort: {1}", bar.fieldA, ushort.MaxValue));
Console.WriteLine(string.Format("Value of BarClassWithFourShorts.fieldB: {0}; max ushort: {1}", bar.fieldB, ushort.MaxValue));
Console.WriteLine(string.Format("Value of BarClassWithFourShorts.fieldB: {0}; max ushort: {1}", bar.fieldC, ushort.MaxValue));
Console.WriteLine(string.Format("Value of BarClassWithFourShorts.fieldB: {0}; max ushort: {1}", bar.fieldD, ushort.MaxValue));
}
// Don't even need the same field types in source and target (but this is a bit dodgy)
{
FooClassWithLong foo = new FooClassWithLong
{
fieldA = ulong.MaxValue
};
// Bonus feature: Travel really far into the future.
// This yields the date 08/11/14614 13:24:02, whereas DateTime.MaxValue is only 31/12/9999 23:59:59
BarClassWithDate bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From<FooClassWithLong>.To<BarClassWithDate>.ForScience(foo);
Console.WriteLine(string.Format("Value of BarClassWithDate.fieldB: {0}; max DateTime: {1}", bar.fieldA, DateTime.MaxValue));
}
// String.Length is for weak poeple.
{
string wellHelloThere = "idin 9ehvjd dng8nf yes this is gonna work";
BarClassWithIntOrLong bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From<string>.To<BarClassWithIntOrLong>.ForScience(wellHelloThere);
Console.WriteLine(string.Format("Value of string.Length is: {0}. And value of BarClassWithIntOrLong.fieldA is: {1}", wellHelloThere.Length, bar.fieldA));
}
// Immutable strings? Ha!
{
string wellHelloThere = "idin 9ehvjd dng8nf yes this is gonna work";
char[] bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From<string>.To<char[]>.ForScience(wellHelloThere);
bar[0] = 'Y';
bar[1] = 'A';
bar[2] = 'Y';
bar[3] = '!';
Console.WriteLine(string.Format("Value of string after showing who's the boss here: {0}.", wellHelloThere));
}
// Is someone over-protective of their code?
// Did someone read too many blogs on the benefits of "encapsulation"?
// Have they thought to hide cool useful fields using "private" keyword?
// Fools! It's Encapsulation-Boomcapsulation time! Turn their private fields into public!
{
FooClassWithPrivateFields foo = new FooClassWithPrivateFields(fieldA: "private field A", fieldB: "private field B");
BarClassWithEverythingPublic bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From<FooClassWithPrivateFields>.To<BarClassWithEverythingPublic>.ForScience(foo);
Console.WriteLine("Private field A? Not anymore!: {0}", bar.fieldAPublic);
Console.WriteLine("Private field B? Not anymore!: {0}", bar.fieldBPublic);
}
// Arrays of T. Turn them into Arrays of Y!
{
var fooThings = new FooClass[]
{
new FooClass{fieldA = "foo.FieldA 1", fieldB = "foo.FieldB 1"},
new FooClass{fieldA = "foo.FieldA 2", fieldB = "foo.FieldB 2"}
};
// This will not compile.
//var barThings = (BarClass[])fooThings;
// But we don't care!
var barThings = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From<FooClass[]>.To<BarClass[]>.ForScience(fooThings);
foreach (var bar in barThings)
{
Console.WriteLine("Array. bar.fieldXXX: {0}", bar.fieldXXX);
Console.WriteLine("Array. bar.fieldYYY: {0}", bar.fieldYYY);
}
}
// Linq and enumerables -- no problem!
{
var fooArray = new FooClass[]
{
new FooClass{fieldA = "foo.FieldA 1", fieldB = "foo.FieldB 1"},
new FooClass{fieldA = "foo.FieldA 2", fieldB = "foo.FieldB 2"}
};
var fooThingsEnumerable = fooArray.AsEnumerable();
// This will throw InvalidCastException.
//var barThings = (IEnumerable<BarClass>)fooThingsEnumerable;
// But we don't care!
var barThings = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From<IEnumerable<FooClass>>.To<IEnumerable<BarClass>>.ForScience(fooThingsEnumerable);
foreach (var bar in barThings)
{
Console.WriteLine("Enumerable. bar.fieldXXX: {0}", bar.fieldXXX);
Console.WriteLine("Enumerable. bar.fieldYYY: {0}", bar.fieldYYY);
}
}
// Enhanced polymorphism without class hierarchy - Turn dogs into cats!
{
var cat = new Cat();
// This will not compile.
//var dog = (Dog)cat;
// But we don't care!
var dog = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From<Cat>.To<Dog>.ForScience(cat);
Console.WriteLine("Cat says: {0}", cat.SaySomething());
Console.WriteLine("Cat became dog: {0}", dog.SaySomething());
}
// And many, many other fun application. :)
}
/// <summary>
/// Exercise in Power. Control. Power. And once more Control. Show them stupid compiler who's the boss.
/// Why? Yes.
/// </summary>
static void Main(string[] args)
{
// Casting enums work. But this is boring.
{
FooEnum fooX = FooEnum.SomeValueA;
BarEnum barX = (BarEnum)fooX;
}
// Casting structs does not compile. Obviously What a shame.
{
//FooStruct foo = new FooStruct();
//BarStruct bar = (BarStruct)foo;
}
// Screw you CLR, I'm a ninja.
{
FooStruct foo = new FooStruct
{
fieldA = "this is FooStruct.FieldA",
fieldB = "this is FooStruct.FieldB",
};
BarStruct bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From <FooStruct> .To <BarStruct> .ForScience(foo);
Console.WriteLine(string.Format("Value of BarStruct.fieldXXX: {0}", bar.fieldXXX));
Console.WriteLine(string.Format("Value of BarStruct.fieldYYY: {0}", bar.fieldYYY));
}
// And classes too! Compiles! And even works!
{
FooClass foo = new FooClass
{
fieldA = "this is FooClass.FieldA",
fieldB = "this is FooClass.FieldB",
};
BarClass bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From <FooClass> .To <BarClass> .ForScience(foo);
Console.WriteLine(string.Format("Value of BarClass.fieldXXX: {0}", bar.fieldXXX));
Console.WriteLine(string.Format("Value of BarClass.fieldYYY: {0}", bar.fieldYYY));
}
// Extra fields AND classes? Ha! Also works as expected
{
FooClass foo = new FooClass
{
fieldA = "this is FooClass.FieldA",
fieldB = "this is FooClass.FieldB",
};
BarClassWithExtraField bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From <FooClass> .To <BarClassWithExtraField> .ForScience(foo);
Console.WriteLine(string.Format("Value of BarClassWithExtraField.fieldXXX: {0}", bar.fieldXXX));
Console.WriteLine(string.Format("Value of BarClassWithExtraField.fieldYYY: {0}", bar.fieldYYY));
Console.WriteLine(string.Format("Value of BarClassWithExtraField.fieldExtra: {0}", bar.fieldExtra ?? "<null>"));
}
// Split long integeres into shorter ones. Wow :)
{
FooClassWithLong foo = new FooClassWithLong
{
fieldA = ulong.MaxValue
};
BarClassWithFourShorts bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From <FooClassWithLong> .To <BarClassWithFourShorts> .ForScience(foo);
Console.WriteLine(string.Format("Value of BarClassWithFourShorts.fieldA: {0}; max ushort: {1}", bar.fieldA, ushort.MaxValue));
Console.WriteLine(string.Format("Value of BarClassWithFourShorts.fieldB: {0}; max ushort: {1}", bar.fieldB, ushort.MaxValue));
Console.WriteLine(string.Format("Value of BarClassWithFourShorts.fieldB: {0}; max ushort: {1}", bar.fieldC, ushort.MaxValue));
Console.WriteLine(string.Format("Value of BarClassWithFourShorts.fieldB: {0}; max ushort: {1}", bar.fieldD, ushort.MaxValue));
}
// Don't even need the same field types in source and target (but this is a bit dodgy)
{
FooClassWithLong foo = new FooClassWithLong
{
fieldA = ulong.MaxValue
};
// Bonus feature: Travel really far into the future.
// This yields the date 08/11/14614 13:24:02, whereas DateTime.MaxValue is only 31/12/9999 23:59:59
BarClassWithDate bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From <FooClassWithLong> .To <BarClassWithDate> .ForScience(foo);
Console.WriteLine(string.Format("Value of BarClassWithDate.fieldB: {0}; max DateTime: {1}", bar.fieldA, DateTime.MaxValue));
}
// String.Length is for weak poeple.
{
string wellHelloThere = "idin 9ehvjd dng8nf yes this is gonna work";
BarClassWithIntOrLong bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From <string> .To <BarClassWithIntOrLong> .ForScience(wellHelloThere);
Console.WriteLine(string.Format("Value of string.Length is: {0}. And value of BarClassWithIntOrLong.fieldA is: {1}", wellHelloThere.Length, bar.fieldA));
}
// Immutable strings? Ha!
{
string wellHelloThere = "idin 9ehvjd dng8nf yes this is gonna work";
char[] bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From <string> .To <char[]> .ForScience(wellHelloThere);
bar[0] = 'Y';
bar[1] = 'A';
bar[2] = 'Y';
bar[3] = '!';
Console.WriteLine(string.Format("Value of string after showing who's the boss here: {0}.", wellHelloThere));
}
// Is someone over-protective of their code?
// Did someone read too many blogs on the benefits of "encapsulation"?
// Have they thought to hide cool useful fields using "private" keyword?
// Fools! It's Encapsulation-Boomcapsulation time! Turn their private fields into public!
{
FooClassWithPrivateFields foo = new FooClassWithPrivateFields(fieldA: "private field A", fieldB: "private field B");
BarClassWithEverythingPublic bar = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From <FooClassWithPrivateFields> .To <BarClassWithEverythingPublic> .ForScience(foo);
Console.WriteLine("Private field A? Not anymore!: {0}", bar.fieldAPublic);
Console.WriteLine("Private field B? Not anymore!: {0}", bar.fieldBPublic);
}
// Arrays of T. Turn them into Arrays of Y!
{
var fooThings = new FooClass[]
{
new FooClass {
fieldA = "foo.FieldA 1", fieldB = "foo.FieldB 1"
},
new FooClass {
fieldA = "foo.FieldA 2", fieldB = "foo.FieldB 2"
}
};
// This will not compile.
//var barThings = (BarClass[])fooThings;
// But we don't care!
var barThings = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From <FooClass[]> .To <BarClass[]> .ForScience(fooThings);
foreach (var bar in barThings)
{
Console.WriteLine("Array. bar.fieldXXX: {0}", bar.fieldXXX);
Console.WriteLine("Array. bar.fieldYYY: {0}", bar.fieldYYY);
}
}
// Linq and enumerables -- no problem!
{
var fooArray = new FooClass[]
{
new FooClass {
fieldA = "foo.FieldA 1", fieldB = "foo.FieldB 1"
},
new FooClass {
fieldA = "foo.FieldA 2", fieldB = "foo.FieldB 2"
}
};
var fooThingsEnumerable = fooArray.AsEnumerable();
// This will throw InvalidCastException.
//var barThings = (IEnumerable<BarClass>)fooThingsEnumerable;
// But we don't care!
var barThings = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From <IEnumerable <FooClass> > .To <IEnumerable <BarClass> > .ForScience(fooThingsEnumerable);
foreach (var bar in barThings)
{
Console.WriteLine("Enumerable. bar.fieldXXX: {0}", bar.fieldXXX);
Console.WriteLine("Enumerable. bar.fieldYYY: {0}", bar.fieldYYY);
}
}
// Enhanced polymorphism without class hierarchy - Turn dogs into cats!
{
var cat = new Cat();
// This will not compile.
//var dog = (Dog)cat;
// But we don't care!
var dog = I.Donʼt.Do.This.Often.But.When.I.Do.I.Always.Cast.From <Cat> .To <Dog> .ForScience(cat);
Console.WriteLine("Cat says: {0}", cat.SaySomething());
Console.WriteLine("Cat became dog: {0}", dog.SaySomething());
}
// And many, many other fun application. :)
}