Can I fake a parent element in a serializable class?

[sandycormie]

Hello

I suspect the answer is going to be no, but...

I have a class that contains a property defined as an abstract class.
I would like to control the format of the generated XML to include a
container element that isn't actually implemented in my class.

This is best described by an example.

I have an abstract class that represents an expression:

public abstract class Expression {...}

I have extended this abstract class with various types of expression,
e.g.

public class Literal : Expression {...}
public class Field : Expression {...}
public class Operation : Expression {...}

I make use of this abstract class in another class, exposing it as a
property:

public class Comparison
{
private Expression _argument1;
private Expression _argument2;

public Expression Argument1
{
get {return _expression;}
set {_expression = value;}
}

public Expression Argument2
{
get {return _expression;}
set {_expression = value;}
}
}

To prepare the class for serialization, I decorate it using
[Serializable] and adding [XmlElement] attributes to the public
properties:

[Serializable]
public class Comparison
{
private Expression _argument1;
private Expression _argument2;

[XmlElement("literal", typeof(Literal))]
[XmlElement("field", typeof(Field))]
[XmlElement("operation", typeof(Operation))]
public Expression Argument1
{
get {return _expression;}
set {_expression = value;}
}

[XmlElement("literal", typeof(Literal))]
[XmlElement("field", typeof(Field))]
[XmlElement("operation", typeof(Operation))]
public Expression Argument2
{
get {return _expression;}
set {_expression = value;}
}
}

When argument 1 is a field and argument 2 is a literal (for example),
this generates XML of the form

<Comparison>
<field>
--field elements
</field>
<literal>
--literal elements
</literal>
</Comparison>

However, what I really want is XML of the form:

<Comparison>
<argument1>
<field>
--field elements
</field>
</argument1>
<argument2>
<literal>
--literal elements
</literal>
</argument2>
</Comparison>

So my question is: can this be achieved without physically
implementing a container class to represent the argument elements?

i.e. I don't want to have to change my class model by introducing a new
class.

Thanks very much

Sandy