Properties

AutomaticProperties

Auto-implemented properties make property-declaration more concise when no additional logic is required in the property accessors. It is possible to activate this option in xsd2code++ to obtain a more compact code, which improves the readability of classes.

LazyLoading

This parameter allows to instantiate objects only at the moment of their use. Here is an example of generated code :

Lazy initialization is a technique that defers the creation of an object until the first time it is needed. In other words, initialization of the object happens only on demand. Note that the terms lazy initialization and lazy instantiation mean the same thing—they can be used interchangeably. By taking advantage of lazy initialization, you can improve the application’s performance by avoiding unnecessary computation and memory consumption. In this article we’ll look at how we can perform lazy initialization in C# with xsd2code++.

To enable this feature, you must set it in the settings: PROPERTIES.LAZYLOADING (TRUE/FALSE)

public List<dvd> Dvds
{
    get
    {
        if ((dvdsField == null))
        {
            dvdsField = new List<dvd>();
        }
        return dvdsField;
    }
    set
    {
        ...
}
}

NotifyPropertyChanged

The INotifyPropertyChanged interface is used to notify clients, typically binding clients, that a property value has changed. 
For example, consider a Person object with a property called FirstName. To provide generic property-change notification, the Person type implements the INotifyPropertyChanged interface and raises a PropertyChanged event when FirstName is changed.

For change notification to occur in a binding between a bound client and a data source, xsd2code++ generates the code that :

- Implement the INotifyPropertyChanged interface.

- Provide a change event à each time the value is changed or set to null.

public partial class RootSchemaCustomer : INotifyPropertyChanged
{
    #region Private fields
    private PurchaseOrderType _purchaseOrder;
    private static MessagePackSerializer _serializer;
    #endregion
 
    public RootSchemaCustomer()
    {
        _purchaseOrder = new PurchaseOrderType();
    }
 
    public PurchaseOrderType PurchaseOrder
    {
        get
        {
            return _purchaseOrder;
        }
        set
        {
            if ((_purchaseOrder == value))
            {
                return;
            }
            if (((_purchaseOrder == null)
                        || (_purchaseOrder.Equals(value) != true)))
            {
                _purchaseOrder = value;
                OnPropertyChanged("PurchaseOrder");
            }
        }
    }

PascalCaseProperty

PascalCase is a naming convention in which the first letter of each word in a compound word is capitalized. If you use this naming convention, you can activate it in your generated classes.

Xsd2Code++ takes care of injecting the necessary attributes to maintain compliance with the XML or JSON schema.

Private fields name & Prefix

Within the naming convention that you wish to adopt, you have the possibility to define if the private elements begin or end with :

• StartWithUnderscore : private bool _isEnabled;
• EndWithField : private bool isEnabledField;
• StartWithCustomPrefix : private bool _p_isEnabled;

PropertyNameSpecified

Specified Conditional Serialization Pattern allows to exclude properties during the serialization process.
This parameter is used to generate additional properties which are used to determine whether a property should be serialized or not. There are several possibilities:

public int PublishYear
{
    get
    {
        return _publishYear;
    }
    set
    {
        _publishYear = value;
    }
}
 
[XmlIgnore()]
public bool PublishYearSpecified
{
    get
    {
        return _publishYearSpecified;
    }
    set
    {
        _publishYearSpecified = value;
    }
}

DvdCollection collectionDvd = new DvdCollection();
dvd newdvd = new dvd();
newdvd.PublishYear = 2000;
newdvd.PublishYearSpecified = true;
collectionDvd.Dvds.Add(newdvd);
collectionDvd.DvdsSpecified = true;
collectionDvd.SaveToFile("c:\temp\dvds.xml");

VirtualProperties

Virtual properties behave like virtual methods, except for the differences in declaration and invocation syntax.
A virtual inherited property can be overridden in a derived class by including a property declaration that uses the override modifier.

public virtual PurchaseOrderType PurchaseOrder
{
    ...
}

public override PurchaseOrderType PurchaseOrder
{
    ...
}

ExpandObjectItem

While working with the international pioneer in the aerospace sector Airbus we were led to interacting with schemas that contained elements whose types could be chosen from a list.
This new setting "ExpandObjectItem" ensures theses situation are handled properly by the generator.
With this setting enabled, wherever you could find a choice between types, you will now find in your generated class distinct properties for every choice available, giving you the option to use the option you need.

In the example given above, our choice is to be made between "SupportDig" and "SupportPhy", being an xsd we are dealing with an xs:choice. Here's what it looks like in a C# class generated with the ExpandObjectItem setting enabled.

By default Xsd2Code++ can handle xs:choices without enabling this setting, when you're using an xsd with choices you have the option to use this setting. Here's what it look like by default, thanks to .Net it can be done by taking it through an item list with the help of the built in Xml tools.

The main reason why this setting was put in place is JSon, by default Xsd2code++ won't be able to generate appropriate code without this setting enabled
So if you have a choice to make in JSon you NEED to enable the "ExpandObjectItem" setting, here's what the JSon equivalent of an xs:choice looks like :