private MetadataSection CreateMetadataSection(object document)
{
System.Web.Services.Description.ServiceDescription description =
document as System.Web.Services.Description.ServiceDescription;
XmlSchema schema = document as XmlSchema;
XmlElement element = document as XmlElement;
MetadataSection section;
if (description != null)
{
section = MetadataSection.CreateFromServiceDescription(description);
}
else if (schema != null)
{
section = MetadataSection.CreateFromSchema(schema);
}
else if ((element != null) && IsPolicyElement(element))
{
section = MetadataSection.CreateFromPolicy(element, null);
}
else
{
section = new MetadataSection();
section.Metadata = document;
}
return(section);
}
private static IEnumerable <MetadataSection> LoadAsPolicy(XmlReader reader, string path)
{
XmlDocument document;
try
{
document = new XmlDocument();
document.Load(reader);
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
string message = string.Format("WS-Policy Parsing Error while reading: '{0}'. Verify that the XML is both well-formed and valid.", path);
throw new MetadataDiscoveryException(message);
}
XmlElement documentElement = document.DocumentElement;
return((documentElement != null)
? new List <MetadataSection> {
MetadataSection.CreateFromPolicy(documentElement, null)
}
: Enumerable.Empty <MetadataSection>());
}
private static void ResolveImports(MetadataResolverOptions options, MetadataSet metadataSet)
{
// Resolve metadata using a DiscoveryClientProtocol.
DiscoveryClientProtocol dcp = new DiscoveryClientProtocol();
dcp.Credentials = GetCredentials(options);
dcp.AllowAutoRedirect = true;
dcp.DiscoverAny(options.MetadataLocation);
dcp.ResolveAll();
foreach (object osd in dcp.Documents.Values)
{
if (osd is System.Web.Services.Description.ServiceDescription)
{
MetadataSection mds = MetadataSection.CreateFromServiceDescription((System.Web.Services.Description.ServiceDescription)osd);
metadataSet.MetadataSections.Add(mds);
continue;
}
if (osd is XmlSchema)
{
MetadataSection mds = MetadataSection.CreateFromSchema((XmlSchema)osd);
metadataSet.MetadataSections.Add(mds);
continue;
}
}
}
/// <summary>
/// Populates the internal definition of the schema based on the representation contained in the metadata set
/// </summary>
/// <param name="set">The metadata set describing the schema</param>
private static void PopulateSchemaFromMetadata(MetadataSet set)
{
if (set == null)
{
throw new ArgumentNullException(nameof(set));
}
if (set.MetadataSections.Count != 1)
{
throw new NotSupportedException("The metadata returned from the resource management service did not contain the expected number of sections");
}
MetadataSection section = set.MetadataSections[0];
XmlSchema metadata = section.Metadata as XmlSchema;
if (metadata == null)
{
throw new NotSupportedException("The metadata returned from the resource management service did not contain the expected metadata section");
}
ResourceManagementSchema.ObjectTypes.Clear();
foreach (XmlSchemaComplexType complexType in metadata.Items.OfType <XmlSchemaComplexType>())
{
if (!ResourceManagementSchema.ElementsToIgnore.Contains(complexType.Name))
{
ObjectTypeDefinition definition = new ObjectTypeDefinition(complexType);
ResourceManagementSchema.ObjectTypes.TryAdd(definition.SystemName, definition);
}
}
}
private async Task LoadAsWsdlAsync(XmlNS.XmlReader reader, string uri, string basePath, CancellationToken cancellationToken)
{
WsdlNS.ServiceDescription wsdl = await AsyncHelper.RunAsync(() => WsdlNS.ServiceDescription.Read(reader), cancellationToken).ConfigureAwait(false);
wsdl.RetrievalUrl = uri;
if (_resolveExternalDocs)
{
foreach (WsdlNS.Import import in wsdl.Imports)
{
if (!string.IsNullOrWhiteSpace(import.Location))
{
var resolvedLocation = await LoadAsSchemaImportLocationAsync(import.Location, uri, basePath, import.Namespace, ".wsdl", cancellationToken).ConfigureAwait(false);
import.Location = resolvedLocation;
}
}
foreach (XmlNS.Schema.XmlSchema schema in wsdl.Types.Schemas)
{
schema.SourceUri = uri;
await LoadAsXmlSchemaIncludesAsync(schema, wsdl.RetrievalUrl, basePath, cancellationToken).ConfigureAwait(false);
}
}
_metadataSections.Add(MetadataSection.CreateFromServiceDescription(wsdl));
}
/// <summary>
/// Retrieves and imports meta data for a given WSDL document specified by
/// WsdlDocument property.
/// </summary>
/// <param name="options">The metadata resolving options.</param>
/// <returns>A collection of service metadata in XML form.</returns>
public static MetadataSet GetMetadataSet(MetadataResolverOptions options)
{
if (options == null)
{
throw new ArgumentException("options could not be null.");
}
if (string.IsNullOrEmpty(options.MetadataLocation))
{
throw new ArgumentException("MetadataLocation option could not be null or an empty string.");
}
try
{
// First download the contracts if they are accessed over the web.
DownloadContract(options);
// Try to run RPC2DocumentLiteral converter.
TryTranslateRpc2DocumentLiteral(options);
MetadataSet metadataSet = new MetadataSet();
XmlDocument doc = new XmlDocument();
doc.Load(options.MetadataLocation);
MetadataSection ms = new MetadataSection(null, null, doc);
metadataSet.MetadataSections.Add(ms);
ResolveImports(options, metadataSet);
return(metadataSet);
}
catch (Exception ex)
{
// TODO: Log exception.
throw new MetadataResolveException("Could not resolve metadata", ex);
}
}
private static void AddDocumentToResults(object document, ICollection <MetadataSection> results)
{
ServiceDescription serviceDescription = document as ServiceDescription;
XmlSchema xmlSchema = document as XmlSchema;
XmlElement xmlElement = document as XmlElement;
if (serviceDescription != null)
{
results.Add(MetadataSection.CreateFromServiceDescription(serviceDescription));
}
else if (xmlSchema != null)
{
results.Add(MetadataSection.CreateFromSchema(xmlSchema));
}
else if (xmlElement != null && (xmlElement.NamespaceURI == "http://schemas.xmlsoap.org/ws/2004/09/policy" || xmlElement.NamespaceURI == "http://www.w3.org/ns/ws-policy") && xmlElement.LocalName == "Policy")
{
results.Add(MetadataSection.CreateFromPolicy(xmlElement, null));
}
else
{
MetadataSection mexDoc = new MetadataSection();
mexDoc.Metadata = document;
results.Add(mexDoc);
}
}
private void AddDocumentToResults(object document, Collection <MetadataSection> results)
{
var wsdl = document as ServiceDescription;
var schema = document as XmlSchema;
var xmlDoc = document as XmlElement;
if (wsdl != null)
{
results.Add(MetadataSection.CreateFromServiceDescription(wsdl));
}
else if (schema != null)
{
results.Add(MetadataSection.CreateFromSchema(schema));
}
else if (xmlDoc != null && xmlDoc.LocalName == "Policy")
{
results.Add(MetadataSection.CreateFromPolicy(xmlDoc, null));
}
else
{
var mexDoc = new MetadataSection {
Metadata = document
};
results.Add(mexDoc);
}
}
void AddDocumentToSet(MetadataSet metadataSet, object document)
{
WsdlNS.ServiceDescription wsdl = document as WsdlNS.ServiceDescription;
XmlSchema schema = document as XmlSchema;
XmlElement xmlDoc = document as XmlElement;
if (wsdl != null)
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(wsdl));
}
else if (schema != null)
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromSchema(schema));
}
else if (xmlDoc != null && MetadataSection.IsPolicyElement(xmlDoc))
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromPolicy(xmlDoc, null));
}
else
{
MetadataSection mexDoc = new MetadataSection();
mexDoc.Metadata = document;
metadataSet.MetadataSections.Add(mexDoc);
}
}
internal static MetadataSet GetMetadataSetForMonolithicWsdl()
{
string xmlSchemaFile = TestFiles.GetFilePath(TestFiles.RestaurantDataXsdFileName);
XmlSchema xmlSchema;
using (XmlTextReader xmlTextReader = new XmlTextReader(xmlSchemaFile))
{
xmlSchema = XmlSchema.Read(xmlTextReader, null);
}
string serviceDescriptionFile = TestFiles.GetFilePath(TestFiles.RestaurantServiceWsdlFileName2);
ServiceDescription serviceDescription;
using (XmlTextReader xmlTextReader = new XmlTextReader(serviceDescriptionFile))
{
serviceDescription = ServiceDescription.Read(xmlTextReader);
}
List <MetadataSection> sections = new List <MetadataSection>
{
MetadataSection.CreateFromSchema(xmlSchema),
MetadataSection.CreateFromServiceDescription(serviceDescription)
};
return(new MetadataSet(sections));
}
private static void AddDocumentToSet(MetadataSet metadataSet, object document)
{
ServiceDescription serviceDescription = document as ServiceDescription;
XmlSchema schema = document as XmlSchema;
XmlElement policy = document as XmlElement;
if (serviceDescription != null)
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(serviceDescription));
}
else if (schema != null)
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromSchema(schema));
}
else if ((policy != null) && IsPolicyElement(policy))
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromPolicy(policy, null));
}
else
{
MetadataSection item = new MetadataSection {
Metadata = document
};
metadataSet.MetadataSections.Add(item);
}
}
void AddDocumentToResults(object document, Collection <MetadataSection> results)
{
WsdlNS.ServiceDescription wsdl = document as WsdlNS.ServiceDescription;
XmlSchema schema = document as XmlSchema;
XmlElement xmlDoc = document as XmlElement;
if (wsdl != null)
{
results.Add(MetadataSection.CreateFromServiceDescription(wsdl));
}
else if (schema != null)
{
results.Add(MetadataSection.CreateFromSchema(schema));
}
else if (xmlDoc != null && xmlDoc.LocalName == "Policy")
{
results.Add(MetadataSection.CreateFromPolicy(xmlDoc, null));
}
else
{
MetadataSection mexDoc = new MetadataSection();
mexDoc.Metadata = document;
results.Add(mexDoc);
}
}
public Beatmap()
{
GeneralSection = new GeneralSection();
EditorSection = new EditorSection();
MetadataSection = new MetadataSection();
DifficultySection = new DifficultySection();
EventsSection = new EventsSection();
}
private void LoadAsPolicy(XmlNS.XmlReader reader)
{
var doc = new XmlNS.XmlDocument();
doc.XmlResolver = null;
doc.Load(reader);
XmlNS.XmlElement policy = doc.DocumentElement;
_metadataSections.Add(MetadataSection.CreateFromPolicy(policy, null));
}
protected string GetSourceUrl(MetadataSection section)
{
// The SourceUrl property of the MetadataSection is set by the WCF MetadataExchangeClient when downloading metadata from a web server.
// This property is not set when the metadata comes from a WSDL file in disk as the WSDL file processing code is not in WCF.
#if NETCORE
return(section.SourceUrl);
#else
return(section.GetType().GetProperty("SourceUrl", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(section) as string);
#endif
}
public OsuBeatmap(Qua qua, Arguments args)
{
GeneralSection = new GeneralSection(qua, args);
EditorSection = new EditorSection(qua, args);
MetadataSection = new MetadataSection(qua, args);
DifficultySection = new DifficultySection(qua, args);
EventsSection = new EventsSection(qua, args);
TimingPointsSection = new TimingPointsSection(qua, args);
HitObjectsSection = new HitObjectsSection(qua, args);
}
/// <summary>
/// first response performance critical
/// </summary>
/// <returns></returns>
public override MetadataSet GetGeneratedMetadata()
{
ImporterController.TryDocRevImporting();
int i = 0;
// let the base build up metadata for the service contracts as these are static
MetadataSet _MetadataSet = base.GetGeneratedMetadata();
foreach (DirectoryInfo _DirectoryInfo in Directory
.EnumerateDirectories(FilesystemTemplateController.DirectoryPath)
.Select(path => new DirectoryInfo(path)))
{
// persist the datacontract xml schema for the datacontract to the user's temporary directory
//TODO:combine this logic and Runtime's that calculates it's dll output location
int key = Math.Abs(File.ReadAllText(
RequestPaths.GetPhysicalApplicationPath(
"doc",
_DirectoryInfo.Name,
Runtime.MYSCHEMA_XSD_FILE_NAME)).GetHashCode()
^ WindowsIdentity.GetCurrent().User.Value.GetHashCode()); // just incase the user changes due to an apppool change
string tempDataContractXsdPath = string.Format("{0}\\{1}.xsd", Path.GetTempPath(), Base36.Encode(key));
if (!File.Exists(tempDataContractXsdPath))
{
// the datacontracts are the things that are dynamic & change according to what DocTypes are present
XsdDataContractExporter _XsdDataContractExporter = new XsdDataContractExporter();
Type DocType = Runtime.ActivateBaseDocType(_DirectoryInfo.Name, TemplateController.Instance.TopDocRev(_DirectoryInfo.Name));
_XsdDataContractExporter.Export(DocType);
// _XsdDataContractExporter.Schemas.CompilationSettings.EnableUpaCheck = true;
_XsdDataContractExporter.Schemas.Compile();
foreach (XmlSchema _XmlSchema in _XsdDataContractExporter.Schemas.Schemas(_XsdDataContractExporter.GetRootElementName(DocType).Namespace))
{
using (Stream _Stream = File.OpenWrite(tempDataContractXsdPath))
{
_MetadataSet.MetadataSections.Add(MetadataSection.CreateFromSchema(_XmlSchema));
_XmlSchema.Write(_Stream);
break;
}
}
}
using (Stream _Stream = File.OpenRead(tempDataContractXsdPath))
_MetadataSet.MetadataSections.Add(MetadataSection.CreateFromSchema(
XmlSchema.Read(_Stream, (s, o) =>
{
/*if (o != null && o.Exception != null) throw o.Exception;*/
})));
}
return(_MetadataSet);
}
private ServiceContractGenerator BuildServiceContractGenerator(XmlTextReader xmlreader)
{
// make sure xml describes a valid wsdl
if (!System.Web.Services.Description.ServiceDescription.CanRead(xmlreader))
{
throw new Exception("Invalid Web Service Description");
}
// parse wsdl
System.Web.Services.Description.ServiceDescription serviceDescription = System.Web.Services.Description.ServiceDescription.Read(xmlreader);
MetadataSection section = MetadataSection.CreateFromServiceDescription(serviceDescription);
MetadataSet metaDocs = new MetadataSet(new MetadataSection[] { section });
WsdlImporter importer = new WsdlImporter(metaDocs);
// Add any imported files
foreach (System.Xml.Schema.XmlSchema wsdlSchema in serviceDescription.Types.Schemas)
{
foreach (System.Xml.Schema.XmlSchemaObject externalSchema in wsdlSchema.Includes)
{
if (externalSchema is System.Xml.Schema.XmlSchemaImport)
{
Uri baseUri = webServiceUri;
if (string.IsNullOrEmpty(((System.Xml.Schema.XmlSchemaExternal)externalSchema).SchemaLocation))
{
continue;
}
Uri schemaUri = new Uri(baseUri, ((System.Xml.Schema.XmlSchemaExternal)externalSchema).SchemaLocation);
Console.WriteLine("== xml schema " + schemaUri);
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
StreamReader sr = GetHttpWebResponse(schemaUri.ToString());
System.Xml.Schema.XmlSchema schema = System.Xml.Schema.XmlSchema.Read(sr, null);
importer.XmlSchemas.Add(schema);
}
}
}
ServiceContractGenerator generator = new ServiceContractGenerator();
IEnumerable <ContractDescription> contracts
= importer.ImportAllContracts();
importer.ImportAllEndpoints();
foreach (ContractDescription contract in contracts)
{
generator.GenerateServiceContractType(contract);
}
if (generator.Errors.Count != 0)
{
throw new Exception("There were errors during code compilation.");
}
return(generator);
}
public MetadataEntry(MetadataSection section, ushort tagId, TagDataType type, byte[] data)
{
if (data is null)
{
throw new ArgumentNullException(nameof(data));
}
Section = section;
TagId = tagId;
Type = type;
this.data = (byte[])data.Clone();
}
private async Task LoadAsXmlSchemaAsync(XmlNS.XmlReader reader, string uri, string basePath, CancellationToken cancellationToken)
{
var schema = await AsyncHelper.RunAsync(() => XmlNS.Schema.XmlSchema.Read(reader, null), cancellationToken).ConfigureAwait(false);
_metadataSections.Add(MetadataSection.CreateFromSchema(schema));
schema.SourceUri = uri;
if (_resolveExternalDocs)
{
await LoadAsXmlSchemaIncludesAsync(schema, uri, basePath, cancellationToken).ConfigureAwait(false);
}
}
MetadataSet GetMetadataSetFromWsdl(string path)
{
var ms = new MetadataSet();
var sd = WSServiceDescription.Read(XmlReader.Create(path));
ms.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(sd));
foreach (XmlSchema xs in sd.Types.Schemas)
{
foreach (XmlSchemaImport import in xs.Includes)
{
using (var xr = XmlReader.Create(Path.Combine(Path.GetDirectoryName(path), import.SchemaLocation)))
ms.MetadataSections.Add(MetadataSection.CreateFromSchema(XmlSchema.Read(xr, null)));
}
}
return(ms);
}
public static List <string> MetadataSection(MetadataSection section)
{
return(new List <string>
{
string.Empty,
"[Metadata]",
"Title:" + section.Title,
"TitleUnicode:" + section.TitleUnicode,
"Artist:" + section.Artist,
"ArtistUnicode:" + section.ArtistUnicode,
"Creator:" + section.Creator,
"Version:" + section.Version,
"Source:" + section.Source,
"Tags:" + section.TagsString,
"BeatmapID:" + section.BeatmapID,
"BeatmapSetID:" + section.BeatmapSetID,
});
}
static void Main(string[] args)
{
MetadataSet metadata = new MetadataSet();
string address = "http://127.0.0.1:3721/calculatorservice/metadata";
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(address);
request.Method = "Get";
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
using (XmlReader reader = XmlDictionaryReader.CreateTextReader(response.GetResponseStream(), new XmlDictionaryReaderQuotas()))
{
System.Web.Services.Description.ServiceDescription serviceDesc = System.Web.Services.Description.ServiceDescription.Read(reader);
metadata.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(serviceDesc));
}
using (XmlWriter writer = new XmlTextWriter("metadata.xml", Encoding.UTF8))
{
metadata.WriteTo(writer);
}
Process.Start("metadata.xml");
}
private static void AddDocumentToResults(object document, Collection <MetadataSection> results)
{
var serviceDescr = document as SWSServiceDescription;
if (serviceDescr != null)
{
results.Add(MetadataSection.CreateFromServiceDescription(serviceDescr));
return;
}
var schema = document as XmlSchema;
if (schema != null)
{
results.Add(MetadataSection.CreateFromSchema(schema));
return;
}
throw new NotSupportedException(string.Format("Metadata type '{0}' is currently not supported.", document.GetType().FullName));
}
private XmlDictionaryReader CreateMetadataReader(Uri mexAddress)
{
var metadataSet = new MetadataSet();
var metadataReference = new MetadataReference(new EndpointAddress(mexAddress), AddressingVersion.WSAddressing10);
var metadataSection = new MetadataSection(MetadataSection.MetadataExchangeDialect, null, metadataReference);
metadataSet.MetadataSections.Add(metadataSection);
var sb = new StringBuilder();
var w = new StringWriter(sb, CultureInfo.InvariantCulture);
var writer = XmlWriter.Create(w);
metadataSet.WriteTo(writer);
writer.Flush();
w.Flush();
var input = new StringReader(sb.ToString());
var reader = new XmlTextReader(input);
return(XmlDictionaryReader.CreateDictionaryReader(reader));
}
private static IEnumerable <MetadataSection> LoadAsXmlSchema(XmlReader reader, string path)
{
XmlSchema schema;
try
{
schema = XmlSchema.Read(reader, null);
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
string message = string.Format("XML Schema Parsing Error while reading: '{0}'. Verify that the XML is both well-formed and valid.", path);
throw new MetadataDiscoveryException(message);
}
return(new List <MetadataSection> {
MetadataSection.CreateFromSchema(schema)
});
}
private static IEnumerable <MetadataSection> LoadAsWsdl(XmlReader reader, string path)
{
ServiceDescription description;
try
{
description = ServiceDescription.Read(reader);
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
string message = string.Format("WSDL Parsing Error while reading: '{0}'. Verify that the XML is both well-formed and valid.", path);
throw new MetadataDiscoveryException(message);
}
return(new List <MetadataSection> {
MetadataSection.CreateFromServiceDescription(description)
});
}
private void DownloadMetadata()
{
var results = new Collection <MetadataSection>();
if (DiscoveryClient.Documents.Values != null)
{
foreach (var document in DiscoveryClient.Documents.Values)
{
var wsdl = document as System.Web.Services.Description.ServiceDescription;
var schema = document as XmlSchema;
var xmlDoc = document as XmlElement;
if (wsdl != null)
{
var metaSect = MetadataSection.CreateFromServiceDescription(wsdl);
results.Add(metaSect);
}
else if (schema != null)
{
results.Add(MetadataSection.CreateFromSchema(schema));
}
else if (xmlDoc != null && xmlDoc.LocalName == "Policy")
{
results.Add(MetadataSection.CreateFromPolicy(xmlDoc, null));
}
else
{
var mexDoc = new MetadataSection();
mexDoc.Metadata = document;
results.Add(mexDoc);
}
}
}
Metadata = results;
}
/// <summary>
/// Create a reader to provide simulated Metadata endpoint configuration element
/// </summary>
/// <param name="activeSTSUrl">The active endpoint URL.</param>
static XmlDictionaryReader GetMetadataReader(string activeSTSUrl)
{
MetadataSet metadata = new MetadataSet();
MetadataReference mexReferece = new MetadataReference(new EndpointAddress(activeSTSUrl + "/mex"), AddressingVersion.WSAddressing10);
MetadataSection refSection = new MetadataSection(MetadataSection.MetadataExchangeDialect, null, mexReferece);
metadata.MetadataSections.Add(refSection);
byte[] metadataSectionBytes;
StringBuilder stringBuilder = new StringBuilder();
using (StringWriter stringWriter = new StringWriter(stringBuilder))
{
using (XmlTextWriter textWriter = new XmlTextWriter(stringWriter))
{
metadata.WriteTo(textWriter);
textWriter.Flush();
stringWriter.Flush();
metadataSectionBytes = stringWriter.Encoding.GetBytes(stringBuilder.ToString());
}
}
return(XmlDictionaryReader.CreateTextReader(metadataSectionBytes, XmlDictionaryReaderQuotas.Max));
}
private static Dictionary <MetadataSection, Dictionary <ushort, MetadataEntry> > CreateTagDictionary(
Document doc,
IDictionary <MetadataKey, MetadataEntry> entries,
ExifColorSpace exifColorSpace)
{
Dictionary <MetadataSection, Dictionary <ushort, MetadataEntry> > metadataEntries = new Dictionary <MetadataSection, Dictionary <ushort, MetadataEntry> >
{
{
MetadataSection.Image,
new Dictionary <ushort, MetadataEntry>
{
{
MetadataKeys.Image.Orientation.TagId,
new MetadataEntry(MetadataKeys.Image.Orientation,
TagDataType.Short,
MetadataHelpers.EncodeShort(TiffConstants.Orientation.TopLeft))
}
}
},
{
MetadataSection.Exif,
new Dictionary <ushort, MetadataEntry>()
}
};
// Add the image size tags.
if (IsUncompressedImage(entries))
{
Dictionary <ushort, MetadataEntry> imageSection = metadataEntries[MetadataSection.Image];
imageSection.Add(MetadataKeys.Image.ImageWidth.TagId,
new MetadataEntry(MetadataKeys.Image.ImageWidth,
TagDataType.Long,
MetadataHelpers.EncodeLong((uint)doc.Width)));
imageSection.Add(MetadataKeys.Image.ImageLength.TagId,
new MetadataEntry(MetadataKeys.Image.ImageLength,
TagDataType.Long,
MetadataHelpers.EncodeLong((uint)doc.Height)));
entries.Remove(MetadataKeys.Image.ImageWidth);
entries.Remove(MetadataKeys.Image.ImageLength);
// These tags should not be included in uncompressed images.
entries.Remove(MetadataKeys.Exif.PixelXDimension);
entries.Remove(MetadataKeys.Exif.PixelYDimension);
}
else
{
Dictionary <ushort, MetadataEntry> exifSection = metadataEntries[MetadataSection.Exif];
exifSection.Add(MetadataKeys.Exif.PixelXDimension.TagId,
new MetadataEntry(MetadataKeys.Exif.PixelXDimension,
TagDataType.Long,
MetadataHelpers.EncodeLong((uint)doc.Width)));
exifSection.Add(MetadataKeys.Exif.PixelYDimension.TagId,
new MetadataEntry(MetadataKeys.Exif.PixelYDimension,
TagDataType.Long,
MetadataHelpers.EncodeLong((uint)doc.Height)));
entries.Remove(MetadataKeys.Exif.PixelXDimension);
entries.Remove(MetadataKeys.Exif.PixelYDimension);
// These tags should not be included in compressed images.
entries.Remove(MetadataKeys.Image.ImageWidth);
entries.Remove(MetadataKeys.Image.ImageLength);
}
// Add the EXIF color space tag.
if (!entries.ContainsKey(MetadataKeys.Exif.ColorSpace))
{
metadataEntries[MetadataSection.Exif].Add(MetadataKeys.Exif.ColorSpace.TagId,
new MetadataEntry(MetadataKeys.Exif.ColorSpace,
TagDataType.Short,
MetadataHelpers.EncodeShort((ushort)exifColorSpace)));
}
foreach (KeyValuePair <MetadataKey, MetadataEntry> kvp in entries)
{
MetadataEntry entry = kvp.Value;
MetadataSection section = entry.Section;
if (section == MetadataSection.Image && !ExifTagHelper.CanWriteImageSectionTag(entry.TagId))
{
continue;
}
if (metadataEntries.TryGetValue(section, out Dictionary <ushort, MetadataEntry> values))
{
if (!values.ContainsKey(entry.TagId))
{
values.Add(entry.TagId, entry);
}
}
else
{
metadataEntries.Add(section, new Dictionary <ushort, MetadataEntry>
{
{ entry.TagId, entry }
});
}
}
AddVersionEntries(ref metadataEntries);
return(metadataEntries);
}
