Unless you want to create functions that do this for you, you are, for the most part, out of luck. You could create a constructor for Class1 that accepts an instance of Class2 and copies all of the fields, allowing you to create a Class1 from a Class2, but that is about as good as it gets unless you want to get your hands dirty with reflection.
Here is the problem: polymorphism. Suppose you have ClassA, which is used to copy a file, and ClassB, which inherits from ClassA to extend it and copy files from the internet. ClassA has two properties: Source and Target, which specify from where and to where the file is copied. ClassA also defines a virtual (overridable) function named PerformCopy which copies the file. ClassB simply overrides PerformCopy, adding logic that allows files to be copied from a URL in addition to a file path.
Now you create an instance of ClassB whose Source is "ftp://ftp.mysite.com/somedoc.html". If you call PerformCopy the file will be copied from the Internet to the hard drive. However, if you force the object to an instance of ClassA all of a sudden it loses the capability to copy files from the Internet and your object is broken. Values that were valid are no longer valid.
Besides that, in the grand scheme of object-oriented programming, that type of conversion doesn't make much sense. It is like wanting to be able to change your rice from regular rice to pork fried rice and back again. You can't do that. It is what it is. Reality doesn't work that way, and OOP mimics that aspect of reality. Sorry, but you are stuck with white rice.
That being said, I wrote this function in VB that uses reflection to convert an object into an intance of a base class. The stipulation is that the base class must have a public default constructor and there is no guaruntee that there will be no broken objects as a result of lost polymorphism. Also, the code must be run in a full trust context.
Visual Basic:
Public Function DownCast(Of T As New)(ByVal source As Object) As T
'A System.Type that represents the base type we are converting to
'which we can use for reflection.
Dim targetType As Type = GetType(T)
'Throw an error if the source object does not derive from the target type.
If Not source.GetType.IsSubclassOf(GetType(T)) Then
Throw New ArgumentException("Source must be instance of a class derived from <T>.")
End If
'This is the resulting object, which is an instance of the base class.
Dim Result As New T
'Now we will loop through each field in the BASE CLASS and copy the value from
'the source object to the resulting object.
'(We need full trust because we must copy private members, which can't be accessed in partial trust contexts.)
For Each field As FieldInfo In targetType.GetFields(_
BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.FlattenHierarchy Or BindingFlags.Instance)
field.SetValue(Result, field.GetValue(source))
Next
Return Result
End Function
Sub SillyExample()
Dim Derived As New ArgumentException("message", "param name", New Exception())
Dim Base As Exception = DownCast(Of Exception)(Derived)
MessageBox.Show(Base.Message + " " + Base.InnerException.ToString())
End Sub
