Data Member Order

In some applications, it is useful to know the order in which data from the various data members is sent or is expected to be received (such as the order in which data appears in the serialized XML). Sometimes it may be necessary to change this order. This topic explains the ordering rules.

Basic Rules

The basic rules for data ordering include:

  • If a data contract type is a part of an inheritance hierarchy, data members of its base types are always first in the order.

  • Next in order are the current type’s data members that do not have the Order property of the DataMemberAttribute attribute set, in alphabetical order.

  • Next are any data members that have the Order property of the DataMemberAttribute attribute set. These are ordered by the value of the Order property first and then alphabetically if there is more than one member of a certain Order value. Order values may be skipped.

Alphabetical order is established by calling the CompareOrdinal method.

Examples

Consider the following code.

Visual Basic
<DataContract()> _
Public Class BaseType
    <DataMember()> Public zebra As String
End Class

<DataContract()> _
Public Class DerivedType
    Inherits BaseType
    <DataMember(Order:=0)> Public bird As String
    <DataMember(Order:=1)> Public parrot As String
    <DataMember()> Public dog As String
    <DataMember(Order:=3)> Public antelope As String
    <DataMember()> Public cat As String
    <DataMember(Order:=1)> Public albatross As String
End Class
C#
[DataContract]
public class BaseType
{

    [DataMember]
    public string zebra;
}
[DataContract]
public class DerivedType : BaseType
{
    [DataMember(Order = 0)]
    public string bird;
    [DataMember(Order = 1)]
    public string parrot;
    [DataMember]
    public string dog;
    [DataMember(Order = 3)]
    public string antelope;
    [DataMember]
    public string cat;
    [DataMember(Order = 1)]
    public string albatross;
}

The XML produced is similar to the following.

<DerivedType>
    <!-- Zebra is a base data member, and appears first. -->
    <zebra/> 

    <!-- Cat has no Order, appears alphabetically first. -->
    <cat/>
    
   <!-- Dog has no Order, appears alphabetically last. -->
    <dog/> 

    <!-- Bird is the member with the smallest Order value -->
    <bird/>

    <!-- Albatross has the next Order value, alphabetically first. -->
    <albatross/>

    <!-- Parrot, with the next Order value, alphabetically last. -->
     <parrot/>

    <!-- Antelope is the member with the highest Order value. Note that 
    Order=2 is skipped -->
     <antelope/> 
</DerivedType>

See Also

Tags :


Community Content

TWildeman
Order also important when deserializing
For all data that's XML over the line. Like for WebServices using SOAP, REST and so on. Order is important, with the deserialisation of XML.
When you have a DataContract with DataMembers without an order specified the order is 'silently' specified through CompareOrdinal. Above is stated that in some cases it is useful to know the order in which data is sent or received. But it is not useful, it is a requirement. When you send XML like:
<Booking>
<ID>1</ID>
<FirstName>Me</FirstName>
<LastName>To</LastName>
</Booking>

And the DataContract for the class Booking has EmitDefaultValue = false and NO order specified for it's DataMembers. The element FirstName is not being deserialized! The key is the CompareOrdinal, which, effectively, looks at the alphabetical order. The F in FirstName has a higher Ordinal than the I in ID, and is therefore silently NOT deserialized. When changing the order to:
<Booking>
<FirstName>Me</FirstName>
<ID>1</ID>
<LastName>To</LastName>
</Booking>

the FirstName element is correctly deserialized.

It's possible to override this behaviour by extending the DataContractSerializer, and overriding the appropriate methods.

Page view tracker