Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataWeb / Server / System / Data / Services / Serializers / SyndicationSerializer.cs / 1305376 / SyndicationSerializer.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// Provides a serializer that creates syndication objects and
// then formatts them.
//
//
// @owner [....]
//---------------------------------------------------------------------
namespace System.Data.Services.Serializers
{
#region Namespaces.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data.Services.Common;
using System.Data.Services.Providers;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.ServiceModel.Syndication;
using System.Text;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Serialization;
#endregion Namespaces.
/// Serializes results into System.ServiceModel.Syndication objects, which can then be formatted.
internal sealed class SyndicationSerializer : Serializer
{
#region Fields.
/// Namespace-qualified attribute for null value annotations.
internal static readonly XmlQualifiedName QualifiedNullAttribute = new XmlQualifiedName(XmlConstants.AtomNullAttributeName, XmlConstants.DataWebMetadataNamespace);
/// Empty person singleton.
private static readonly SyndicationPerson EmptyPerson = new SyndicationPerson(null, String.Empty, null);
/// Namespace-qualified namespace prefix for the DataWeb namespace.
private static readonly XmlQualifiedName QualifiedDataWebPrefix = new XmlQualifiedName(XmlConstants.DataWebNamespacePrefix, XmlConstants.XmlNamespacesNamespace);
/// Namespace-qualified namespace prefix for the DataWebMetadata namespace.
private static readonly XmlQualifiedName QualifiedDataWebMetadataPrefix = new XmlQualifiedName(XmlConstants.DataWebMetadataNamespacePrefix, XmlConstants.XmlNamespacesNamespace);
/// Factory for syndication formatter implementation.
private readonly SyndicationFormatterFactory factory;
/// Last updated time for
///
/// While this is currently an arbitrary decision, it at least saves us from re-querying the system time
/// every time an item is generated.
///
private readonly DateTimeOffset lastUpdatedTime = DateTimeOffset.UtcNow;
/// Writer to which output is sent.
private readonly XmlWriter writer;
/// Top-level feed being built.
private SyndicationFeed resultFeed;
/// Top-level item being built.
private SyndicationItem resultItem;
#endregion Fields.
/// Initializes a new SyndicationSerializer instance.
/// Request description.
/// Absolute URI to the service entry point.
/// Service with configuration and provider from which metadata should be gathered.
/// Stream to write to.
/// Encoding for text in output stream.
/// HTTP ETag header value.
/// Factory for formatter objects.
internal SyndicationSerializer(
RequestDescription requestDescription,
Uri absoluteServiceUri,
IDataService service,
Stream output,
Encoding encoding,
string etag,
SyndicationFormatterFactory factory)
: base(requestDescription, absoluteServiceUri, service, etag)
{
Debug.Assert(service != null, "service != null");
Debug.Assert(output != null, "output != null");
Debug.Assert(encoding != null, "encoding != null");
Debug.Assert(factory != null, "factory != null");
this.factory = factory;
this.writer = factory.CreateWriter(output, encoding);
}
/// Serializes exception information.
/// Description of exception to serialize.
public override void WriteException(HandleExceptionArgs args)
{
ErrorHandler.SerializeXmlError(args, this.writer);
}
/// Writes a primitive value to the specified output.
/// Primitive value to write.
/// name of the property whose value needs to be written
/// Type name of the property
/// Content dictionary to which the value should be written.
internal static void WritePrimitiveValue(object primitive, string propertyName, string expectedTypeName, DictionaryContent content)
{
Debug.Assert(!String.IsNullOrEmpty(propertyName), "!String.IsNullOrEmpty(propertyName)");
Debug.Assert(expectedTypeName != null, "expectedTypeName != null");
if (primitive == null)
{
content.AddNull(expectedTypeName, propertyName);
}
else
{
string primitiveString = PlainXmlSerializer.PrimitiveToString(primitive);
Debug.Assert(primitiveString != null, "primitiveString != null");
content.Add(propertyName, expectedTypeName, primitiveString);
}
}
/// Writes an Atom link element.
/// relation of the link element with the parent element
/// title of the deferred element
/// uri for the deferred element
/// link type for the deferred element
/// Item to write link in.
internal static void WriteDeferredContentElement(string linkRelation, string title, string href, string linkType, SyndicationItem item)
{
Debug.Assert(linkRelation != null, "linkRelation != null");
Debug.Assert(item != null, "item != null");
Debug.Assert(linkType != null, "linkType != null");
SyndicationLink link = new SyndicationLink();
link.RelationshipType = linkRelation;
link.Title = title;
link.Uri = new Uri(href, UriKind.RelativeOrAbsolute);
link.MediaType = linkType;
item.Links.Add(link);
}
/// Flushes the writer to the underlying stream.
protected override void Flush()
{
this.writer.Flush();
}
/// Writes a single top-level element.
/// Expanded properties for the result.
/// Element to write, possibly null.
protected override void WriteTopLevelElement(IExpandedResult expanded, object element)
{
Debug.Assert(this.RequestDescription.IsSingleResult, "this.RequestDescription.SingleResult");
Debug.Assert(element != null, "element != null");
this.resultItem = new SyndicationItem();
this.resultItem.BaseUri = this.AbsoluteServiceUri;
IncludeCommonNamespaces(this.resultItem.AttributeExtensions);
if (this.RequestDescription.TargetSource == RequestTargetSource.EntitySet ||
this.RequestDescription.TargetSource == RequestTargetSource.ServiceOperation)
{
bool needPop = this.PushSegmentForRoot();
this.WriteEntryElement(
expanded,
element,
this.RequestDescription.TargetResourceType,
this.RequestDescription.ResultUri,
this.RequestDescription.ContainerName,
this.resultItem);
this.PopSegmentName(needPop);
}
else
{
Debug.Assert(
this.RequestDescription.TargetSource == RequestTargetSource.Property,
"TargetSource(" + this.RequestDescription.TargetSource + ") == Property -- otherwise control shouldn't be here.");
ResourceType resourcePropertyType;
if (this.RequestDescription.TargetKind == RequestTargetKind.OpenProperty)
{
resourcePropertyType = (element == null) ? ResourceType.PrimitiveStringResourceType : WebUtil.GetResourceType(this.Provider, element);
if (resourcePropertyType == null)
{
Type propertyType = element == null ? typeof(string) : element.GetType();
throw new InvalidOperationException(Strings.Serializer_UnsupportedTopLevelType(propertyType));
}
}
else
{
Debug.Assert(this.RequestDescription.Property != null, "this.RequestDescription.Property - otherwise Property source set with no Property specified.");
ResourceProperty property = this.RequestDescription.Property;
resourcePropertyType = property.ResourceType;
}
Debug.Assert(
resourcePropertyType.ResourceTypeKind == ResourceTypeKind.EntityType,
"Open ResourceTypeKind == EnityType -- temporarily, because ATOM is the only implemented syndication serializer and doesn't support it.");
bool needPop = this.PushSegmentForRoot();
this.WriteEntryElement(
expanded, // expanded
element, // element
resourcePropertyType, // expectedType
this.RequestDescription.ResultUri, // absoluteUri
this.RequestDescription.ContainerName, // relativeUri
this.resultItem); // target
this.PopSegmentName(needPop);
}
// Since the element is not equal to null, the factory should never return null
SyndicationItemFormatter formatter = this.factory.CreateSyndicationItemFormatter(this.resultItem);
formatter.WriteTo(this.writer);
}
/// Writes multiple top-level elements, possibly none.
/// Expanded properties for the result.
/// Enumerator for elements to write.
/// Whether
/// Write out the entry count
///
protected override void WriteRowCount()
{
XElement rowCountElement = new XElement(
XName.Get(XmlConstants.RowCountElement, XmlConstants.DataWebMetadataNamespace),
RequestDescription.CountValue);
this.resultFeed.ElementExtensions.Add(rowCountElement);
}
///
/// Write out the uri for the given element
///
/// element whose uri needs to be written out.
protected override void WriteLink(object element)
{
throw Error.NotImplemented();
}
///
/// Write out the uri for the given elements
///
/// elements whose uri need to be writtne out
/// the current state of the enumerator.
protected override void WriteLinkCollection(IEnumerator elements, bool hasMoved)
{
throw Error.NotImplemented();
}
/// Ensures that common namespaces are included in the topmost tag.
/// Attribute extensions to write namespaces to.
///
/// This method should be called by any method that may write a
/// topmost element tag.
///
private static void IncludeCommonNamespaces(Dictionary attributeExtensions)
{
attributeExtensions.Add(QualifiedDataWebPrefix, XmlConstants.DataWebNamespace);
attributeExtensions.Add(QualifiedDataWebMetadataPrefix, XmlConstants.DataWebMetadataNamespace);
}
/// Sets the type name for the specified syndication entry.
/// Item on which to set the type name.
/// Full type name for the entry.
private static void SetEntryTypeName(SyndicationItem item, string fullName)
{
Debug.Assert(item != null, "item != null");
item.Categories.Add(new SyndicationCategory(fullName, XmlConstants.DataWebSchemeNamespace, null));
}
///
/// Write the link relation element
///
/// title for the current element
/// link relation for the self uri
/// relative uri for the current element
/// Item to write to.
/// List of custom attributes to add to the link element
private static void WriteLinkRelations(string title, string linkRelation, string relativeUri, SyndicationItem item, params KeyValuePair[] attributeExtensions)
{
Debug.Assert(item != null, "item != null");
Debug.Assert(relativeUri != null, "relativeUri != null");
// Write the link relation element
var link = new SyndicationLink();
link.RelationshipType = linkRelation;
link.Title = title;
link.Uri = new Uri(relativeUri, UriKind.Relative);
foreach (KeyValuePair attributeExtension in attributeExtensions)
{
link.AttributeExtensions.Add(attributeExtension.Key, attributeExtension.Value);
}
item.Links.Add(link);
}
///
/// Checks if a particular property value should be skipped from the content section due to
/// EntityProperty mappings for friendly feeds
///
/// Current root segment in the source tree for a resource type
/// Name of the property being checked for
/// true if skipping of property value is needed, false otherwise
private static bool EpmNeedToSkip(EpmSourcePathSegment currentSourceRoot, String propertyName)
{
if (currentSourceRoot != null)
{
EpmSourcePathSegment epmProperty = currentSourceRoot.SubProperties.Find(subProp => subProp.PropertyName == propertyName);
if (epmProperty != null)
{
Debug.Assert(epmProperty.SubProperties.Count == 0, "Complex type added as leaf node in EPM tree.");
Debug.Assert(epmProperty.EpmInfo != null, "Found a non-leaf property for which EpmInfo is not set.");
Debug.Assert(epmProperty.EpmInfo.Attribute != null, "Attribute should always be initialized for EpmInfo.");
if (epmProperty.EpmInfo.Attribute.KeepInContent == false)
{
return true;
}
}
}
return false;
}
///
/// Obtains the child EPM segment corresponding to the given
/// Current root segment
/// Name of property
/// Child segment or null if there is not segment corresponding to the given
private static EpmSourcePathSegment EpmGetComplexPropertySegment(EpmSourcePathSegment currentSourceRoot, String propertyName)
{
if (currentSourceRoot != null)
{
return currentSourceRoot.SubProperties.Find(subProp => subProp.PropertyName == propertyName);
}
else
{
return null;
}
}
/// Writes the value of a complex object.
/// Element to write.
/// name of the property whose value needs to be written
/// expected type of the property
/// relative uri for the complex type element
/// Content to write to.
/// Epm source sub-tree corresponding to Write the entry element.
/// Expanded result provider for the specified
/// Writes the feed element for the atom payload
///
/// Expanded properties for the result.
/// collection of entries in the feed element
/// expectedType of the elements in the collection
/// title of the feed element
/// absolute uri representing the feed element
/// relative uri representing the feed element
/// whether the enumerator has successfully moved to the first element
/// Feed to write to.
/// If set to true the function should dispose the elements enumerator when it's done
/// with it. Not in the case this method fails though.
private void WriteFeedElements(
IExpandedResult expanded,
IEnumerator elements,
ResourceType expectedType,
string title,
Uri absoluteUri,
string relativeUri,
bool hasMoved,
SyndicationFeed feed,
bool disposeElementsOnSuccess)
{
Debug.Assert(feed != null, "feed != null");
// Write the other elements for the feed
feed.Id = absoluteUri.AbsoluteUri;
feed.Title = new TextSyndicationContent(title);
var uri = new Uri(relativeUri, UriKind.Relative);
var link = new SyndicationLink(uri, XmlConstants.AtomSelfRelationAttributeValue, title, null, 0L);
feed.Links.Add(link);
if (!hasMoved)
{
// ATOM specification: if a feed contains no entries, then the feed should have at least one Author tag
feed.Authors.Add(EmptyPerson);
}
// Instead of looping, create an item that will defer the production of SyndicationItem instances.
// PERF: consider optimizing out empty collections when hasMoved is false.
feed.Items = this.DeferredFeedItems(
expanded,
elements,
expectedType,
hasMoved,
this.SaveSegmentNames(),
(o, e) => this.WriteNextPageLink(o, e, absoluteUri),
disposeElementsOnSuccess);
#if ASTORIA_FF_CALLBACKS
this.Service.InternalOnWriteFeed(feed);
#endif
}
///
/// Writes the next page link to the current xml writer corresponding to the feed
///
/// Object that will contain the keys for skip token
/// The Provides an enumeration of deferred feed items.
/// Expanded properties for the result.
/// Elements to enumerate.
/// Expected type of elements.
/// Whether the enumerator moved to the first element.
/// The segment names active at this point in serialization.
/// Delegate that writes the next page link if necessity arises
/// If set to true the function should dispose the elements enumerator (always).
/// An object that can enumerate syndication items.
private IEnumerable DeferredFeedItems(
IExpandedResult expanded,
IEnumerator elements,
ResourceType expectedType,
bool hasMoved,
object activeSegmentNames,
Action nextPageLinkWriter,
bool disposeElements)
{
try
{
object savedSegmentNames = this.SaveSegmentNames();
this.RestoreSegmentNames(activeSegmentNames);
object lastObject = null;
IExpandedResult lastExpandedSkipToken = null;
while (hasMoved)
{
object o = elements.Current;
IExpandedResult skipToken = this.GetSkipToken(expanded);
if (o != null)
{
SyndicationItem target = new SyndicationItem();
IExpandedResult expandedO = o as IExpandedResult;
if (expandedO != null)
{
expanded = expandedO;
o = GetExpandedElement(expanded);
skipToken = this.GetSkipToken(expanded);
}
this.WriteEntryElement(expanded, o, expectedType, null, null, target);
yield return target;
}
hasMoved = elements.MoveNext();
lastObject = o;
lastExpandedSkipToken = skipToken;
}
// After looping through the objects in the sequence, decide if we need to write the next
// page link and if yes, write it by invoking the delegate
if (this.NeedNextPageLink(elements))
{
nextPageLinkWriter(lastObject, lastExpandedSkipToken);
}
this.RestoreSegmentNames(savedSegmentNames);
}
finally
{
if (disposeElements)
{
WebUtil.Dispose(elements);
}
}
}
///
/// Write entry/feed elements, except the content element and related links
///
/// entity instance being serialized
/// resource type of the entry element
/// title for the current element
/// absolute uri for the current element
/// relative uri for the current element
/// entity tag for the Media Resource
/// Item to write to.
private void WriteOtherElements(object element, ResourceType type, string title, Uri absoluteUri, string relativeUri, string mediaETag, SyndicationItem item)
{
Debug.Assert(item != null, "item != null");
Debug.Assert(absoluteUri != null, "absoluteUri != null");
Debug.Assert(relativeUri != null, "relativeUri != null");
// Write Id element
item.Id = absoluteUri.AbsoluteUri;
// Write Updated element
item.LastUpdatedTime = this.lastUpdatedTime;
// Write "edit-media" link
if (type != null && type.IsMediaLinkEntry)
{
KeyValuePair[] attributeExtensions = new KeyValuePair[0];
if (element != null && !string.IsNullOrEmpty(mediaETag))
{
XmlQualifiedName mediaResourceETagKey = new XmlQualifiedName(XmlConstants.AtomETagAttributeName, XmlConstants.DataWebMetadataNamespace);
attributeExtensions = new KeyValuePair[] { new KeyValuePair(mediaResourceETagKey, mediaETag) };
}
WriteLinkRelations(
title,
XmlConstants.AtomEditMediaRelationAttributeValue,
DataServiceStreamProviderWrapper.GetStreamEditMediaUri(relativeUri),
item,
attributeExtensions);
}
// Write "edit" link
WriteLinkRelations(
title,
XmlConstants.AtomEditRelationAttributeValue,
relativeUri,
item);
}
/// Writes all the properties of the specified resource or complex object.
/// Expanded properties for the result.
/// Resource or complex object with properties to write out.
/// resourceType containing metadata about the current custom object
/// absolute uri for the given resource
/// relative uri for the given resource
/// Item in which to place links / expansions.
/// Content in which to place values.
/// Epm source sub-tree corresponding to navProperties = null;
IEnumerable projectionNodes = null;
if (resourceType.ResourceTypeKind == ResourceTypeKind.EntityType)
{
Debug.Assert(this.CurrentContainer != null, "this.CurrentContainer != null");
if (this.Provider.IsEntityTypeDisallowedForSet(this.CurrentContainer, resourceType))
{
throw new InvalidOperationException(Strings.BaseServiceProvider_NavigationPropertiesOnDerivedEntityTypesNotSupported(resourceType.FullName, this.CurrentContainer.Name));
}
navProperties = new List(resourceType.Properties.Count);
projectionNodes = this.GetProjections();
}
if (projectionNodes == null)
{
var action = resourceType.DictionarySerializerDelegate;
if (action == null && this.Provider.IsV1Provider)
{
Module module = typeof(SyndicationSerializer).Module;
Type customObjectType = customObject.GetType();
Type[] parameterTypes = new Type[] { typeof(object), typeof(DictionaryContent) };
DynamicMethod method = new DynamicMethod("content_populator", typeof(void), parameterTypes, module, false /* skipVisibility */);
ILGenerator generator = method.GetILGenerator();
MethodInfo methodWritePrimitiveValue = typeof(SyndicationSerializer).GetMethod("WritePrimitiveValue", BindingFlags.Static | BindingFlags.NonPublic);
// Downcast the argument.
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Castclass, customObjectType);
foreach (ResourceProperty property in resourceType.Properties.Where(p => p.TypeKind == ResourceTypeKind.Primitive))
{
if (SyndicationSerializer.EpmNeedToSkip(currentSourceRoot, property.Name))
{
continue;
}
// WritePrimitiveValue(propertyValue, property.Name, property.ResourceType, content);
generator.Emit(OpCodes.Dup);
generator.Emit(OpCodes.Call, resourceType.GetPropertyInfo(property).GetGetMethod());
if (property.Type.IsValueType)
{
generator.Emit(OpCodes.Box, property.Type);
}
generator.Emit(OpCodes.Ldstr, property.Name);
generator.Emit(OpCodes.Ldstr, property.ResourceType.FullName);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Call, methodWritePrimitiveValue);
}
generator.Emit(OpCodes.Pop);
generator.Emit(OpCodes.Ret);
action = (Action)method.CreateDelegate(typeof(Action), null);
resourceType.DictionarySerializerDelegate = action;
}
if (action != null)
{
action(customObject, content);
}
else
{
foreach (ResourceProperty property in resourceType.Properties.Where(p => p.TypeKind == ResourceTypeKind.Primitive))
{
object propertyValue = WebUtil.GetPropertyValue(this.Provider, customObject, resourceType, property, null);
if (SyndicationSerializer.EpmNeedToSkip(currentSourceRoot, property.Name))
{
continue;
}
WritePrimitiveValue(propertyValue, property.Name, property.ResourceType.FullName, content);
}
}
foreach (ResourceProperty property in this.Provider.GetResourceProperties(this.CurrentContainer, resourceType))
{
string propertyName = property.Name;
if (property.TypeKind == ResourceTypeKind.EntityType)
{
Debug.Assert(navProperties != null, "navProperties list must be assigned for entity types");
object propertyValue =
(this.ShouldExpandSegment(property.Name)) ? GetExpandedProperty(this.Provider, expanded, customObject, property) : null;
navProperties.Add(new ResourcePropertyInfo(property, propertyValue));
}
else
{
if (property.TypeKind == ResourceTypeKind.ComplexType)
{
object propertyValue = WebUtil.GetPropertyValue(this.Provider, customObject, resourceType, property, null);
bool needPop = this.PushSegmentForProperty(property);
this.WriteComplexObjectValue(
propertyValue,
propertyName,
property.ResourceType,
relativeUri + "/" + property.Name,
content,
SyndicationSerializer.EpmGetComplexPropertySegment(currentSourceRoot, property.Name));
this.PopSegmentName(needPop);
}
}
}
if (resourceType.IsOpenType)
{
IEnumerable> properties = this.Provider.GetOpenPropertyValues(customObject);
foreach (KeyValuePair property in properties)
{
string propertyName = property.Key;
if (String.IsNullOrEmpty(propertyName))
{
throw new DataServiceException(500, Strings.Syndication_InvalidOpenPropertyName(resourceType.FullName));
}
Type valueType;
ResourceType propertyResourceType;
object value = property.Value;
if (value == null || value == DBNull.Value)
{
valueType = typeof(string);
propertyResourceType = ResourceType.PrimitiveStringResourceType;
}
else
{
valueType = value.GetType();
propertyResourceType = WebUtil.GetResourceType(this.Provider, value);
}
// A null ResourceType indicates a ----ed type (eg, IntPtr or DateTimeOffset). So ignore it.
if (propertyResourceType == null)
{
throw new DataServiceException(500, Strings.Syndication_InvalidOpenPropertyType(propertyName));
}
if (propertyResourceType.ResourceTypeKind == ResourceTypeKind.Primitive)
{
if (value != null && SyndicationSerializer.EpmNeedToSkip(currentSourceRoot, propertyName))
{
continue;
}
WritePrimitiveValue(value, propertyName, propertyResourceType.FullName, content);
}
else
{
if (propertyResourceType.ResourceTypeKind == ResourceTypeKind.ComplexType)
{
Debug.Assert(propertyResourceType.InstanceType == valueType, "propertyResourceType.Type == valueType");
this.WriteComplexObjectValue(
value,
propertyName,
propertyResourceType,
relativeUri + "/" + propertyName,
content,
SyndicationSerializer.EpmGetComplexPropertySegment(currentSourceRoot, propertyName));
}
else
{
Debug.Assert(
propertyResourceType.ResourceTypeKind == ResourceTypeKind.EntityType,
"propertyResourceType.ResourceTypeKind == ResourceTypeKind.EntityType -- otherwise should have been processed as primitve or complex type.");
// Open navigation properties are not supported on OpenTypes
throw DataServiceException.CreateBadRequestError(Strings.OpenNavigationPropertiesNotSupportedOnOpenTypes(propertyName));
}
}
}
}
}
else
{
foreach (ProjectionNode projectionNode in projectionNodes)
{
string propertyName = projectionNode.PropertyName;
ResourceProperty property = resourceType.TryResolvePropertyName(propertyName);
// First solve the normal entity type property - turn it into a nav. property record
if (property != null && property.TypeKind == ResourceTypeKind.EntityType)
{
Debug.Assert(navProperties != null, "navProperties list must be assigned for entity types");
// By calling the GetResourceProperties we will use the cached list of properties
// for the given type and set. But we have to search through it.
// We could use the GetContainer (since that's what the GetResourceProperties does) and check
// if it returns null, but result of that is only partially cached so it might be expensive
// to evaluate for each item in the feed.
if (this.Provider.GetResourceProperties(this.CurrentContainer, resourceType).Contains(property))
{
object expandedPropertyValue =
(this.ShouldExpandSegment(propertyName)) ? GetExpandedProperty(this.Provider, expanded, customObject, property) : null;
navProperties.Add(new ResourcePropertyInfo(property, expandedPropertyValue));
}
continue;
}
// Now get the property value
object propertyValue = WebUtil.GetPropertyValue(this.Provider, customObject, resourceType, property, property == null ? propertyName : null);
// Determine the type of the property
ResourceType propertyResourceType;
if (property != null)
{
propertyResourceType = property.ResourceType;
}
else
{
if (propertyValue == null || propertyValue == DBNull.Value)
{
propertyResourceType = ResourceType.PrimitiveStringResourceType;
}
else
{
propertyResourceType = WebUtil.GetResourceType(this.Provider, propertyValue);
// A null ResourceType indicates a ----ed type (eg, IntPtr or DateTimeOffset). So ignore it.
if (propertyResourceType == null)
{
throw new DataServiceException(500, Strings.Syndication_InvalidOpenPropertyType(propertyName));
}
}
}
// And write out the value (depending on the type of the property)
if (propertyResourceType.ResourceTypeKind == ResourceTypeKind.Primitive)
{
if (propertyValue == DBNull.Value)
{
propertyValue = null;
}
if (propertyValue != null && SyndicationSerializer.EpmNeedToSkip(currentSourceRoot, propertyName))
{
continue;
}
WritePrimitiveValue(propertyValue, propertyName, propertyResourceType.FullName, content);
}
else if (propertyResourceType.ResourceTypeKind == ResourceTypeKind.ComplexType)
{
bool needPop = false;
if (property != null)
{
needPop = this.PushSegmentForProperty(property);
}
this.WriteComplexObjectValue(
propertyValue,
propertyName,
propertyResourceType,
relativeUri + "/" + propertyName,
content,
SyndicationSerializer.EpmGetComplexPropertySegment(currentSourceRoot, propertyName));
if (property != null)
{
this.PopSegmentName(needPop);
}
}
else
{
Debug.Assert(
propertyResourceType.ResourceTypeKind == ResourceTypeKind.EntityType,
"propertyResourceType.ResourceTypeKind == ResourceTypeKind.EntityType -- otherwise should have been processed as primitve or complex type.");
// Open navigation properties are not supported on OpenTypes
throw DataServiceException.CreateBadRequestError(Strings.OpenNavigationPropertiesNotSupportedOnOpenTypes(propertyName));
}
}
}
if (resourceType.ResourceTypeKind == ResourceTypeKind.EntityType)
{
for (int i = 0; i < navProperties.Count; i++)
{
ResourcePropertyInfo propertyInfo = navProperties[i];
ResourceProperty navProperty = propertyInfo.Property;
Debug.Assert(
navProperty.IsOfKind(ResourcePropertyKind.ResourceReference) ||
navProperty.IsOfKind(ResourcePropertyKind.ResourceSetReference),
"this must be nav property");
// Generate a link - see http://tools.ietf.org/html/rfc4287#section-4.2.7
string linkType = navProperty.IsOfKind(ResourcePropertyKind.ResourceReference) ? XmlConstants.AtomEntryElementName : XmlConstants.AtomFeedElementName;
linkType = String.Format(CultureInfo.InvariantCulture, "{0};{1}={2}", XmlConstants.MimeApplicationAtom, XmlConstants.AtomTypeAttributeName, linkType);
string segmentIdentifier = navProperty.Name;
if (!this.ShouldExpandSegment(navProperty.Name))
{
WriteDeferredContentElement(
XmlConstants.DataWebRelatedNamespace + navProperty.Name,
navProperty.Name,
relativeUri + "/" + segmentIdentifier,
linkType,
item);
}
else
{
object propertyValue = propertyInfo.Value;
IExpandedResult expandedResultPropertyValue = propertyValue as IExpandedResult;
object expandedPropertyValue =
expandedResultPropertyValue != null ?
GetExpandedElement(expandedResultPropertyValue) :
propertyValue;
string propertyRelativeUri = relativeUri + "/" + segmentIdentifier;
Uri propertyAbsoluteUri = RequestUriProcessor.AppendUnescapedSegment(absoluteUri, segmentIdentifier);
SyndicationLink link = new SyndicationLink();
link.RelationshipType = XmlConstants.DataWebRelatedNamespace + navProperty.Name;
link.Title = navProperty.Name;
link.Uri = new Uri(propertyRelativeUri, UriKind.RelativeOrAbsolute);
link.MediaType = linkType;
item.Links.Add(link);
bool needPop = this.PushSegmentForProperty(navProperty);
// if this.CurrentContainer is null, the target set of the navigation property is hidden.
if (this.CurrentContainer != null)
{
if (navProperty.IsOfKind(ResourcePropertyKind.ResourceSetReference))
{
IEnumerable enumerable;
bool collection = WebUtil.IsElementIEnumerable(expandedPropertyValue, out enumerable);
Debug.Assert(collection, "metadata loading must have ensured that navigation set properties must implement IEnumerable");
SyndicationFeed feed = new SyndicationFeed();
InlineAtomFeed inlineFeedExtension = new InlineAtomFeed(feed, this.factory);
link.ElementExtensions.Add(inlineFeedExtension);
IEnumerator enumerator = enumerable.GetEnumerator();
try
{
bool hasMoved = enumerator.MoveNext();
this.WriteFeedElements(
propertyValue as IExpandedResult,
enumerator,
navProperty.ResourceType,
navProperty.Name,
propertyAbsoluteUri,
propertyRelativeUri,
hasMoved,
feed,
true);
}
catch
{
WebUtil.Dispose(enumerator);
throw;
}
}
else
{
SyndicationItem inlineItem = new SyndicationItem();
this.WriteEntryElement(propertyValue as IExpandedResult, expandedPropertyValue, navProperty.ResourceType, propertyAbsoluteUri, propertyRelativeUri, inlineItem);
InlineAtomItem inlineItemExtension = new InlineAtomItem(inlineItem, this.factory);
link.ElementExtensions.Add(inlineItemExtension);
}
}
this.PopSegmentName(needPop);
}
}
}
}
finally
{
// The matching call to RecurseLeave is in a try/finally block not because it's necessary in the
// presence of an exception (progress will halt anyway), but because it's easier to maintain in the
// code in the presence of multiple exit points (returns).
this.RecurseLeave();
}
}
#region Inner types.
/// Stores the resource property, its value and a flag which indicates whether this is a open property or not.
private struct ResourcePropertyInfo
{
/// refers to the property that this instance represents.
private ResourceProperty resourceProperty;
/// Value of the property.
private object value;
///
/// Creates a new instance of ResourcePropertyInfo.
///
/// resource property instance.
/// value for the resource property.
public ResourcePropertyInfo(ResourceProperty resourceProperty, object value)
{
Debug.Assert(resourceProperty != null, "resourceProperty != null");
this.resourceProperty = resourceProperty;
this.value = value;
}
/// Returns the resource property.
internal ResourceProperty Property
{
get { return this.resourceProperty; }
}
/// Returns the value of the resource property.
internal object Value
{
get { return this.value; }
}
}
/// Wrapper for an inline item.
[XmlRoot(ElementName = XmlConstants.AtomInlineElementName, Namespace = XmlConstants.DataWebMetadataNamespace)]
internal class InlineAtomItem : IXmlSerializable
{
/// Factory for item formatter.
private readonly SyndicationFormatterFactory factory;
/// Item being serialized.
private SyndicationItem item;
/// Empty constructor.
internal InlineAtomItem()
{
}
/// Initializing constructor.
/// Item being serialized.
/// Factory for item formatter.
internal InlineAtomItem(SyndicationItem item, SyndicationFormatterFactory factory)
{
this.item = item;
this.factory = factory;
}
#region IXmlSerializable Members
/// Reserved method.
/// null
public System.Xml.Schema.XmlSchema GetSchema()
{
return null;
}
/// Generates an object from its XML representation.
/// XmlReader with representation.
public void ReadXml(XmlReader reader)
{
throw Error.NotImplemented();
}
/// Converts an object into its XML representation.
/// Writer to write representation into.
public void WriteXml(XmlWriter writer)
{
SyndicationItemFormatter formatter = this.factory.CreateSyndicationItemFormatter(this.item);
if (formatter != null)
{
formatter.WriteTo(writer);
}
}
#endregion
}
/// Wrapper for an inline feed.
[XmlRoot(ElementName = XmlConstants.AtomInlineElementName, Namespace = XmlConstants.DataWebMetadataNamespace)]
internal class InlineAtomFeed : IXmlSerializable
{
/// Factory for item formatter.
private readonly SyndicationFormatterFactory factory;
/// Feed being serialized.
private SyndicationFeed feed;
/// Empty constructor.
internal InlineAtomFeed()
{
}
/// Initializing constructor.
/// Feed being serialized.
/// Factory for item formatter.
internal InlineAtomFeed(SyndicationFeed feed, SyndicationFormatterFactory factory)
{
this.feed = feed;
this.factory = factory;
}
#region IXmlSerializable Members
/// Reserved method.
/// null
public System.Xml.Schema.XmlSchema GetSchema()
{
return null;
}
/// Generates an object from its XML representation.
/// XmlReader with representation.
public void ReadXml(XmlReader reader)
{
throw Error.NotImplemented();
}
/// Converts an object into its XML representation.
/// Writer to write representation into.
public void WriteXml(XmlWriter writer)
{
this.factory.CreateSyndicationFeedFormatter(this.feed).WriteTo(writer);
}
#endregion
}
#endregion Inner types.
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// Provides a serializer that creates syndication objects and
// then formatts them.
//
//
// @owner [....]
//---------------------------------------------------------------------
namespace System.Data.Services.Serializers
{
#region Namespaces.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data.Services.Common;
using System.Data.Services.Providers;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.ServiceModel.Syndication;
using System.Text;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Serialization;
#endregion Namespaces.
/// Serializes results into System.ServiceModel.Syndication objects, which can then be formatted.
internal sealed class SyndicationSerializer : Serializer
{
#region Fields.
/// Namespace-qualified attribute for null value annotations.
internal static readonly XmlQualifiedName QualifiedNullAttribute = new XmlQualifiedName(XmlConstants.AtomNullAttributeName, XmlConstants.DataWebMetadataNamespace);
/// Empty person singleton.
private static readonly SyndicationPerson EmptyPerson = new SyndicationPerson(null, String.Empty, null);
/// Namespace-qualified namespace prefix for the DataWeb namespace.
private static readonly XmlQualifiedName QualifiedDataWebPrefix = new XmlQualifiedName(XmlConstants.DataWebNamespacePrefix, XmlConstants.XmlNamespacesNamespace);
/// Namespace-qualified namespace prefix for the DataWebMetadata namespace.
private static readonly XmlQualifiedName QualifiedDataWebMetadataPrefix = new XmlQualifiedName(XmlConstants.DataWebMetadataNamespacePrefix, XmlConstants.XmlNamespacesNamespace);
/// Factory for syndication formatter implementation.
private readonly SyndicationFormatterFactory factory;
/// Last updated time for
///
/// While this is currently an arbitrary decision, it at least saves us from re-querying the system time
/// every time an item is generated.
///
private readonly DateTimeOffset lastUpdatedTime = DateTimeOffset.UtcNow;
/// Writer to which output is sent.
private readonly XmlWriter writer;
/// Top-level feed being built.
private SyndicationFeed resultFeed;
/// Top-level item being built.
private SyndicationItem resultItem;
#endregion Fields.
/// Initializes a new SyndicationSerializer instance.
/// Request description.
/// Absolute URI to the service entry point.
/// Service with configuration and provider from which metadata should be gathered.
/// Stream to write to.
/// Encoding for text in output stream.
/// HTTP ETag header value.
/// Factory for formatter objects.
internal SyndicationSerializer(
RequestDescription requestDescription,
Uri absoluteServiceUri,
IDataService service,
Stream output,
Encoding encoding,
string etag,
SyndicationFormatterFactory factory)
: base(requestDescription, absoluteServiceUri, service, etag)
{
Debug.Assert(service != null, "service != null");
Debug.Assert(output != null, "output != null");
Debug.Assert(encoding != null, "encoding != null");
Debug.Assert(factory != null, "factory != null");
this.factory = factory;
this.writer = factory.CreateWriter(output, encoding);
}
/// Serializes exception information.
/// Description of exception to serialize.
public override void WriteException(HandleExceptionArgs args)
{
ErrorHandler.SerializeXmlError(args, this.writer);
}
/// Writes a primitive value to the specified output.
/// Primitive value to write.
/// name of the property whose value needs to be written
/// Type name of the property
/// Content dictionary to which the value should be written.
internal static void WritePrimitiveValue(object primitive, string propertyName, string expectedTypeName, DictionaryContent content)
{
Debug.Assert(!String.IsNullOrEmpty(propertyName), "!String.IsNullOrEmpty(propertyName)");
Debug.Assert(expectedTypeName != null, "expectedTypeName != null");
if (primitive == null)
{
content.AddNull(expectedTypeName, propertyName);
}
else
{
string primitiveString = PlainXmlSerializer.PrimitiveToString(primitive);
Debug.Assert(primitiveString != null, "primitiveString != null");
content.Add(propertyName, expectedTypeName, primitiveString);
}
}
/// Writes an Atom link element.
/// relation of the link element with the parent element
/// title of the deferred element
/// uri for the deferred element
/// link type for the deferred element
/// Item to write link in.
internal static void WriteDeferredContentElement(string linkRelation, string title, string href, string linkType, SyndicationItem item)
{
Debug.Assert(linkRelation != null, "linkRelation != null");
Debug.Assert(item != null, "item != null");
Debug.Assert(linkType != null, "linkType != null");
SyndicationLink link = new SyndicationLink();
link.RelationshipType = linkRelation;
link.Title = title;
link.Uri = new Uri(href, UriKind.RelativeOrAbsolute);
link.MediaType = linkType;
item.Links.Add(link);
}
/// Flushes the writer to the underlying stream.
protected override void Flush()
{
this.writer.Flush();
}
/// Writes a single top-level element.
/// Expanded properties for the result.
/// Element to write, possibly null.
protected override void WriteTopLevelElement(IExpandedResult expanded, object element)
{
Debug.Assert(this.RequestDescription.IsSingleResult, "this.RequestDescription.SingleResult");
Debug.Assert(element != null, "element != null");
this.resultItem = new SyndicationItem();
this.resultItem.BaseUri = this.AbsoluteServiceUri;
IncludeCommonNamespaces(this.resultItem.AttributeExtensions);
if (this.RequestDescription.TargetSource == RequestTargetSource.EntitySet ||
this.RequestDescription.TargetSource == RequestTargetSource.ServiceOperation)
{
bool needPop = this.PushSegmentForRoot();
this.WriteEntryElement(
expanded,
element,
this.RequestDescription.TargetResourceType,
this.RequestDescription.ResultUri,
this.RequestDescription.ContainerName,
this.resultItem);
this.PopSegmentName(needPop);
}
else
{
Debug.Assert(
this.RequestDescription.TargetSource == RequestTargetSource.Property,
"TargetSource(" + this.RequestDescription.TargetSource + ") == Property -- otherwise control shouldn't be here.");
ResourceType resourcePropertyType;
if (this.RequestDescription.TargetKind == RequestTargetKind.OpenProperty)
{
resourcePropertyType = (element == null) ? ResourceType.PrimitiveStringResourceType : WebUtil.GetResourceType(this.Provider, element);
if (resourcePropertyType == null)
{
Type propertyType = element == null ? typeof(string) : element.GetType();
throw new InvalidOperationException(Strings.Serializer_UnsupportedTopLevelType(propertyType));
}
}
else
{
Debug.Assert(this.RequestDescription.Property != null, "this.RequestDescription.Property - otherwise Property source set with no Property specified.");
ResourceProperty property = this.RequestDescription.Property;
resourcePropertyType = property.ResourceType;
}
Debug.Assert(
resourcePropertyType.ResourceTypeKind == ResourceTypeKind.EntityType,
"Open ResourceTypeKind == EnityType -- temporarily, because ATOM is the only implemented syndication serializer and doesn't support it.");
bool needPop = this.PushSegmentForRoot();
this.WriteEntryElement(
expanded, // expanded
element, // element
resourcePropertyType, // expectedType
this.RequestDescription.ResultUri, // absoluteUri
this.RequestDescription.ContainerName, // relativeUri
this.resultItem); // target
this.PopSegmentName(needPop);
}
// Since the element is not equal to null, the factory should never return null
SyndicationItemFormatter formatter = this.factory.CreateSyndicationItemFormatter(this.resultItem);
formatter.WriteTo(this.writer);
}
/// Writes multiple top-level elements, possibly none.
/// Expanded properties for the result.
/// Enumerator for elements to write.
/// Whether
/// Write out the entry count
///
protected override void WriteRowCount()
{
XElement rowCountElement = new XElement(
XName.Get(XmlConstants.RowCountElement, XmlConstants.DataWebMetadataNamespace),
RequestDescription.CountValue);
this.resultFeed.ElementExtensions.Add(rowCountElement);
}
///
/// Write out the uri for the given element
///
/// element whose uri needs to be written out.
protected override void WriteLink(object element)
{
throw Error.NotImplemented();
}
///
/// Write out the uri for the given elements
///
/// elements whose uri need to be writtne out
/// the current state of the enumerator.
protected override void WriteLinkCollection(IEnumerator elements, bool hasMoved)
{
throw Error.NotImplemented();
}
/// Ensures that common namespaces are included in the topmost tag.
/// Attribute extensions to write namespaces to.
///
/// This method should be called by any method that may write a
/// topmost element tag.
///
private static void IncludeCommonNamespaces(Dictionary attributeExtensions)
{
attributeExtensions.Add(QualifiedDataWebPrefix, XmlConstants.DataWebNamespace);
attributeExtensions.Add(QualifiedDataWebMetadataPrefix, XmlConstants.DataWebMetadataNamespace);
}
/// Sets the type name for the specified syndication entry.
/// Item on which to set the type name.
/// Full type name for the entry.
private static void SetEntryTypeName(SyndicationItem item, string fullName)
{
Debug.Assert(item != null, "item != null");
item.Categories.Add(new SyndicationCategory(fullName, XmlConstants.DataWebSchemeNamespace, null));
}
///
/// Write the link relation element
///
/// title for the current element
/// link relation for the self uri
/// relative uri for the current element
/// Item to write to.
/// List of custom attributes to add to the link element
private static void WriteLinkRelations(string title, string linkRelation, string relativeUri, SyndicationItem item, params KeyValuePair[] attributeExtensions)
{
Debug.Assert(item != null, "item != null");
Debug.Assert(relativeUri != null, "relativeUri != null");
// Write the link relation element
var link = new SyndicationLink();
link.RelationshipType = linkRelation;
link.Title = title;
link.Uri = new Uri(relativeUri, UriKind.Relative);
foreach (KeyValuePair attributeExtension in attributeExtensions)
{
link.AttributeExtensions.Add(attributeExtension.Key, attributeExtension.Value);
}
item.Links.Add(link);
}
///
/// Checks if a particular property value should be skipped from the content section due to
/// EntityProperty mappings for friendly feeds
///
/// Current root segment in the source tree for a resource type
/// Name of the property being checked for
/// true if skipping of property value is needed, false otherwise
private static bool EpmNeedToSkip(EpmSourcePathSegment currentSourceRoot, String propertyName)
{
if (currentSourceRoot != null)
{
EpmSourcePathSegment epmProperty = currentSourceRoot.SubProperties.Find(subProp => subProp.PropertyName == propertyName);
if (epmProperty != null)
{
Debug.Assert(epmProperty.SubProperties.Count == 0, "Complex type added as leaf node in EPM tree.");
Debug.Assert(epmProperty.EpmInfo != null, "Found a non-leaf property for which EpmInfo is not set.");
Debug.Assert(epmProperty.EpmInfo.Attribute != null, "Attribute should always be initialized for EpmInfo.");
if (epmProperty.EpmInfo.Attribute.KeepInContent == false)
{
return true;
}
}
}
return false;
}
///
/// Obtains the child EPM segment corresponding to the given
/// Current root segment
/// Name of property
/// Child segment or null if there is not segment corresponding to the given
private static EpmSourcePathSegment EpmGetComplexPropertySegment(EpmSourcePathSegment currentSourceRoot, String propertyName)
{
if (currentSourceRoot != null)
{
return currentSourceRoot.SubProperties.Find(subProp => subProp.PropertyName == propertyName);
}
else
{
return null;
}
}
/// Writes the value of a complex object.
/// Element to write.
/// name of the property whose value needs to be written
/// expected type of the property
/// relative uri for the complex type element
/// Content to write to.
/// Epm source sub-tree corresponding to Write the entry element.
/// Expanded result provider for the specified
/// Writes the feed element for the atom payload
///
/// Expanded properties for the result.
/// collection of entries in the feed element
/// expectedType of the elements in the collection
/// title of the feed element
/// absolute uri representing the feed element
/// relative uri representing the feed element
/// whether the enumerator has successfully moved to the first element
/// Feed to write to.
/// If set to true the function should dispose the elements enumerator when it's done
/// with it. Not in the case this method fails though.
private void WriteFeedElements(
IExpandedResult expanded,
IEnumerator elements,
ResourceType expectedType,
string title,
Uri absoluteUri,
string relativeUri,
bool hasMoved,
SyndicationFeed feed,
bool disposeElementsOnSuccess)
{
Debug.Assert(feed != null, "feed != null");
// Write the other elements for the feed
feed.Id = absoluteUri.AbsoluteUri;
feed.Title = new TextSyndicationContent(title);
var uri = new Uri(relativeUri, UriKind.Relative);
var link = new SyndicationLink(uri, XmlConstants.AtomSelfRelationAttributeValue, title, null, 0L);
feed.Links.Add(link);
if (!hasMoved)
{
// ATOM specification: if a feed contains no entries, then the feed should have at least one Author tag
feed.Authors.Add(EmptyPerson);
}
// Instead of looping, create an item that will defer the production of SyndicationItem instances.
// PERF: consider optimizing out empty collections when hasMoved is false.
feed.Items = this.DeferredFeedItems(
expanded,
elements,
expectedType,
hasMoved,
this.SaveSegmentNames(),
(o, e) => this.WriteNextPageLink(o, e, absoluteUri),
disposeElementsOnSuccess);
#if ASTORIA_FF_CALLBACKS
this.Service.InternalOnWriteFeed(feed);
#endif
}
///
/// Writes the next page link to the current xml writer corresponding to the feed
///
/// Object that will contain the keys for skip token
/// The Provides an enumeration of deferred feed items.
/// Expanded properties for the result.
/// Elements to enumerate.
/// Expected type of elements.
/// Whether the enumerator moved to the first element.
/// The segment names active at this point in serialization.
/// Delegate that writes the next page link if necessity arises
/// If set to true the function should dispose the elements enumerator (always).
/// An object that can enumerate syndication items.
private IEnumerable DeferredFeedItems(
IExpandedResult expanded,
IEnumerator elements,
ResourceType expectedType,
bool hasMoved,
object activeSegmentNames,
Action nextPageLinkWriter,
bool disposeElements)
{
try
{
object savedSegmentNames = this.SaveSegmentNames();
this.RestoreSegmentNames(activeSegmentNames);
object lastObject = null;
IExpandedResult lastExpandedSkipToken = null;
while (hasMoved)
{
object o = elements.Current;
IExpandedResult skipToken = this.GetSkipToken(expanded);
if (o != null)
{
SyndicationItem target = new SyndicationItem();
IExpandedResult expandedO = o as IExpandedResult;
if (expandedO != null)
{
expanded = expandedO;
o = GetExpandedElement(expanded);
skipToken = this.GetSkipToken(expanded);
}
this.WriteEntryElement(expanded, o, expectedType, null, null, target);
yield return target;
}
hasMoved = elements.MoveNext();
lastObject = o;
lastExpandedSkipToken = skipToken;
}
// After looping through the objects in the sequence, decide if we need to write the next
// page link and if yes, write it by invoking the delegate
if (this.NeedNextPageLink(elements))
{
nextPageLinkWriter(lastObject, lastExpandedSkipToken);
}
this.RestoreSegmentNames(savedSegmentNames);
}
finally
{
if (disposeElements)
{
WebUtil.Dispose(elements);
}
}
}
///
/// Write entry/feed elements, except the content element and related links
///
/// entity instance being serialized
/// resource type of the entry element
/// title for the current element
/// absolute uri for the current element
/// relative uri for the current element
/// entity tag for the Media Resource
/// Item to write to.
private void WriteOtherElements(object element, ResourceType type, string title, Uri absoluteUri, string relativeUri, string mediaETag, SyndicationItem item)
{
Debug.Assert(item != null, "item != null");
Debug.Assert(absoluteUri != null, "absoluteUri != null");
Debug.Assert(relativeUri != null, "relativeUri != null");
// Write Id element
item.Id = absoluteUri.AbsoluteUri;
// Write Updated element
item.LastUpdatedTime = this.lastUpdatedTime;
// Write "edit-media" link
if (type != null && type.IsMediaLinkEntry)
{
KeyValuePair[] attributeExtensions = new KeyValuePair[0];
if (element != null && !string.IsNullOrEmpty(mediaETag))
{
XmlQualifiedName mediaResourceETagKey = new XmlQualifiedName(XmlConstants.AtomETagAttributeName, XmlConstants.DataWebMetadataNamespace);
attributeExtensions = new KeyValuePair[] { new KeyValuePair(mediaResourceETagKey, mediaETag) };
}
WriteLinkRelations(
title,
XmlConstants.AtomEditMediaRelationAttributeValue,
DataServiceStreamProviderWrapper.GetStreamEditMediaUri(relativeUri),
item,
attributeExtensions);
}
// Write "edit" link
WriteLinkRelations(
title,
XmlConstants.AtomEditRelationAttributeValue,
relativeUri,
item);
}
/// Writes all the properties of the specified resource or complex object.
/// Expanded properties for the result.
/// Resource or complex object with properties to write out.
/// resourceType containing metadata about the current custom object
/// absolute uri for the given resource
/// relative uri for the given resource
/// Item in which to place links / expansions.
/// Content in which to place values.
/// Epm source sub-tree corresponding to navProperties = null;
IEnumerable projectionNodes = null;
if (resourceType.ResourceTypeKind == ResourceTypeKind.EntityType)
{
Debug.Assert(this.CurrentContainer != null, "this.CurrentContainer != null");
if (this.Provider.IsEntityTypeDisallowedForSet(this.CurrentContainer, resourceType))
{
throw new InvalidOperationException(Strings.BaseServiceProvider_NavigationPropertiesOnDerivedEntityTypesNotSupported(resourceType.FullName, this.CurrentContainer.Name));
}
navProperties = new List(resourceType.Properties.Count);
projectionNodes = this.GetProjections();
}
if (projectionNodes == null)
{
var action = resourceType.DictionarySerializerDelegate;
if (action == null && this.Provider.IsV1Provider)
{
Module module = typeof(SyndicationSerializer).Module;
Type customObjectType = customObject.GetType();
Type[] parameterTypes = new Type[] { typeof(object), typeof(DictionaryContent) };
DynamicMethod method = new DynamicMethod("content_populator", typeof(void), parameterTypes, module, false /* skipVisibility */);
ILGenerator generator = method.GetILGenerator();
MethodInfo methodWritePrimitiveValue = typeof(SyndicationSerializer).GetMethod("WritePrimitiveValue", BindingFlags.Static | BindingFlags.NonPublic);
// Downcast the argument.
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Castclass, customObjectType);
foreach (ResourceProperty property in resourceType.Properties.Where(p => p.TypeKind == ResourceTypeKind.Primitive))
{
if (SyndicationSerializer.EpmNeedToSkip(currentSourceRoot, property.Name))
{
continue;
}
// WritePrimitiveValue(propertyValue, property.Name, property.ResourceType, content);
generator.Emit(OpCodes.Dup);
generator.Emit(OpCodes.Call, resourceType.GetPropertyInfo(property).GetGetMethod());
if (property.Type.IsValueType)
{
generator.Emit(OpCodes.Box, property.Type);
}
generator.Emit(OpCodes.Ldstr, property.Name);
generator.Emit(OpCodes.Ldstr, property.ResourceType.FullName);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Call, methodWritePrimitiveValue);
}
generator.Emit(OpCodes.Pop);
generator.Emit(OpCodes.Ret);
action = (Action)method.CreateDelegate(typeof(Action), null);
resourceType.DictionarySerializerDelegate = action;
}
if (action != null)
{
action(customObject, content);
}
else
{
foreach (ResourceProperty property in resourceType.Properties.Where(p => p.TypeKind == ResourceTypeKind.Primitive))
{
object propertyValue = WebUtil.GetPropertyValue(this.Provider, customObject, resourceType, property, null);
if (SyndicationSerializer.EpmNeedToSkip(currentSourceRoot, property.Name))
{
continue;
}
WritePrimitiveValue(propertyValue, property.Name, property.ResourceType.FullName, content);
}
}
foreach (ResourceProperty property in this.Provider.GetResourceProperties(this.CurrentContainer, resourceType))
{
string propertyName = property.Name;
if (property.TypeKind == ResourceTypeKind.EntityType)
{
Debug.Assert(navProperties != null, "navProperties list must be assigned for entity types");
object propertyValue =
(this.ShouldExpandSegment(property.Name)) ? GetExpandedProperty(this.Provider, expanded, customObject, property) : null;
navProperties.Add(new ResourcePropertyInfo(property, propertyValue));
}
else
{
if (property.TypeKind == ResourceTypeKind.ComplexType)
{
object propertyValue = WebUtil.GetPropertyValue(this.Provider, customObject, resourceType, property, null);
bool needPop = this.PushSegmentForProperty(property);
this.WriteComplexObjectValue(
propertyValue,
propertyName,
property.ResourceType,
relativeUri + "/" + property.Name,
content,
SyndicationSerializer.EpmGetComplexPropertySegment(currentSourceRoot, property.Name));
this.PopSegmentName(needPop);
}
}
}
if (resourceType.IsOpenType)
{
IEnumerable> properties = this.Provider.GetOpenPropertyValues(customObject);
foreach (KeyValuePair property in properties)
{
string propertyName = property.Key;
if (String.IsNullOrEmpty(propertyName))
{
throw new DataServiceException(500, Strings.Syndication_InvalidOpenPropertyName(resourceType.FullName));
}
Type valueType;
ResourceType propertyResourceType;
object value = property.Value;
if (value == null || value == DBNull.Value)
{
valueType = typeof(string);
propertyResourceType = ResourceType.PrimitiveStringResourceType;
}
else
{
valueType = value.GetType();
propertyResourceType = WebUtil.GetResourceType(this.Provider, value);
}
// A null ResourceType indicates a ----ed type (eg, IntPtr or DateTimeOffset). So ignore it.
if (propertyResourceType == null)
{
throw new DataServiceException(500, Strings.Syndication_InvalidOpenPropertyType(propertyName));
}
if (propertyResourceType.ResourceTypeKind == ResourceTypeKind.Primitive)
{
if (value != null && SyndicationSerializer.EpmNeedToSkip(currentSourceRoot, propertyName))
{
continue;
}
WritePrimitiveValue(value, propertyName, propertyResourceType.FullName, content);
}
else
{
if (propertyResourceType.ResourceTypeKind == ResourceTypeKind.ComplexType)
{
Debug.Assert(propertyResourceType.InstanceType == valueType, "propertyResourceType.Type == valueType");
this.WriteComplexObjectValue(
value,
propertyName,
propertyResourceType,
relativeUri + "/" + propertyName,
content,
SyndicationSerializer.EpmGetComplexPropertySegment(currentSourceRoot, propertyName));
}
else
{
Debug.Assert(
propertyResourceType.ResourceTypeKind == ResourceTypeKind.EntityType,
"propertyResourceType.ResourceTypeKind == ResourceTypeKind.EntityType -- otherwise should have been processed as primitve or complex type.");
// Open navigation properties are not supported on OpenTypes
throw DataServiceException.CreateBadRequestError(Strings.OpenNavigationPropertiesNotSupportedOnOpenTypes(propertyName));
}
}
}
}
}
else
{
foreach (ProjectionNode projectionNode in projectionNodes)
{
string propertyName = projectionNode.PropertyName;
ResourceProperty property = resourceType.TryResolvePropertyName(propertyName);
// First solve the normal entity type property - turn it into a nav. property record
if (property != null && property.TypeKind == ResourceTypeKind.EntityType)
{
Debug.Assert(navProperties != null, "navProperties list must be assigned for entity types");
// By calling the GetResourceProperties we will use the cached list of properties
// for the given type and set. But we have to search through it.
// We could use the GetContainer (since that's what the GetResourceProperties does) and check
// if it returns null, but result of that is only partially cached so it might be expensive
// to evaluate for each item in the feed.
if (this.Provider.GetResourceProperties(this.CurrentContainer, resourceType).Contains(property))
{
object expandedPropertyValue =
(this.ShouldExpandSegment(propertyName)) ? GetExpandedProperty(this.Provider, expanded, customObject, property) : null;
navProperties.Add(new ResourcePropertyInfo(property, expandedPropertyValue));
}
continue;
}
// Now get the property value
object propertyValue = WebUtil.GetPropertyValue(this.Provider, customObject, resourceType, property, property == null ? propertyName : null);
// Determine the type of the property
ResourceType propertyResourceType;
if (property != null)
{
propertyResourceType = property.ResourceType;
}
else
{
if (propertyValue == null || propertyValue == DBNull.Value)
{
propertyResourceType = ResourceType.PrimitiveStringResourceType;
}
else
{
propertyResourceType = WebUtil.GetResourceType(this.Provider, propertyValue);
// A null ResourceType indicates a ----ed type (eg, IntPtr or DateTimeOffset). So ignore it.
if (propertyResourceType == null)
{
throw new DataServiceException(500, Strings.Syndication_InvalidOpenPropertyType(propertyName));
}
}
}
// And write out the value (depending on the type of the property)
if (propertyResourceType.ResourceTypeKind == ResourceTypeKind.Primitive)
{
if (propertyValue == DBNull.Value)
{
propertyValue = null;
}
if (propertyValue != null && SyndicationSerializer.EpmNeedToSkip(currentSourceRoot, propertyName))
{
continue;
}
WritePrimitiveValue(propertyValue, propertyName, propertyResourceType.FullName, content);
}
else if (propertyResourceType.ResourceTypeKind == ResourceTypeKind.ComplexType)
{
bool needPop = false;
if (property != null)
{
needPop = this.PushSegmentForProperty(property);
}
this.WriteComplexObjectValue(
propertyValue,
propertyName,
propertyResourceType,
relativeUri + "/" + propertyName,
content,
SyndicationSerializer.EpmGetComplexPropertySegment(currentSourceRoot, propertyName));
if (property != null)
{
this.PopSegmentName(needPop);
}
}
else
{
Debug.Assert(
propertyResourceType.ResourceTypeKind == ResourceTypeKind.EntityType,
"propertyResourceType.ResourceTypeKind == ResourceTypeKind.EntityType -- otherwise should have been processed as primitve or complex type.");
// Open navigation properties are not supported on OpenTypes
throw DataServiceException.CreateBadRequestError(Strings.OpenNavigationPropertiesNotSupportedOnOpenTypes(propertyName));
}
}
}
if (resourceType.ResourceTypeKind == ResourceTypeKind.EntityType)
{
for (int i = 0; i < navProperties.Count; i++)
{
ResourcePropertyInfo propertyInfo = navProperties[i];
ResourceProperty navProperty = propertyInfo.Property;
Debug.Assert(
navProperty.IsOfKind(ResourcePropertyKind.ResourceReference) ||
navProperty.IsOfKind(ResourcePropertyKind.ResourceSetReference),
"this must be nav property");
// Generate a link - see http://tools.ietf.org/html/rfc4287#section-4.2.7
string linkType = navProperty.IsOfKind(ResourcePropertyKind.ResourceReference) ? XmlConstants.AtomEntryElementName : XmlConstants.AtomFeedElementName;
linkType = String.Format(CultureInfo.InvariantCulture, "{0};{1}={2}", XmlConstants.MimeApplicationAtom, XmlConstants.AtomTypeAttributeName, linkType);
string segmentIdentifier = navProperty.Name;
if (!this.ShouldExpandSegment(navProperty.Name))
{
WriteDeferredContentElement(
XmlConstants.DataWebRelatedNamespace + navProperty.Name,
navProperty.Name,
relativeUri + "/" + segmentIdentifier,
linkType,
item);
}
else
{
object propertyValue = propertyInfo.Value;
IExpandedResult expandedResultPropertyValue = propertyValue as IExpandedResult;
object expandedPropertyValue =
expandedResultPropertyValue != null ?
GetExpandedElement(expandedResultPropertyValue) :
propertyValue;
string propertyRelativeUri = relativeUri + "/" + segmentIdentifier;
Uri propertyAbsoluteUri = RequestUriProcessor.AppendUnescapedSegment(absoluteUri, segmentIdentifier);
SyndicationLink link = new SyndicationLink();
link.RelationshipType = XmlConstants.DataWebRelatedNamespace + navProperty.Name;
link.Title = navProperty.Name;
link.Uri = new Uri(propertyRelativeUri, UriKind.RelativeOrAbsolute);
link.MediaType = linkType;
item.Links.Add(link);
bool needPop = this.PushSegmentForProperty(navProperty);
// if this.CurrentContainer is null, the target set of the navigation property is hidden.
if (this.CurrentContainer != null)
{
if (navProperty.IsOfKind(ResourcePropertyKind.ResourceSetReference))
{
IEnumerable enumerable;
bool collection = WebUtil.IsElementIEnumerable(expandedPropertyValue, out enumerable);
Debug.Assert(collection, "metadata loading must have ensured that navigation set properties must implement IEnumerable");
SyndicationFeed feed = new SyndicationFeed();
InlineAtomFeed inlineFeedExtension = new InlineAtomFeed(feed, this.factory);
link.ElementExtensions.Add(inlineFeedExtension);
IEnumerator enumerator = enumerable.GetEnumerator();
try
{
bool hasMoved = enumerator.MoveNext();
this.WriteFeedElements(
propertyValue as IExpandedResult,
enumerator,
navProperty.ResourceType,
navProperty.Name,
propertyAbsoluteUri,
propertyRelativeUri,
hasMoved,
feed,
true);
}
catch
{
WebUtil.Dispose(enumerator);
throw;
}
}
else
{
SyndicationItem inlineItem = new SyndicationItem();
this.WriteEntryElement(propertyValue as IExpandedResult, expandedPropertyValue, navProperty.ResourceType, propertyAbsoluteUri, propertyRelativeUri, inlineItem);
InlineAtomItem inlineItemExtension = new InlineAtomItem(inlineItem, this.factory);
link.ElementExtensions.Add(inlineItemExtension);
}
}
this.PopSegmentName(needPop);
}
}
}
}
finally
{
// The matching call to RecurseLeave is in a try/finally block not because it's necessary in the
// presence of an exception (progress will halt anyway), but because it's easier to maintain in the
// code in the presence of multiple exit points (returns).
this.RecurseLeave();
}
}
#region Inner types.
/// Stores the resource property, its value and a flag which indicates whether this is a open property or not.
private struct ResourcePropertyInfo
{
/// refers to the property that this instance represents.
private ResourceProperty resourceProperty;
/// Value of the property.
private object value;
///
/// Creates a new instance of ResourcePropertyInfo.
///
/// resource property instance.
/// value for the resource property.
public ResourcePropertyInfo(ResourceProperty resourceProperty, object value)
{
Debug.Assert(resourceProperty != null, "resourceProperty != null");
this.resourceProperty = resourceProperty;
this.value = value;
}
/// Returns the resource property.
internal ResourceProperty Property
{
get { return this.resourceProperty; }
}
/// Returns the value of the resource property.
internal object Value
{
get { return this.value; }
}
}
/// Wrapper for an inline item.
[XmlRoot(ElementName = XmlConstants.AtomInlineElementName, Namespace = XmlConstants.DataWebMetadataNamespace)]
internal class InlineAtomItem : IXmlSerializable
{
/// Factory for item formatter.
private readonly SyndicationFormatterFactory factory;
/// Item being serialized.
private SyndicationItem item;
/// Empty constructor.
internal InlineAtomItem()
{
}
/// Initializing constructor.
/// Item being serialized.
/// Factory for item formatter.
internal InlineAtomItem(SyndicationItem item, SyndicationFormatterFactory factory)
{
this.item = item;
this.factory = factory;
}
#region IXmlSerializable Members
/// Reserved method.
/// null
public System.Xml.Schema.XmlSchema GetSchema()
{
return null;
}
/// Generates an object from its XML representation.
/// XmlReader with representation.
public void ReadXml(XmlReader reader)
{
throw Error.NotImplemented();
}
/// Converts an object into its XML representation.
/// Writer to write representation into.
public void WriteXml(XmlWriter writer)
{
SyndicationItemFormatter formatter = this.factory.CreateSyndicationItemFormatter(this.item);
if (formatter != null)
{
formatter.WriteTo(writer);
}
}
#endregion
}
/// Wrapper for an inline feed.
[XmlRoot(ElementName = XmlConstants.AtomInlineElementName, Namespace = XmlConstants.DataWebMetadataNamespace)]
internal class InlineAtomFeed : IXmlSerializable
{
/// Factory for item formatter.
private readonly SyndicationFormatterFactory factory;
/// Feed being serialized.
private SyndicationFeed feed;
/// Empty constructor.
internal InlineAtomFeed()
{
}
/// Initializing constructor.
/// Feed being serialized.
/// Factory for item formatter.
internal InlineAtomFeed(SyndicationFeed feed, SyndicationFormatterFactory factory)
{
this.feed = feed;
this.factory = factory;
}
#region IXmlSerializable Members
/// Reserved method.
/// null
public System.Xml.Schema.XmlSchema GetSchema()
{
return null;
}
/// Generates an object from its XML representation.
/// XmlReader with representation.
public void ReadXml(XmlReader reader)
{
throw Error.NotImplemented();
}
/// Converts an object into its XML representation.
/// Writer to write representation into.
public void WriteXml(XmlWriter writer)
{
this.factory.CreateSyndicationFeedFormatter(this.feed).WriteTo(writer);
}
#endregion
}
#endregion Inner types.
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ToolboxItem.cs
- MenuBase.cs
- PackagingUtilities.cs
- Matrix3DConverter.cs
- mediapermission.cs
- SchemaMapping.cs
- Accessible.cs
- ColumnClickEvent.cs
- URLIdentityPermission.cs
- Win32.cs
- WebControl.cs
- SynchronizedDisposablePool.cs
- FrameworkName.cs
- ProcessHostMapPath.cs
- PathSegment.cs
- WebPartVerbsEventArgs.cs
- HttpConfigurationContext.cs
- PersistenceProviderBehavior.cs
- StandardBindingCollectionElement.cs
- TriState.cs
- PostBackTrigger.cs
- SqlDeflator.cs
- TreeNodeBinding.cs
- QilList.cs
- DBCommandBuilder.cs
- ProxyFragment.cs
- SoapEnvelopeProcessingElement.cs
- QueryExecutionOption.cs
- ProgressPage.cs
- dbdatarecord.cs
- StringDictionaryCodeDomSerializer.cs
- HostingEnvironment.cs
- XmlDocument.cs
- LineSegment.cs
- ComboBoxItem.cs
- ToolboxItemCollection.cs
- dataSvcMapFileLoader.cs
- ValuePatternIdentifiers.cs
- WebRequestModulesSection.cs
- TrustLevelCollection.cs
- RectAnimation.cs
- PackageFilter.cs
- DataGridViewAdvancedBorderStyle.cs
- DesignerLinkAdapter.cs
- ServiceRoute.cs
- JournalEntry.cs
- UserPreference.cs
- Substitution.cs
- HttpException.cs
- PropertyValidationContext.cs
- Volatile.cs
- LoadedOrUnloadedOperation.cs
- NumericUpDownAcceleration.cs
- UnmanagedMemoryStream.cs
- DictionaryCustomTypeDescriptor.cs
- AnnotationAdorner.cs
- DynamicRenderer.cs
- IsolatedStoragePermission.cs
- OdbcReferenceCollection.cs
- ConnectionsZoneAutoFormat.cs
- DateTimeUtil.cs
- ConfigPathUtility.cs
- ConfigurationErrorsException.cs
- SoapCodeExporter.cs
- DbMetaDataFactory.cs
- _ListenerAsyncResult.cs
- RegexNode.cs
- MLangCodePageEncoding.cs
- DataGridViewLayoutData.cs
- _IPv4Address.cs
- DesignerForm.cs
- PageThemeBuildProvider.cs
- DbSourceCommand.cs
- PersonalizationEntry.cs
- DataFormats.cs
- CursorEditor.cs
- ResourceSet.cs
- SoapAttributeAttribute.cs
- EntityContainer.cs
- UdpTransportBindingElement.cs
- Span.cs
- DBSqlParser.cs
- SafeFileMappingHandle.cs
- TextEditorCharacters.cs
- ActivityDesignerAccessibleObject.cs
- InputMethodStateTypeInfo.cs
- DoubleCollectionValueSerializer.cs
- CqlLexerHelpers.cs
- StringComparer.cs
- XmlUtil.cs
- BaseDataListPage.cs
- StructuredType.cs
- RightsManagementResourceHelper.cs
- EntityDesignerBuildProvider.cs
- HelpEvent.cs
- WebPartConnectionsConnectVerb.cs
- SqlReorderer.cs
- ComplexPropertyEntry.cs
- ConnectionConsumerAttribute.cs
- DataControlFieldCollection.cs