mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
772 lines
30 KiB
C#
772 lines
30 KiB
C#
#region Copyright (c) Microsoft Corporation
|
|
/// <copyright company='Microsoft Corporation'>
|
|
/// Copyright (c) Microsoft Corporation. All Rights Reserved.
|
|
/// Information Contained Herein is Proprietary and Confidential.
|
|
/// </copyright>
|
|
#endregion
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Reflection;
|
|
using System.Xml;
|
|
using System.Xml.Schema;
|
|
|
|
#if WEB_EXTENSIONS_CODE
|
|
using System.Web.Resources;
|
|
#else
|
|
using Microsoft.VSDesigner.WCF.Resources;
|
|
#endif
|
|
|
|
#if WEB_EXTENSIONS_CODE
|
|
namespace System.Web.Compilation.WCFModel
|
|
#else
|
|
namespace Microsoft.VSDesigner.WCFModel
|
|
#endif
|
|
{
|
|
/// <summary>
|
|
/// a utility class to merge schema files, and remove duplicated part
|
|
/// </summary>
|
|
internal class SchemaMerger
|
|
{
|
|
// xml serializable attributes
|
|
private static Type[] xmlSerializationAttributes = new Type[] {
|
|
typeof(System.Xml.Serialization.XmlElementAttribute),
|
|
typeof(System.Xml.Serialization.XmlAttributeAttribute),
|
|
typeof(System.Xml.Serialization.XmlAnyAttributeAttribute),
|
|
typeof(System.Xml.Serialization.XmlAnyElementAttribute),
|
|
typeof(System.Xml.Serialization.XmlTextAttribute),
|
|
};
|
|
|
|
// elements in the schema (we don't process annotation node)
|
|
private static SchemaTopLevelItemType[] schemaTopLevelItemTypes = new SchemaTopLevelItemType[] {
|
|
new SchemaTopLevelItemType(typeof(XmlSchemaType), "type"),
|
|
new SchemaTopLevelItemType(typeof(XmlSchemaElement), "element"),
|
|
new SchemaTopLevelItemType(typeof(XmlSchemaAttribute), "attribute"),
|
|
new SchemaTopLevelItemType(typeof(XmlSchemaGroup), "group"),
|
|
new SchemaTopLevelItemType(typeof(XmlSchemaAttributeGroup), "attributeGroup"),
|
|
};
|
|
|
|
// when properties defined in those types are different, we only report warnings, but not error messages
|
|
private static Type[] ignorablePropertyTypes = new Type[] {
|
|
typeof(XmlAttribute[]),
|
|
typeof(XmlElement[]),
|
|
typeof(XmlNode[]),
|
|
typeof(XmlSchemaAnnotation),
|
|
};
|
|
|
|
private readonly static XmlAttribute[] emptyXmlAttributeCollection = new XmlAttribute[0];
|
|
private readonly static object[] emptyCollection = new object[0];
|
|
|
|
/// <summary>
|
|
/// Merge and remove duplicated part from the schema list
|
|
/// </summary>
|
|
/// <param name="schemaList">schemas with names</param>
|
|
/// <param name="importErrors">error messages</param>
|
|
/// <param name="duplicatedSchemas">error messages</param>
|
|
/// <remarks></remarks>
|
|
internal static void MergeSchemas(IEnumerable<XmlSchema> schemaList, IList<ProxyGenerationError> importErrors, out IEnumerable<XmlSchema> duplicatedSchemas)
|
|
{
|
|
if (schemaList == null)
|
|
{
|
|
throw new ArgumentNullException("schemaList");
|
|
}
|
|
if (importErrors == null)
|
|
{
|
|
throw new ArgumentNullException("importErrors");
|
|
}
|
|
|
|
List<XmlSchema> duplicatedSchemaList = new List<XmlSchema>();
|
|
duplicatedSchemas = duplicatedSchemaList;
|
|
|
|
// types, elements, groups have their own name space
|
|
Dictionary<XmlQualifiedName, XmlSchemaObject>[] knownItemTables = new Dictionary<XmlQualifiedName, XmlSchemaObject>[schemaTopLevelItemTypes.Length];
|
|
for (int i = 0; i < schemaTopLevelItemTypes.Length; i++)
|
|
{
|
|
knownItemTables[i] = new Dictionary<XmlQualifiedName, XmlSchemaObject>();
|
|
}
|
|
|
|
foreach (XmlSchema schema in schemaList)
|
|
{
|
|
|
|
bool hasNewDefinedItems = false;
|
|
List<XmlSchemaObject> duplicatedItems = new List<XmlSchemaObject>();
|
|
|
|
for (int i = 0; i < schemaTopLevelItemTypes.Length; i++)
|
|
{
|
|
Dictionary<XmlQualifiedName, XmlSchemaObject> knownItemTable = knownItemTables[i];
|
|
int knownItemCount = knownItemTable.Count;
|
|
FindDuplicatedItems(schema, schemaTopLevelItemTypes[i].ItemType, schemaTopLevelItemTypes[i].Name, knownItemTable, duplicatedItems, importErrors);
|
|
if (knownItemTable.Count > knownItemCount)
|
|
{
|
|
hasNewDefinedItems = true;
|
|
}
|
|
}
|
|
|
|
if (duplicatedItems.Count > 0)
|
|
{
|
|
if (!hasNewDefinedItems)
|
|
{
|
|
// remove the whole schema...
|
|
duplicatedSchemaList.Add(schema);
|
|
}
|
|
else
|
|
{
|
|
// remove duplicated items only
|
|
foreach (XmlSchemaObject item in duplicatedItems)
|
|
{
|
|
schema.Items.Remove(item);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find duplicated items in a schema
|
|
/// </summary>
|
|
/// <remarks></remarks>
|
|
private static void FindDuplicatedItems(
|
|
XmlSchema schema,
|
|
Type itemType,
|
|
string itemTypeName,
|
|
Dictionary<XmlQualifiedName, XmlSchemaObject> knownItemTable,
|
|
List<XmlSchemaObject> duplicatedItems,
|
|
IList<ProxyGenerationError> importErrors)
|
|
{
|
|
|
|
string targetNamespace = schema.TargetNamespace;
|
|
if (String.IsNullOrEmpty(targetNamespace))
|
|
{
|
|
targetNamespace = String.Empty;
|
|
}
|
|
|
|
foreach (XmlSchemaObject item in schema.Items)
|
|
{
|
|
if (itemType.IsInstanceOfType(item))
|
|
{
|
|
|
|
XmlQualifiedName combinedName = new XmlQualifiedName(GetSchemaItemName(item), targetNamespace);
|
|
|
|
XmlSchemaObject originalItem = null;
|
|
if (knownItemTable.TryGetValue(combinedName, out originalItem))
|
|
{
|
|
string differentLocation;
|
|
|
|
if (!AreSchemaObjectsEquivalent(originalItem, item, out differentLocation))
|
|
{
|
|
differentLocation = CombinePath(".", differentLocation);
|
|
importErrors.Add(
|
|
new ProxyGenerationError(
|
|
ProxyGenerationError.GeneratorState.MergeMetadata,
|
|
String.Empty,
|
|
new InvalidOperationException(
|
|
String.Format(CultureInfo.CurrentCulture, WCFModelStrings.ReferenceGroup_DuplicatedSchemaItems, itemTypeName, combinedName.ToString(), schema.SourceUri, originalItem.SourceUri, differentLocation)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
else if (!String.IsNullOrEmpty(differentLocation))
|
|
{
|
|
// warning: ignorable difference found
|
|
differentLocation = CombinePath(".", differentLocation);
|
|
importErrors.Add(
|
|
new ProxyGenerationError(
|
|
ProxyGenerationError.GeneratorState.MergeMetadata,
|
|
String.Empty,
|
|
new InvalidOperationException(
|
|
String.Format(CultureInfo.CurrentCulture, WCFModelStrings.ReferenceGroup_DuplicatedSchemaItemsIgnored, itemTypeName, combinedName.ToString(), schema.SourceUri, originalItem.SourceUri, differentLocation)
|
|
),
|
|
true // isWarning = true
|
|
)
|
|
);
|
|
}
|
|
duplicatedItems.Add(item);
|
|
}
|
|
else
|
|
{
|
|
item.SourceUri = schema.SourceUri;
|
|
knownItemTable.Add(combinedName, item);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare two schema objects
|
|
/// </summary>
|
|
/// <return></return>
|
|
/// <remarks>
|
|
/// For all those functions, we follow the same pattern:
|
|
/// return false: find not-ignorable difference between them. differentLocation will contain the path
|
|
/// return true, with empty differentLocation -- no difference found
|
|
/// return true, with non-empty differentLocation -- ignorable difference found under that location
|
|
/// </remarks>
|
|
private static bool AreSchemaObjectsEquivalent(XmlSchemaObject originalItem, XmlSchemaObject item, out string differentLocation)
|
|
{
|
|
differentLocation = String.Empty;
|
|
|
|
Type itemType = originalItem.GetType();
|
|
if (itemType != item.GetType())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
string ignorableDifferenceLocation = String.Empty;
|
|
|
|
PropertyInfo[] properties = itemType.GetProperties();
|
|
foreach (PropertyInfo property in properties)
|
|
{
|
|
if (IsPersistedProperty(property))
|
|
{
|
|
|
|
bool ignorableProperty = ShouldIgnoreSchemaProperty(property);
|
|
|
|
object originalValue = property.GetValue(originalItem, new object[] { });
|
|
object newValue = property.GetValue(item, new object[] { });
|
|
|
|
if (!CompareSchemaPropertyValues(property, originalValue, newValue, out differentLocation) && !ignorableProperty)
|
|
{
|
|
return false;
|
|
}
|
|
if (String.IsNullOrEmpty(ignorableDifferenceLocation))
|
|
{
|
|
ignorableDifferenceLocation = differentLocation;
|
|
}
|
|
}
|
|
}
|
|
|
|
differentLocation = ignorableDifferenceLocation;
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare two property of a schema object
|
|
/// </summary>
|
|
/// <return>true: if the value are same</return>
|
|
/// <remarks></remarks>
|
|
private static bool CompareSchemaPropertyValues(PropertyInfo propertyInfo, object originalValue, object newValue, out string differentLocation)
|
|
{
|
|
differentLocation = String.Empty;
|
|
|
|
if (originalValue == null && newValue == null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// we create empty collection so a meaningful differentLocation could be generated
|
|
if (typeof(XmlAttribute[]) == propertyInfo.PropertyType)
|
|
{
|
|
if (originalValue == null)
|
|
{
|
|
originalValue = emptyXmlAttributeCollection;
|
|
}
|
|
if (newValue == null)
|
|
{
|
|
newValue = emptyXmlAttributeCollection;
|
|
}
|
|
|
|
XmlAttribute differentAttribute1, differentAttribute2;
|
|
if (!CompareXmlAttributeCollections((XmlAttribute[])originalValue, (XmlAttribute[])newValue, out differentAttribute1, out differentAttribute2))
|
|
{
|
|
differentLocation = GetSchemaPropertyNameInXml(propertyInfo, differentAttribute1, differentAttribute2);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (typeof(System.Collections.ICollection).IsAssignableFrom(propertyInfo.PropertyType))
|
|
{
|
|
if (originalValue == null)
|
|
{
|
|
originalValue = emptyCollection;
|
|
}
|
|
if (newValue == null)
|
|
{
|
|
newValue = emptyCollection;
|
|
}
|
|
|
|
object differentItem1, differentItem2;
|
|
if (!CompareSchemaCollections((System.Collections.ICollection)originalValue, (System.Collections.ICollection)newValue, out differentItem1, out differentItem2, out differentLocation))
|
|
{
|
|
differentLocation = CombinePath(GetSchemaPropertyNameInXml(propertyInfo, differentItem1, differentItem2), differentLocation);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (!String.IsNullOrEmpty(differentLocation))
|
|
{
|
|
// ignorable difference...
|
|
differentLocation = CombinePath(GetSchemaPropertyNameInXml(propertyInfo, differentItem1, differentItem2), differentLocation);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (originalValue == null || newValue == null)
|
|
{
|
|
differentLocation = CombinePath(GetSchemaPropertyNameInXml(propertyInfo, originalValue, newValue), differentLocation);
|
|
return false;
|
|
}
|
|
|
|
if (originalValue.GetType() != newValue.GetType())
|
|
{
|
|
differentLocation = CombinePath(GetSchemaPropertyNameInXml(propertyInfo, originalValue, newValue), differentLocation);
|
|
return false;
|
|
}
|
|
|
|
if (!CompareSchemaValues(originalValue, newValue, out differentLocation))
|
|
{
|
|
differentLocation = CombinePath(GetSchemaPropertyNameInXml(propertyInfo, originalValue, newValue), differentLocation);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// ignorable difference...
|
|
if (!String.IsNullOrEmpty(differentLocation))
|
|
{
|
|
differentLocation = CombinePath(GetSchemaPropertyNameInXml(propertyInfo, originalValue, newValue), differentLocation);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare two schema values
|
|
/// </summary>
|
|
/// <return></return>
|
|
/// <remarks></remarks>
|
|
private static bool CompareSchemaValues(object originalValue, object newValue, out string differentLocation)
|
|
{
|
|
differentLocation = String.Empty;
|
|
|
|
if (originalValue == null || newValue == null)
|
|
{
|
|
return (originalValue == null && newValue == null);
|
|
}
|
|
|
|
if (originalValue.GetType() != newValue.GetType())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (originalValue is XmlSchemaObject)
|
|
{
|
|
return AreSchemaObjectsEquivalent((XmlSchemaObject)originalValue, (XmlSchemaObject)newValue, out differentLocation);
|
|
}
|
|
|
|
if (originalValue is XmlAttribute)
|
|
{
|
|
return CompareXmlAttributes((XmlAttribute)originalValue, (XmlAttribute)newValue);
|
|
}
|
|
|
|
if (originalValue is XmlElement)
|
|
{
|
|
return CompareXmlElements((XmlElement)originalValue, (XmlElement)newValue, out differentLocation);
|
|
}
|
|
|
|
if (originalValue is XmlText)
|
|
{
|
|
return CompareXmlTexts((XmlText)originalValue, (XmlText)newValue);
|
|
}
|
|
|
|
return originalValue.Equals(newValue);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare two collections of items
|
|
/// </summary>
|
|
/// <return></return>
|
|
/// <remarks></remarks>
|
|
private static bool CompareSchemaCollections(System.Collections.IEnumerable originalCollection, System.Collections.IEnumerable newCollection,
|
|
out object differentItem1, out object differentItem2, out string differentLocation)
|
|
{
|
|
|
|
differentLocation = String.Empty;
|
|
|
|
System.Collections.IEnumerator list1 = originalCollection.GetEnumerator();
|
|
System.Collections.IEnumerator list2 = newCollection.GetEnumerator();
|
|
|
|
string ignorableDifferenceLocation = String.Empty;
|
|
object ignorableDifferenceItem1 = null;
|
|
object ignorableDifferenceItem2 = null;
|
|
|
|
do
|
|
{
|
|
differentItem1 = list1.MoveNext() ? list1.Current : null;
|
|
differentItem2 = list2.MoveNext() ? list2.Current : null;
|
|
|
|
if (!CompareSchemaValues(differentItem1, differentItem2, out differentLocation))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (String.IsNullOrEmpty(ignorableDifferenceLocation))
|
|
{
|
|
ignorableDifferenceItem1 = differentItem1;
|
|
ignorableDifferenceItem2 = differentItem2;
|
|
ignorableDifferenceLocation = differentLocation;
|
|
}
|
|
}
|
|
while (differentItem1 != null && differentItem2 != null);
|
|
|
|
Debug.Assert(differentItem1 == null && differentItem2 == null);
|
|
|
|
differentLocation = ignorableDifferenceLocation;
|
|
differentItem1 = ignorableDifferenceItem1;
|
|
differentItem2 = ignorableDifferenceItem2;
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare two attributes
|
|
/// </summary>
|
|
/// <return></return>
|
|
/// <remarks></remarks>
|
|
private static bool CompareXmlAttributes(XmlAttribute attribute1, XmlAttribute attribute2)
|
|
{
|
|
return String.Equals(attribute1.LocalName, attribute2.LocalName, StringComparison.Ordinal) &&
|
|
String.Equals(attribute1.NamespaceURI, attribute2.NamespaceURI, StringComparison.Ordinal) &&
|
|
String.Equals(attribute1.Value, attribute2.Value, StringComparison.Ordinal);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare two attribute collections
|
|
/// </summary>
|
|
/// <return></return>
|
|
/// <remarks></remarks>
|
|
private static bool CompareXmlAttributeCollections(System.Collections.ICollection attributeCollection1, System.Collections.ICollection attributeCollection2, out XmlAttribute differentAttribute1, out XmlAttribute differentAttribute2)
|
|
{
|
|
differentAttribute1 = null;
|
|
differentAttribute2 = null;
|
|
|
|
XmlAttribute[] attributeArray1 = GetSortedAttributeArray(attributeCollection1);
|
|
XmlAttribute[] attributeArray2 = GetSortedAttributeArray(attributeCollection2);
|
|
|
|
object differentItem1, differentItem2;
|
|
string differentLocation;
|
|
if (!CompareSchemaCollections(attributeArray1, attributeArray2, out differentItem1, out differentItem2, out differentLocation))
|
|
{
|
|
differentAttribute1 = (XmlAttribute)differentItem1;
|
|
differentAttribute2 = (XmlAttribute)differentItem2;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// sort XmlAttribute array, so we can compare two collections without being affected by the order
|
|
/// </summary>
|
|
/// <return></return>
|
|
/// <remarks></remarks>
|
|
private static XmlAttribute[] GetSortedAttributeArray(System.Collections.ICollection attributeCollection)
|
|
{
|
|
XmlAttribute[] attributeArray = new XmlAttribute[attributeCollection.Count];
|
|
int index = 0;
|
|
foreach (XmlAttribute attribute in attributeCollection)
|
|
{
|
|
attributeArray[index++] = attribute;
|
|
}
|
|
|
|
Array.Sort(attributeArray, new AttributeComparer());
|
|
return attributeArray;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare two elements
|
|
/// </summary>
|
|
/// <return></return>
|
|
/// <remarks></remarks>
|
|
private static bool CompareXmlElements(XmlElement element1, XmlElement element2, out string differentLocation)
|
|
{
|
|
differentLocation = String.Empty;
|
|
|
|
if (!String.Equals(element1.LocalName, element2.LocalName, StringComparison.Ordinal) ||
|
|
!String.Equals(element1.NamespaceURI, element2.NamespaceURI, StringComparison.Ordinal))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
XmlAttribute differentAttribute1, differentAttribute2;
|
|
if (!CompareXmlAttributeCollections(element1.Attributes, element2.Attributes, out differentAttribute1, out differentAttribute2))
|
|
{
|
|
string attributeName1 = differentAttribute1 != null ? "@" + differentAttribute1.LocalName : String.Empty;
|
|
string attributeName2 = differentAttribute2 != null ? "@" + differentAttribute2.LocalName : String.Empty;
|
|
differentLocation = CombineTwoNames(attributeName1, attributeName2);
|
|
return false;
|
|
}
|
|
|
|
object differentChild1, differentChild2;
|
|
if (!CompareSchemaCollections(element1.ChildNodes, element2.ChildNodes, out differentChild1, out differentChild2, out differentLocation))
|
|
{
|
|
string child1Name = differentChild1 != null ? ((XmlNode)differentChild1).LocalName : String.Empty;
|
|
string child2Name = differentChild2 != null ? ((XmlNode)differentChild2).LocalName : String.Empty;
|
|
differentLocation = CombinePath(CombineTwoNames(child1Name, child2Name), differentLocation);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare two text nodes
|
|
/// </summary>
|
|
/// <return></return>
|
|
/// <remarks></remarks>
|
|
private static bool CompareXmlTexts(XmlText text1, XmlText text2)
|
|
{
|
|
return String.Equals(text1.Value, text2.Value, StringComparison.Ordinal);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Combine two path (similar to xpath) in error messages
|
|
/// </summary>
|
|
/// <return></return>
|
|
/// <remarks></remarks>
|
|
private static string CombinePath(string path1, string path2)
|
|
{
|
|
if (String.IsNullOrEmpty(path1))
|
|
{
|
|
return path2;
|
|
}
|
|
else if (String.IsNullOrEmpty(path2))
|
|
{
|
|
return path1;
|
|
}
|
|
|
|
return path1 + "/" + path2;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Name of a top level schema item
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <return></return>
|
|
/// <remarks></remarks>
|
|
private static string GetSchemaItemName(XmlSchemaObject item)
|
|
{
|
|
if (item == null)
|
|
{
|
|
throw new ArgumentNullException("item");
|
|
}
|
|
|
|
Type itemType = item.GetType();
|
|
PropertyInfo nameProperty = itemType.GetProperty("Name");
|
|
if (nameProperty != null)
|
|
{
|
|
object nameValue = nameProperty.GetValue(item, new object[] { });
|
|
if (nameValue is string)
|
|
{
|
|
return (string)nameValue;
|
|
}
|
|
return String.Empty;
|
|
}
|
|
|
|
return String.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generate end-user unstandable property name -- we will use name in the schema file, but not name in object model
|
|
/// </summary>
|
|
/// <return></return>
|
|
/// <remarks></remarks>
|
|
private static string GetSchemaPropertyNameInXml(PropertyInfo property, object value1, object value2)
|
|
{
|
|
object[] propertyAttributes = property.GetCustomAttributes(true);
|
|
string name = String.Empty;
|
|
|
|
if (propertyAttributes != null)
|
|
{
|
|
string name1 = GetSchemaPropertyNameInXmlHelper(propertyAttributes, value1);
|
|
string name2 = GetSchemaPropertyNameInXmlHelper(propertyAttributes, value2);
|
|
|
|
name = CombineTwoNames(name1, name2);
|
|
}
|
|
|
|
if (String.IsNullOrEmpty(name))
|
|
{
|
|
Debug.Fail("Why we didn't get a property name with normal routine?");
|
|
name = property.Name;
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Combine names of two properties in error messages
|
|
/// </summary>
|
|
/// <remarks></remarks>
|
|
private static string CombineTwoNames(string name1, string name2)
|
|
{
|
|
string name = String.Empty;
|
|
if (name1.Length > 0)
|
|
{
|
|
if (name2.Length > 0)
|
|
{
|
|
if (String.Equals(name1, name2, StringComparison.Ordinal))
|
|
{
|
|
name = name1;
|
|
}
|
|
else
|
|
{
|
|
name = name1 + "|" + name2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
name = name1;
|
|
}
|
|
}
|
|
else if (name2.Length > 0)
|
|
{
|
|
name = name2;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
/// <summary>
|
|
/// a helper function to generate names
|
|
/// </summary>
|
|
/// <remarks></remarks>
|
|
private static string GetSchemaPropertyNameInXmlHelper(object[] propertyAttributes, object value)
|
|
{
|
|
if (value != null)
|
|
{
|
|
foreach (object attribute in propertyAttributes)
|
|
{
|
|
if (attribute is System.Xml.Serialization.XmlAttributeAttribute)
|
|
{
|
|
return "@" + ((System.Xml.Serialization.XmlAttributeAttribute)attribute).AttributeName;
|
|
}
|
|
if (attribute is System.Xml.Serialization.XmlElementAttribute)
|
|
{
|
|
System.Xml.Serialization.XmlElementAttribute elementAttribute = (System.Xml.Serialization.XmlElementAttribute)attribute;
|
|
Type elementType = elementAttribute.Type;
|
|
if (elementType == null || elementType.IsInstanceOfType(value))
|
|
{
|
|
if (value is XmlSchemaObject)
|
|
{
|
|
string itemName = GetSchemaItemName((XmlSchemaObject)value);
|
|
if (itemName.Length > 0)
|
|
{
|
|
return String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}[@name='{1}']", elementAttribute.ElementName, itemName);
|
|
}
|
|
}
|
|
return elementAttribute.ElementName;
|
|
}
|
|
}
|
|
if (attribute is System.Xml.Serialization.XmlAnyAttributeAttribute)
|
|
{
|
|
if (value is XmlAttribute)
|
|
{
|
|
return "@" + ((XmlAttribute)value).LocalName;
|
|
}
|
|
}
|
|
if (attribute is System.Xml.Serialization.XmlAnyElementAttribute)
|
|
{
|
|
if (value is XmlElement)
|
|
{
|
|
return ((XmlElement)value).LocalName;
|
|
}
|
|
}
|
|
if (attribute is System.Xml.Serialization.XmlTextAttribute)
|
|
{
|
|
if (value is XmlText)
|
|
{
|
|
return ((XmlText)value).Name;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return String.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check whether a property is persisted with XmlSerialization
|
|
/// </summary>
|
|
/// <param name="property"></param>
|
|
/// <return></return>
|
|
/// <remarks></remarks>
|
|
private static bool IsPersistedProperty(PropertyInfo property)
|
|
{
|
|
object[] propertyAttributes = property.GetCustomAttributes(true);
|
|
if (propertyAttributes != null)
|
|
{
|
|
foreach (object attribute in propertyAttributes)
|
|
{
|
|
foreach (Type serializationAttibuteType in xmlSerializationAttributes)
|
|
{
|
|
if (serializationAttibuteType.IsInstanceOfType(attribute))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// check whether we should report warning but not error messages, when the property is different
|
|
/// </summary>
|
|
/// <remarks></remarks>
|
|
private static bool ShouldIgnoreSchemaProperty(PropertyInfo property)
|
|
{
|
|
Type propertyType = property.PropertyType;
|
|
foreach (Type ignoreableType in ignorablePropertyTypes)
|
|
{
|
|
if (propertyType == ignoreableType || propertyType.IsSubclassOf(ignoreableType))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// special case constraints...
|
|
if (String.Equals(property.Name, "Constraints", StringComparison.Ordinal))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// a helper structure to hold top level items we want to scan
|
|
/// </summary>
|
|
/// <remarks></remarks>
|
|
private struct SchemaTopLevelItemType
|
|
{
|
|
public Type ItemType;
|
|
public string Name;
|
|
|
|
public SchemaTopLevelItemType(Type itemType, string name)
|
|
{
|
|
this.ItemType = itemType;
|
|
this.Name = name;
|
|
}
|
|
};
|
|
|
|
/// <summary>
|
|
/// Helper class to compare two XmlAttributes
|
|
/// </summary>
|
|
/// <remarks></remarks>
|
|
private class AttributeComparer : System.Collections.Generic.IComparer<XmlAttribute>
|
|
{
|
|
|
|
public int Compare(System.Xml.XmlAttribute x, System.Xml.XmlAttribute y)
|
|
{
|
|
int namespaceResult = String.Compare(x.NamespaceURI, y.NamespaceURI, StringComparison.Ordinal);
|
|
if (namespaceResult != 0)
|
|
{
|
|
return namespaceResult;
|
|
}
|
|
|
|
return String.Compare(x.Name, y.Name, StringComparison.Ordinal);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|