/// <summary>
/// </summary>
public override void GenerateSchemaTypeObjects(PropertyInfo property, XmlSchemaType type, int level)
{
var atts = GetAttributes <ConfigurationPropertyAttribute>(property);
if (atts.Length == 0)
{
return;
}
XmlSchemaComplexType ct;
if (Generator.ComplexMap.ContainsKey(property.PropertyType))
{
//already done the work
ct = Generator.ComplexMap[property.PropertyType];
}
else
{
// got to generate a new one
ct = new XmlSchemaComplexType {
Name = atts[0].Name + "CT"
};
ct.AddAnnotation(property, null);
ct.CreateSchemaSequenceParticle();
Generator.ComplexMap.Add(property.PropertyType, ct);
Generator.Schema.Items.Add(ct);
// get all properties from the configuration object
var propertyInfos = GetProperties <ConfigurationPropertyAttribute>(property.PropertyType);
foreach (var pi in propertyInfos)
{
var parser = TypeParserFactory.GetParser(Generator, pi);
parser.GenerateSchemaTypeObjects(pi, ct, level + 1);
}
}
var element = new XmlSchemaElement
{
Name = atts[0].Name, // property.PropertyType.Name + "CT",
MinOccurs = atts[0].IsRequired ? 1 : 0,
SchemaTypeName = new XmlQualifiedName(XmlHelper.PrependNamespaceAlias(ct.Name))
};
var pct = (XmlSchemaComplexType)type;
((XmlSchemaGroupBase)pct.Particle).Items.Add(element);
// add the documentation
element.AddAnnotation(property, atts[0]);
}
/// <summary>
/// Convert the property into a schema object
/// </summary>
public override void GenerateSchemaTypeObjects(PropertyInfo property, XmlSchemaType type, int level)
{
Debug.IndentLevel = level;
Debug.WriteLine("{0} {1} {2}", level, property.Name, type.Name);
var configPropertyAtts = GetAttributes <ConfigurationPropertyAttribute>(property);
if (configPropertyAtts.Length == 0)
{
return;
}
var configCollPropertyAtts = GetAttributes <ConfigurationCollectionAttribute>(property);
if (configCollPropertyAtts.Length == 0)
{
configCollPropertyAtts = GetAttributes <ConfigurationCollectionAttribute>(property.PropertyType);
}
if (configCollPropertyAtts.Length == 0)
{
return;
}
var configAttribute = configPropertyAtts[0];
var configCollAttribute = configCollPropertyAtts[0];
XmlSchemaComplexType ct;
var typeAlreadyInSchema = false;
if (Generator.ComplexMap.ContainsKey(property.PropertyType))
{
//already done the work
typeAlreadyInSchema = true;
ct = Generator.ComplexMap[property.PropertyType];
}
else
{
// got to generate a new one for the collection
ct = new XmlSchemaComplexType
{
Name = configAttribute.Name + "CT",
};
var seq = new XmlSchemaChoice
{
MinOccurs = 0,
MaxOccursString = "unbounded"
};
ct.Particle = seq;
Generator.ComplexMap.Add(property.PropertyType, ct);
Generator.Schema.Items.Add(ct);
}
var element = new XmlSchemaElement
{
Name = configAttribute.Name,
MinOccurs = configAttribute.IsRequired ? 1 : 0,
SchemaTypeName = new XmlQualifiedName(XmlHelper.PrependNamespaceAlias(ct.Name))
};
var pct = (XmlSchemaComplexType)type;
var items = ((XmlSchemaGroupBase)pct.Particle).Items;
if (items.OfType <XmlSchemaElement>().All(x => x.Name != element.Name))
{
items.Add(element);
}
// get all properties from the configuration object
foreach (var pi in GetProperties <ConfigurationPropertyAttribute>(property.PropertyType))
{
Debug.WriteLine("ConfigurationProperty: " + pi.Name);
var parser = TypeParserFactory.GetParser(Generator, pi);
parser.GenerateSchemaTypeObjects(pi, ct, level + 1);
}
// add the documentation
element.AddAnnotation(property, configPropertyAtts[0]);
// at this point the element has been added to the schema
// but we now need to add support for the child elements
if (!typeAlreadyInSchema)
{
AddCollectionChildren((XmlSchemaGroupBase)ct.Particle, configCollAttribute, level);
}
}
/// <summary>
/// Adds the child elements of the collection
/// </summary>
protected void AddCollectionChildren(XmlSchemaGroupBase parentParticle, ConfigurationCollectionAttribute configCollAttribute, int level)
{
Debug.IndentLevel = level;
XmlSchemaComplexType ct;
if (Generator.ComplexMap.ContainsKey(configCollAttribute.ItemType))
{
//already done the work
ct = Generator.ComplexMap[configCollAttribute.ItemType];
}
else
{
// got to generate a new one for the collection
ct = new XmlSchemaComplexType {
Name = configCollAttribute.ItemType.Name + "CT"
};
ct.CreateSchemaSequenceParticle();
Generator.ComplexMap.Add(configCollAttribute.ItemType, ct);
Generator.Schema.Items.Add(ct);
}
// add method
var addElement = new XmlSchemaElement
{
Name = configCollAttribute.AddItemName,
MinOccurs = 0,
SchemaTypeName = new XmlQualifiedName(XmlHelper.PrependNamespaceAlias(ct.Name))
};
// ok we now have the child element as a complextype object
// but we need to add three elements to the parent complex type
// which support the add / remove / clear methods of the collection
// if we must add a clear method then it has to come first
// the basic map types do not include the clear and remove methods
if (configCollAttribute.CollectionType == ConfigurationElementCollectionType.AddRemoveClearMap ||
configCollAttribute.CollectionType == ConfigurationElementCollectionType.AddRemoveClearMapAlternate)
{
// clear method (which is a simple element)
var element = new XmlSchemaElement
{
Name = configCollAttribute.ClearItemsName,
MinOccurs = 0,
MaxOccurs = 1,
//SchemaType = new XmlSchemaComplexType()
};
parentParticle.Items.Add(element);
// remove method
element = new XmlSchemaElement
{
MinOccurs = 0,
Name = configCollAttribute.RemoveItemName
};
var removeCt = new XmlSchemaComplexType();
element.SchemaType = removeCt;
// get the type contained in the collection and work out
// what the key property is
var childElementType = configCollAttribute.ItemType;
var found = false;
foreach (var pi in childElementType.GetProperties())
{
if (found)
{
break;
}
Debug.WriteLine("Child property: " + pi.Name);
var cpAtts = GetAttributes <ConfigurationPropertyAttribute>(pi);
// this should return a standardtypeparser object, if it doesnt
// then it means that the key of the element was an element
// itself and I don't think that is possible!
if (cpAtts.Any(att => att.IsKey))
{
var parser = TypeParserFactory.GetParser(Generator, pi);
parser.GenerateSchemaTypeObjects(pi, removeCt, level + 1);
found = true;
}
}
parentParticle.Items.Add(element);
SetMaxOccurs(element, parentParticle);
}
SetMaxOccurs(addElement, parentParticle);
parentParticle.Items.Add(addElement);
// get all properties from the configuration object
var propertyInfos = GetProperties <ConfigurationPropertyAttribute>(configCollAttribute.ItemType);
foreach (var pi in propertyInfos)
{
var parser = TypeParserFactory.GetParser(Generator, pi);
Debug.WriteLine("\tConfigurationProperty: {0} {1}", pi.Name, parser.GetType());
parser.GenerateSchemaTypeObjects(pi, ct, level + 1);
}
}