class Foo
{
	public string field1;
	public string field2;
}

class Bar
{
	public string field1;
	public string field2;
}

var foo = new Foo();
var bar = (Bar)foo;      // does not compile, obviously

public enum Foo : int
{
	one,
	two,
	three,
}

var enumArray = new Foo[]{Foo.one, Foo.two, Foo.three};
var intArray = (int[])enumArray;   // does not compile either

pubic class Foo
{
	private string fieldA;
}

var foo = new Foo();
var field = foo.fieldA;  // private field, no can do

// C#
using Magicast;

// Cast anything to anything
var result = VeryUnsafeCast<FromType, ToType>.Cast(object_to_cast);

public class Foo<T> where T:enum	// Nope
{
}

public class BadFoo<T> where T:struct			// OK
{
	public int CastToInt(T value)
	{
		// naive approach
		return (int)value;						// Nope: error CS0030: Cannot convert type 'T' to 'int'

		// go via object works but involves boxing
		var obj = (object)value;				// boxing!
		return (int)obj;
	}

	// even worse for arrays
	public int[] CastToIntArray(T[] values)
	{
		return (int[])values;					// obviously doesn't compile

		// same trick to go via object? Nope, doesn't work!
		object[] objects = (object[])values;	// does not compile
		return (int[])objects;					// does not compile either

		// OK, need to do a loop then!
		// Great performance guaranteed. Not.
		var result = new int[values.Length];
		for (int i = 0; i < values.Length; i++)
		{
			// result[i] = (int)values[i];		// damn, this doesn't compile again!
			
			// use the same trick to go via object
			// but boxing!
			object obj = (object)values[i];		// boxing
			result[i] = (int)obj;
		}
		
		return result;



		// But, who writes for loops these days? Everybody's using Linq!
		// ... and your performance has just gone out of the window.
		return values.Cast<object>().Cast<int>().ToArray();
	}
}

use Magicast;

public class GoodFoo<T> where T:struct						// OK, let it be struct
{
	public int CastToInt(T value)
	{
		return VeryUnsafeCast<T, int>.Cast(value);			// works, no boxing
	}

	public int[] CastToIntArray(T[] values)
	{
		return VeryUnsafeCast<T[], int[]>.Cast(values);		// also works, no loops, no boxing
	}
}

public class Foo
{
	private string fieldA;
}

// Declare a type with same fields as Foo and make fields public
public class Bar
{
	public string fieldA;
}

// Magicast
var foo = new Foo();
var bar = VeryUnsafeCast<Foo, Bar>(foo);

// Get to those fields!
bar.fieldA = "hello!";

var array = new string[]{"one", "two", "three"};

// Declare a type with fields like this:
class ArrayView
{
	private object padding;  // required

	// Yep, it even works with auto properties
	// Yep, even with read-only properties
	public string ElementZero {get;}
	public string ElementOne {get;}
}

// Magicast
var view = VeryUnsafeCast<string[], ArrayView>()

// Access them array elements!
var s0 = view.ElementZero;		// equivalent of array[0]
var s1 = view.ElementZero;		// equivalent of array[1]

// Declare two types with same propeties: 
//	- one for internal use with get/set properties
//  - one for public use, just with get properties

internal class FooInternal
{
	public string AutoPropA {get; set;}
	public string AutoPropB {get; set;}
}

public class FooPublic
{
	public string AutoPropA {get;}
	public string AutoPropB {get;}
}


// Implement your method like this.
public FooPublic SomeMethod()
{
	// Use FooInternal to build the object.
	// Use Magicast to turn it into immutable version when you are done.

	var foo = new FooInternal
	{
		AutoPropA = "some value",
		AutoPropB = "some other value",
	};

	var immutable = VeryUnsafeCast<FooInternal, FooPublic>.Cast(foo);

	return immutable;
}

public class Cat
{
	public string name; 

	public string SaySomethingLikeACat()
	{
		return "Meaeoew" + this.name;
	}
}

public class Dog
{
	public string name;

	public string SaySomethingLikeADog()
	{
		return "Woof Woof " + this.name;
	}
}

var cat = new Cat
{
	name = "fluffy cat"
};

var dog = VeryUnsafeCast<Cat, Dog>.Cast(cat);

cat.SaySomethingLikeACat(); // --> Meaeoew fuluffy cat
dog.SaySomethingLikeADog(); // --> Woof Woof fluffy cat

// Arrays -- should just work
var arrayOfFoo = new Foo[]{....};
var arrayOfBar = VeryUnsafeCast<Foo[], Bar[]>.Cast(arrayOfFoo);


// List -- should also work
var listOfFoo = new List<Foo>{....};
var listOfBar = VeryUnsafeCast<List<Foo>, List<Bar>>.Cast(listOfFoo);


// Dictionary -- change of value types
var mapOfStringToFoo = new Dictionary<string, Foo>{....};
vaf mapOfStringToBar = VeryUnsafeCast<Dictionary<string, Foo>, Dictionary<string, Bar>>.Cast(mapOfStringToFoo);