private bool InternalCanImport(XmlSchemaSet schemas, ICollection <XmlQualifiedName>?typeNames, ICollection <XmlSchemaElement>?elements)
{
DataContractSet?oldValue = (_dataContractSet == null) ? null : new DataContractSet(_dataContractSet);
try
{
if (elements != null)
{
DataContractSet.ImportSchemaSet(schemas, elements, ImportXmlDataType);
}
else
{
DataContractSet.ImportSchemaSet(schemas, typeNames, ImportXmlDataType);
}
return(true);
}
catch (InvalidDataContractException)
{
_dataContractSet = oldValue;
return(false);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
_dataContractSet = oldValue;
throw;
}
}
private IList <XmlQualifiedName>?InternalImport(XmlSchemaSet schemas, ICollection <XmlQualifiedName>?typeNames, ICollection <XmlSchemaElement>?elements)
{
DataContractSet? oldValue = (_dataContractSet == null) ? null : new DataContractSet(_dataContractSet);
IList <XmlQualifiedName>?elementTypeNames = null;
try
{
if (elements != null)
{
elementTypeNames = DataContractSet.ImportSchemaSet(schemas, elements, ImportXmlDataType);
}
else
{
DataContractSet.ImportSchemaSet(schemas, typeNames, ImportXmlDataType);
}
CodeExporter codeExporter = new CodeExporter(DataContractSet, Options, CodeCompileUnit);
codeExporter.Export();
return(elementTypeNames);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
_dataContractSet = oldValue;
throw;
}
}
public void Export(Type type)
{
if (type == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(type)));
}
TraceExportBegin();
DataContractSet oldValue = (_dataContractSet == null) ? null : new DataContractSet(_dataContractSet);
try
{
AddType(type);
Export();
}
catch (Exception ex)
{
if (DiagnosticUtility.IsFatal(ex))
{
throw;
}
_dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
TraceExportEnd();
}
public bool CanExport(Type type)
{
if (type == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(type)));
}
DataContractSet oldValue = (_dataContractSet == null) ? null : new DataContractSet(_dataContractSet);
try
{
AddType(type);
AddKnownTypes();
return(true);
}
catch (InvalidDataContractException)
{
_dataContractSet = oldValue;
return(false);
}
catch (Exception ex)
{
if (DiagnosticUtility.IsFatal(ex))
{
throw;
}
_dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
}
internal SchemaImporter(XmlSchemaSet schemas, ICollection<XmlQualifiedName> typeNames, ICollection<XmlSchemaElement> elements, XmlQualifiedName[] elementTypeNames, DataContractSet dataContractSet, bool importXmlDataType)
{
this.dataContractSet = dataContractSet;
this.schemaSet = schemas;
this.typeNames = typeNames;
this.elements = elements;
this.elementTypeNames = elementTypeNames;
this.importXmlDataType = importXmlDataType;
}
public bool CanExport(ICollection <Assembly> assemblies)
{
if (assemblies == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(assemblies)));
}
DataContractSet oldValue = (_dataContractSet == null) ? null : new DataContractSet(_dataContractSet);
try
{
foreach (Assembly assembly in assemblies)
{
if (assembly == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.Format(SR.CannotExportNullAssembly, nameof(assemblies))));
}
Type[] types = assembly.GetTypes();
for (int j = 0; j < types.Length; j++)
{
CheckAndAddType(types[j]);
}
}
AddKnownTypes();
return(true);
}
catch (InvalidDataContractException)
{
_dataContractSet = oldValue;
return(false);
}
catch (Exception ex)
{
if (DiagnosticUtility.IsFatal(ex))
{
throw;
}
_dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
}
public void Export(ICollection <Assembly> assemblies)
{
if (assemblies == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("assemblies"));
}
TraceExportBegin();
DataContractSet oldValue = (dataContractSet == null) ? null : new DataContractSet(dataContractSet);
try
{
foreach (Assembly assembly in assemblies)
{
if (assembly == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.CannotExportNullAssembly, "assemblies")));
}
Type[] types = assembly.GetTypes();
for (int j = 0; j < types.Length; j++)
{
CheckAndAddType(types[j]);
}
}
Export();
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
TraceExportEnd();
}
internal DataContractSet(DataContractSet dataContractSet)
{
ArgumentNullException.ThrowIfNull(dataContractSet);
//this.dataContractSurrogate = dataContractSet.dataContractSurrogate;
_referencedTypes = dataContractSet._referencedTypes;
_referencedCollectionTypes = dataContractSet._referencedCollectionTypes;
foreach (KeyValuePair <XmlQualifiedName, DataContract> pair in dataContractSet)
{
Add(pair.Key, pair.Value);
}
if (dataContractSet._processedContracts != null)
{
foreach (KeyValuePair <DataContract, object> pair in dataContractSet._processedContracts)
{
ProcessedContracts.Add(pair.Key, pair.Value);
}
}
}
internal DataContractSet(DataContractSet dataContractSet)
{
if (dataContractSet == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("dataContractSet"));
}
this.dataContractSurrogate = dataContractSet.dataContractSurrogate;
this.referencedTypes = dataContractSet.referencedTypes;
this.referencedCollectionTypes = dataContractSet.referencedCollectionTypes;
foreach (KeyValuePair <XmlQualifiedName, DataContract> pair in dataContractSet)
{
this.Add(pair.Key, pair.Value);
}
if (dataContractSet.processedContracts != null)
{
foreach (KeyValuePair <DataContract, object> pair2 in dataContractSet.processedContracts)
{
this.ProcessedContracts.Add(pair2.Key, pair2.Value);
}
}
}
internal DataContractSet(DataContractSet dataContractSet)
{
if (dataContractSet == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("dataContractSet"));
}
this.dataContractSurrogate = dataContractSet.dataContractSurrogate;
this.referencedTypes = dataContractSet.referencedTypes;
this.referencedCollectionTypes = dataContractSet.referencedCollectionTypes;
foreach (KeyValuePair<XmlQualifiedName, DataContract> pair in dataContractSet)
{
this.Add(pair.Key, pair.Value);
}
if (dataContractSet.processedContracts != null)
{
foreach (KeyValuePair<DataContract, object> pair2 in dataContractSet.processedContracts)
{
this.ProcessedContracts.Add(pair2.Key, pair2.Value);
}
}
}
internal void Export()
{
try
{
// Remove this if we decide to publish serialization schema at well-known location
ExportSerializationSchema();
foreach (KeyValuePair<XmlQualifiedName, DataContract> pair in dataContractSet)
{
DataContract dataContract = pair.Value;
if (!dataContractSet.IsContractProcessed(dataContract))
{
ExportDataContract(dataContract);
dataContractSet.SetContractProcessed(dataContract);
}
}
}
finally
{
xmlDoc = null;
dataContractSet = null;
}
}
internal void Export()
{
try
{
// Remove this if we decide to publish serialization schema at well-known location
ExportSerializationSchema();
foreach (KeyValuePair <XmlQualifiedName, DataContract> pair in _dataContractSet)
{
DataContract dataContract = pair.Value;
if (!_dataContractSet.IsContractProcessed(dataContract))
{
ExportDataContract(dataContract);
_dataContractSet.SetContractProcessed(dataContract);
}
}
}
finally
{
_xmlDoc = null;
_dataContractSet = null;
}
}
public bool CanExport(ICollection <Type> types)
{
if (types == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("types"));
}
DataContractSet oldValue = (dataContractSet == null) ? null : new DataContractSet(dataContractSet);
try
{
foreach (Type type in types)
{
if (type == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.CannotExportNullType, "types")));
}
AddType(type);
}
AddKnownTypes();
return(true);
}
catch (InvalidDataContractException)
{
dataContractSet = oldValue;
return(false);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
}
private void InternalImport(XmlSchemaSet schemas, ICollection <XmlQualifiedName> typeNames, ICollection <XmlSchemaElement> elements, XmlQualifiedName[] elementTypeNames /*filled on return*/)
{
DataContractSet oldValue = (_dataContractSet == null) ? null : new DataContractSet(_dataContractSet);
try
{
SchemaImporter schemaImporter = new SchemaImporter(schemas, typeNames, elements, elementTypeNames /*filled on return*/, DataContractSet, ImportXmlDataType);
schemaImporter.Import();
CodeExporter codeExporter = new CodeExporter(DataContractSet, Options, GetCodeCompileUnit());
codeExporter.Export();
}
catch (Exception ex)
{
if (DiagnosticUtility.IsFatal(ex))
{
throw;
}
_dataContractSet = oldValue;
TraceImportError(ex);
throw;
}
}
internal DataContractSet(DataContractSet dataContractSet)
{
if (dataContractSet == null)
{
throw /*System.Runtime.Serialization.*/ DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("dataContractSet"));
}
_dataContractSurrogate = dataContractSet._dataContractSurrogate;
_referencedTypes = dataContractSet._referencedTypes;
_referencedCollectionTypes = dataContractSet._referencedCollectionTypes;
foreach (KeyValuePair <XmlQualifiedName, DataContract> pair in dataContractSet)
{
Add(pair.Key, pair.Value);
}
if (dataContractSet._processedContracts != null)
{
foreach (KeyValuePair <DataContract, object> pair in dataContractSet._processedContracts)
{
ProcessedContracts.Add(pair.Key, pair.Value);
}
}
}
public void Export(ICollection <Type> types)
{
if (types == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(types)));
}
TraceExportBegin();
DataContractSet oldValue = (_dataContractSet == null) ? null : new DataContractSet(_dataContractSet);
try
{
foreach (Type type in types)
{
if (type == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.Format(SR.CannotExportNullType, nameof(types))));
}
AddType(type);
}
Export();
}
catch (Exception ex)
{
if (DiagnosticUtility.IsFatal(ex))
{
throw;
}
_dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
TraceExportEnd();
}
internal void Export()
{
try
{
this.ExportSerializationSchema();
foreach (KeyValuePair<XmlQualifiedName, DataContract> pair in this.dataContractSet)
{
DataContract dataContract = pair.Value;
if (!this.dataContractSet.IsContractProcessed(dataContract))
{
this.ExportDataContract(dataContract);
this.dataContractSet.SetContractProcessed(dataContract);
}
}
}
finally
{
this.xmlDoc = null;
this.dataContractSet = null;
}
}
internal SchemaExporter(XmlSchemaSet schemas, DataContractSet dataContractSet)
{
_schemas = schemas;
_dataContractSet = dataContractSet;
}
bool InternalCanImport(XmlSchemaSet schemas, ICollection<XmlQualifiedName> typeNames, ICollection<XmlSchemaElement> elements, XmlQualifiedName[] elementTypeNames)
{
DataContractSet oldValue = (dataContractSet == null) ? null : new DataContractSet(dataContractSet);
try
{
SchemaImporter schemaImporter = new SchemaImporter(schemas, typeNames, elements, elementTypeNames, DataContractSet, ImportXmlDataType);
schemaImporter.Import();
return true;
}
catch (InvalidDataContractException)
{
dataContractSet = oldValue;
return false;
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
dataContractSet = oldValue;
TraceImportError(ex);
throw;
}
}
void InternalImport(XmlSchemaSet schemas, ICollection<XmlQualifiedName> typeNames, ICollection<XmlSchemaElement> elements, XmlQualifiedName[] elementTypeNames/*filled on return*/)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.Trace(TraceEventType.Information, TraceCode.XsdImportBegin, SR.GetString(SR.TraceCodeXsdImportBegin));
}
DataContractSet oldValue = (dataContractSet == null) ? null : new DataContractSet(dataContractSet);
try
{
SchemaImporter schemaImporter = new SchemaImporter(schemas, typeNames, elements, elementTypeNames/*filled on return*/, DataContractSet, ImportXmlDataType);
schemaImporter.Import();
CodeExporter codeExporter = new CodeExporter(DataContractSet, Options, GetCodeCompileUnit());
codeExporter.Export();
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
dataContractSet = oldValue;
TraceImportError(ex);
throw;
}
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.Trace(TraceEventType.Information, TraceCode.XsdImportEnd, SR.GetString(SR.TraceCodeXsdImportEnd));
}
}
private void ExportCollectionDataContract(CollectionDataContract collectionDataContract, XmlSchema schema)
{
XmlSchemaComplexType type = new XmlSchemaComplexType();
type.Name = collectionDataContract.StableName.Name;
schema.Items.Add(type);
XmlElement?genericInfoElement = null, isDictionaryElement = null;
if (collectionDataContract.UnderlyingType.IsGenericType && CollectionDataContract.IsCollectionDataContract(collectionDataContract.UnderlyingType))
{
genericInfoElement = ExportGenericInfo(collectionDataContract.UnderlyingType, Globals.GenericTypeLocalName, Globals.SerializationNamespace);
}
if (collectionDataContract.IsDictionary)
{
isDictionaryElement = ExportIsDictionary();
}
type.Annotation = GetSchemaAnnotation(isDictionaryElement, genericInfoElement, ExportSurrogateData(collectionDataContract));
XmlSchemaSequence rootSequence = new XmlSchemaSequence();
XmlSchemaElement element = new XmlSchemaElement();
element.Name = collectionDataContract.ItemName;
element.MinOccurs = 0;
element.MaxOccursString = Globals.OccursUnbounded;
if (collectionDataContract.IsDictionary)
{
ClassDataContract keyValueContract = (collectionDataContract.ItemContract as ClassDataContract) !;
XmlSchemaComplexType keyValueType = new XmlSchemaComplexType();
XmlSchemaSequence keyValueSequence = new XmlSchemaSequence();
foreach (DataMember dataMember in keyValueContract.Members !)
{
XmlSchemaElement keyValueElement = new XmlSchemaElement();
keyValueElement.Name = dataMember.Name;
SetElementType(keyValueElement, DataContractSet.GetMemberTypeDataContract(dataMember), schema);
SchemaHelper.AddElementForm(keyValueElement, schema);
if (dataMember.IsNullable)
{
keyValueElement.IsNillable = true;
}
keyValueElement.Annotation = GetSchemaAnnotation(ExportSurrogateData(dataMember));
keyValueSequence.Items.Add(keyValueElement);
}
keyValueType.Particle = keyValueSequence;
element.SchemaType = keyValueType;
}
else
{
if (collectionDataContract.IsItemTypeNullable)
{
element.IsNillable = true;
}
DataContract itemContract = DataContractSet.GetItemTypeDataContract(collectionDataContract);
SetElementType(element, itemContract, schema);
}
SchemaHelper.AddElementForm(element, schema);
rootSequence.Items.Add(element);
type.Particle = rootSequence;
if (collectionDataContract.IsReference)
{
AddReferenceAttributes(type.Attributes, schema);
}
}
private void ExportClassDataContract(ClassDataContract classDataContract, XmlSchema schema)
{
XmlSchemaComplexType type = new XmlSchemaComplexType();
type.Name = classDataContract.StableName.Name;
schema.Items.Add(type);
XmlElement?genericInfoElement = null;
if (classDataContract.UnderlyingType.IsGenericType)
{
genericInfoElement = ExportGenericInfo(classDataContract.UnderlyingType, Globals.GenericTypeLocalName, Globals.SerializationNamespace);
}
XmlSchemaSequence rootSequence = new XmlSchemaSequence();
for (int i = 0; i < classDataContract.Members !.Count; i++)
{
DataMember dataMember = classDataContract.Members[i];
XmlSchemaElement element = new XmlSchemaElement();
element.Name = dataMember.Name;
XmlElement? actualTypeElement = null;
DataContract memberTypeContract = DataContractSet.GetMemberTypeDataContract(dataMember);
if (CheckIfMemberHasConflict(dataMember))
{
element.SchemaTypeName = AnytypeQualifiedName;
actualTypeElement = ExportActualType(memberTypeContract.StableName);
SchemaHelper.AddSchemaImport(memberTypeContract.StableName.Namespace, schema);
}
else
{
SetElementType(element, memberTypeContract, schema);
}
SchemaHelper.AddElementForm(element, schema);
if (dataMember.IsNullable)
{
element.IsNillable = true;
}
if (!dataMember.IsRequired)
{
element.MinOccurs = 0;
}
element.Annotation = GetSchemaAnnotation(actualTypeElement, ExportSurrogateData(dataMember), ExportEmitDefaultValue(dataMember));
rootSequence.Items.Add(element);
}
XmlElement?isValueTypeElement = null;
if (classDataContract.BaseContract != null)
{
XmlSchemaComplexContentExtension extension = CreateTypeContent(type, classDataContract.BaseContract.StableName, schema);
extension.Particle = rootSequence;
if (classDataContract.IsReference && !classDataContract.BaseContract.IsReference)
{
AddReferenceAttributes(extension.Attributes, schema);
}
}
else
{
type.Particle = rootSequence;
if (classDataContract.IsValueType)
{
isValueTypeElement = GetAnnotationMarkup(IsValueTypeName, XmlConvert.ToString(classDataContract.IsValueType), schema);
}
if (classDataContract.IsReference)
{
AddReferenceAttributes(type.Attributes, schema);
}
}
type.Annotation = GetSchemaAnnotation(genericInfoElement, ExportSurrogateData(classDataContract), isValueTypeElement);
}
//Returns warnings
public IList <string> GenerateCode(IList <Assembly> assemblies)
{
if (assemblies == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(assemblies)));
}
List <string> warnings = new List <string>();
DataContractSet oldValue = (dataContractSet == null) ? null : new DataContractSet(dataContractSet);
try
{
for (int i = 0; i < assemblies.Count; i++)
{
Assembly assembly = assemblies[i];
if (assembly == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.Format(SR.CannotExportNullAssembly, "assemblies")));
}
Type[] types = assembly.GetTypes();
for (int j = 0; j < types.Length; j++)
{
try
{
CheckAndAddType(types[j]);
}
catch (Exception ex)
{
warnings.Add("Error on exporting Type " + DataContract.GetClrTypeFullName(types[j]) + ". " + ex.Message);
}
}
}
foreach (KeyValuePair <XmlQualifiedName, DataContract> pair in dataContractSet)
{
DataContract dataContract = pair.Value;
if (dataContract is ClassDataContract)
{
try
{
XmlFormatClassWriterDelegate writerMethod = ((ClassDataContract)dataContract).XmlFormatWriterDelegate;
XmlFormatClassReaderDelegate readerMethod = ((ClassDataContract)dataContract).XmlFormatReaderDelegate;
}
catch (Exception ex)
{
warnings.Add("Error on exporting Type " + dataContract.UnderlyingType + ". " + ex.Message);
}
}
else if (dataContract is CollectionDataContract)
{
try
{
XmlFormatCollectionWriterDelegate writerMethod = ((CollectionDataContract)dataContract).XmlFormatWriterDelegate;
XmlFormatCollectionReaderDelegate readerMethod = ((CollectionDataContract)dataContract).XmlFormatReaderDelegate;
}
catch (Exception ex)
{
warnings.Add("Error on exporting Type " + dataContract.UnderlyingType + ". " + ex.Message);
}
}
}
return(warnings);
}
catch (Exception ex)
{
if (DiagnosticUtility.IsFatal(ex))
{
throw;
}
dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
}
//Returns warnings
public IList<string> GenerateCode(IList<Assembly> assemblies)
{
if (assemblies == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("assemblies"));
List<string> warnings = new List<string>();
DataContractSet oldValue = (dataContractSet == null) ? null : new DataContractSet(dataContractSet);
try
{
for (int i=0; i < assemblies.Count; i++)
{
Assembly assembly = assemblies[i];
if (assembly == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.CannotExportNullAssembly, "assemblies")));
Type[] types = assembly.GetTypes();
for (int j=0; j < types.Length; j++)
{
try
{
CheckAndAddType(types[j]);
}
catch (Exception ex)
{
warnings.Add("Error on exporting Type " + DataContract.GetClrTypeFullName(types[j]) + ". " + ex.Message);
}
}
}
foreach (KeyValuePair<XmlQualifiedName, DataContract> pair in dataContractSet)
{
DataContract dataContract = pair.Value;
if (dataContract is ClassDataContract)
{
try
{
XmlFormatClassWriterDelegate writerMethod = ((ClassDataContract)dataContract).XmlFormatWriterDelegate;
XmlFormatClassReaderDelegate readerMethod = ((ClassDataContract)dataContract).XmlFormatReaderDelegate;
}
catch (Exception ex)
{
warnings.Add("Error on exporting Type " + dataContract.UnderlyingType + ". " + ex.Message);
}
}
else if (dataContract is CollectionDataContract)
{
try
{
XmlFormatCollectionWriterDelegate writerMethod = ((CollectionDataContract)dataContract).XmlFormatWriterDelegate;
XmlFormatCollectionReaderDelegate readerMethod = ((CollectionDataContract)dataContract).XmlFormatReaderDelegate;
}
catch (Exception ex)
{
warnings.Add("Error on exporting Type " + dataContract.UnderlyingType + ". " + ex.Message);
}
}
}
return warnings;
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
}
public bool CanExport(Type type)
{
if (type == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("type"));
DataContractSet oldValue = (dataContractSet == null) ? null : new DataContractSet(dataContractSet);
try
{
AddType(type);
AddKnownTypes();
return true;
}
catch (InvalidDataContractException)
{
dataContractSet = oldValue;
return false;
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
}
public bool CanExport(ICollection<Type> types)
{
if (types == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("types"));
DataContractSet oldValue = (dataContractSet == null) ? null : new DataContractSet(dataContractSet);
try
{
foreach (Type type in types)
{
if (type == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.CannotExportNullType, "types")));
AddType(type);
}
AddKnownTypes();
return true;
}
catch (InvalidDataContractException)
{
dataContractSet = oldValue;
return false;
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
}
internal SchemaExporter(XmlSchemaSet schemas, DataContractSet dataContractSet)
{
this.schemas = schemas;
this.dataContractSet = dataContractSet;
}
internal DataContractSet(DataContractSet dataContractSet !!)
{
internal CodeExporter(DataContractSet dataContractSet, ImportOptions options, CodeCompileUnit codeCompileUnit)
{
this.dataContractSet = dataContractSet;
this.codeCompileUnit = codeCompileUnit;
AddReferencedAssembly(Assembly.GetExecutingAssembly());
this.options = options;
this.namespaces = new Dictionary<string, string>();
this.clrNamespaces = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
// Update namespace tables for DataContract(s) that are already processed
foreach (KeyValuePair<XmlQualifiedName, DataContract> pair in dataContractSet)
{
DataContract dataContract = pair.Value;
if (!(dataContract.IsBuiltInDataContract || dataContract is CollectionDataContract))
{
ContractCodeDomInfo contractCodeDomInfo = GetContractCodeDomInfo(dataContract);
if (contractCodeDomInfo.IsProcessed && !contractCodeDomInfo.UsesWildcardNamespace)
{
string clrNamespace = contractCodeDomInfo.ClrNamespace;
if (clrNamespace != null && !this.clrNamespaces.ContainsKey(clrNamespace))
{
this.clrNamespaces.Add(clrNamespace, dataContract.StableName.Namespace);
this.namespaces.Add(dataContract.StableName.Namespace, clrNamespace);
}
}
}
}
// Copy options.Namespaces to namespace tables
if (this.options != null)
{
foreach (KeyValuePair<string, string> pair in options.Namespaces)
{
string dataContractNamespace = pair.Key;
string clrNamespace = pair.Value;
if (clrNamespace == null)
clrNamespace = String.Empty;
string currentDataContractNamespace;
if (this.clrNamespaces.TryGetValue(clrNamespace, out currentDataContractNamespace))
{
if (dataContractNamespace != currentDataContractNamespace)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.CLRNamespaceMappedMultipleTimes, currentDataContractNamespace, dataContractNamespace, clrNamespace)));
}
else
this.clrNamespaces.Add(clrNamespace, dataContractNamespace);
string currentClrNamespace;
if (this.namespaces.TryGetValue(dataContractNamespace, out currentClrNamespace))
{
if (clrNamespace != currentClrNamespace)
{
this.namespaces.Remove(dataContractNamespace);
this.namespaces.Add(dataContractNamespace, clrNamespace);
}
}
else
this.namespaces.Add(dataContractNamespace, clrNamespace);
}
}
// Update namespace tables for pre-existing namespaces in CodeCompileUnit
foreach (CodeNamespace codeNS in codeCompileUnit.Namespaces)
{
string ns = codeNS.Name ?? string.Empty;
if (!this.clrNamespaces.ContainsKey(ns))
{
this.clrNamespaces.Add(ns, null);
}
if (ns.Length == 0)
{
foreach (CodeTypeDeclaration codeTypeDecl in codeNS.Types)
{
AddGlobalTypeName(codeTypeDecl.Name);
}
}
}
}
public void Export(ICollection<Type> types)
{
if (types == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(types)));
TraceExportBegin();
DataContractSet oldValue = (_dataContractSet == null) ? null : new DataContractSet(_dataContractSet);
try
{
foreach (Type type in types)
{
if (type == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.Format(SR.CannotExportNullType, nameof(types))));
AddType(type);
}
Export();
}
catch (Exception ex)
{
if (DiagnosticUtility.IsFatal(ex))
{
throw;
}
_dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
TraceExportEnd();
}
public void Export(ICollection<Assembly> assemblies)
{
if (assemblies == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("assemblies"));
TraceExportBegin();
DataContractSet oldValue = (dataContractSet == null) ? null : new DataContractSet(dataContractSet);
try
{
foreach (Assembly assembly in assemblies)
{
if (assembly == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.CannotExportNullAssembly, "assemblies")));
Type[] types = assembly.GetTypes();
for (int j = 0; j < types.Length; j++)
CheckAndAddType(types[j]);
}
Export();
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
TraceExportEnd();
}
public void Export(Type type)
{
if (type == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("type"));
TraceExportBegin();
DataContractSet oldValue = (dataContractSet == null) ? null : new DataContractSet(dataContractSet);
try
{
AddType(type);
Export();
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
TraceExportEnd();
}
public bool CanExport(ICollection<Assembly> assemblies)
{
if (assemblies == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(assemblies)));
DataContractSet oldValue = (_dataContractSet == null) ? null : new DataContractSet(_dataContractSet);
try
{
foreach (Assembly assembly in assemblies)
{
if (assembly == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.Format(SR.CannotExportNullAssembly, nameof(assemblies))));
Type[] types = assembly.GetTypes();
for (int j = 0; j < types.Length; j++)
CheckAndAddType(types[j]);
}
AddKnownTypes();
return true;
}
catch (InvalidDataContractException)
{
_dataContractSet = oldValue;
return false;
}
catch (Exception ex)
{
if (DiagnosticUtility.IsFatal(ex))
{
throw;
}
_dataContractSet = oldValue;
TraceExportError(ex);
throw;
}
}
internal CodeExporter(DataContractSet dataContractSet, ImportOptions options, CodeCompileUnit codeCompileUnit)
{
this.dataContractSet = dataContractSet;
this.codeCompileUnit = codeCompileUnit;
this.AddReferencedAssembly(Assembly.GetExecutingAssembly());
this.options = options;
this.namespaces = new Dictionary<string, string>();
this.clrNamespaces = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
foreach (KeyValuePair<XmlQualifiedName, DataContract> pair in dataContractSet)
{
DataContract dataContract = pair.Value;
if (!dataContract.IsBuiltInDataContract && !(dataContract is CollectionDataContract))
{
ContractCodeDomInfo contractCodeDomInfo = this.GetContractCodeDomInfo(dataContract);
if (contractCodeDomInfo.IsProcessed && !contractCodeDomInfo.UsesWildcardNamespace)
{
string clrNamespace = contractCodeDomInfo.ClrNamespace;
if ((clrNamespace != null) && !this.clrNamespaces.ContainsKey(clrNamespace))
{
this.clrNamespaces.Add(clrNamespace, dataContract.StableName.Namespace);
this.namespaces.Add(dataContract.StableName.Namespace, clrNamespace);
}
}
}
}
if (this.options != null)
{
foreach (KeyValuePair<string, string> pair2 in options.Namespaces)
{
string str4;
string str5;
string key = pair2.Key;
string str3 = pair2.Value;
if (str3 == null)
{
str3 = string.Empty;
}
if (this.clrNamespaces.TryGetValue(str3, out str4))
{
if (key != str4)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.Runtime.Serialization.SR.GetString("CLRNamespaceMappedMultipleTimes", new object[] { str4, key, str3 })));
}
}
else
{
this.clrNamespaces.Add(str3, key);
}
if (this.namespaces.TryGetValue(key, out str5))
{
if (str3 != str5)
{
this.namespaces.Remove(key);
this.namespaces.Add(key, str3);
}
}
else
{
this.namespaces.Add(key, str3);
}
}
}
foreach (CodeNamespace namespace2 in codeCompileUnit.Namespaces)
{
string str6 = namespace2.Name ?? string.Empty;
if (!this.clrNamespaces.ContainsKey(str6))
{
this.clrNamespaces.Add(str6, null);
}
if (str6.Length == 0)
{
foreach (CodeTypeDeclaration declaration in namespace2.Types)
{
this.AddGlobalTypeName(declaration.Name);
}
}
}
}
//XmlDocument _xmlDoc;
internal SchemaExporter(XmlSchemaSet schemas, DataContractSet dataContractSet)
{
_schemas = schemas;
_dataContractSet = dataContractSet;
}
