/// <inheritdoc />
public override void WriteObjectInline(object graph, IEdmTypeReference expectedType, ODataWriter writer,
ODataSerializerContext writeContext)
{
if (writer == null)
{
throw Error.ArgumentNull("writer");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
if (expectedType == null)
{
throw Error.ArgumentNull("expectedType");
}
if (graph == null)
{
throw new SerializationException(Error.Format(SRResources.CannotSerializerNull, Feed));
}
IEnumerable enumerable = graph as IEnumerable; // Data to serialize
if (enumerable == null)
{
throw new SerializationException(
Error.Format(SRResources.CannotWriteType, GetType().Name, graph.GetType().FullName));
}
WriteFeed(enumerable, expectedType, writer, writeContext);
}
public override void WriteObjectInline(object graph, IEdmTypeReference expectedType, ODataWriter writer, ODataSerializerContext writeContext)
{
if (graph != null)
{
base.WriteObjectInline(graph, expectedType, writer, writeContext);
}
}
private void StartRead(ODataReader reader, ODataWriter writer)
{
ExceptionUtilities.Assert(reader.State == ODataReaderState.Start, "Reader is expected to be in state Start at StartRead.");
while (reader.Read())
{
switch(reader.State)
{
case ODataReaderState.EntryStart:
writer.WriteStart((ODataEntry)reader.Item);
break;
case ODataReaderState.FeedStart:
writer.WriteStart((ODataFeed)reader.Item);
break;
case ODataReaderState.NavigationLinkStart:
writer.WriteStart((ODataNavigationLink)reader.Item);
break;
case ODataReaderState.EntryEnd:
case ODataReaderState.FeedEnd:
case ODataReaderState.NavigationLinkEnd:
writer.WriteEnd();
break;
default:
throw new NotSupportedException();
};
}
}
/// <summary>
/// Writes an OData entry.
/// </summary>
/// <param name="writer">The ODataWriter that will write the entry.</param>
/// <param name="element">The item from the data store to write.</param>
/// <param name="navigationSource">The navigation source in the model that the entry belongs to.</param>
/// <param name="model">The data store model.</param>
/// <param name="targetVersion">The OData version this segment is targeting.</param>
/// <param name="selectExpandClause">The SelectExpandClause.</param>
public static void WriteEntry(ODataWriter writer, object element, IEdmNavigationSource entitySource, ODataVersion targetVersion, SelectExpandClause selectExpandClause, Dictionary<string, string> incomingHeaders = null)
{
var entry = ODataObjectModelConverter.ConvertToODataEntry(element, entitySource, targetVersion);
entry.ETag = Utility.GetETagValue(element);
if (selectExpandClause != null && selectExpandClause.SelectedItems.OfType<PathSelectItem>().Any())
{
ExpandSelectItemHandler selectItemHandler = new ExpandSelectItemHandler(entry);
foreach (var item in selectExpandClause.SelectedItems.OfType<PathSelectItem>())
{
item.HandleWith(selectItemHandler);
}
entry = selectItemHandler.ProjectedEntry;
}
CustomizeEntry(incomingHeaders, entry);
writer.WriteStart(entry);
// gets all of the expandedItems, including ExpandedRefernceSelectItem and ExpandedNavigationItem
var expandedItems = selectExpandClause == null ? null : selectExpandClause.SelectedItems.OfType<ExpandedReferenceSelectItem>();
WriteNavigationLinks(writer, element, entry.ReadLink, entitySource, targetVersion, expandedItems);
writer.WriteEnd();
}
/// <summary>
/// Prevents a default instance of the <see cref="ODataWriterWrapper"/> class from being created.
/// </summary>
/// <param name="odataWriter">The odata writer.</param>
/// <param name="requestPipeline">The request pipeline configuration.</param>
private ODataWriterWrapper(ODataWriter odataWriter, DataServiceClientRequestPipelineConfiguration requestPipeline)
{
Debug.Assert(odataWriter != null, "odataWriter != null");
Debug.Assert(requestPipeline != null, "DataServiceClientRequestPipelineConfiguration != null");
this.odataWriter = odataWriter;
this.requestPipeline = requestPipeline;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="writer">The writer to wrap.</param>
/// <param name="testConfiguration">The test configuration to use.</param>
public ODataWriterTestWrapper(ODataWriter writer, WriterTestConfiguration testConfiguration)
{
ExceptionUtilities.CheckArgumentNotNull(writer, "writer");
ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");
this.writer = writer;
this.testConfiguration = testConfiguration;
}
/// <summary>
/// Writes an OData entry.
/// </summary>
/// <param name="writer">The ODataWriter that will write the entry.</param>
/// <param name="element">The item from the data store to write.</param>
/// <param name="entitySet">The entity set in the model that the entry belongs to.</param>
/// <param name="model">The data store model.</param>
/// <param name="targetVersion">The OData version this segment is targeting.</param>
/// <param name="expandedNavigationProperties">A list of navigation property names to expand.</param>
public static void WriteEntry(ODataWriter writer, object element, IEdmEntitySet entitySet, IEdmModel model, ODataVersion targetVersion, IEnumerable<string> expandedNavigationProperties)
{
var entry = ODataObjectModelConverter.ConvertToODataEntry(element, entitySet, targetVersion);
writer.WriteStart(entry);
// Here, we write out the links for the navigation properties off of the entity type
WriteNavigationLinks(writer, element, entry.ReadLink, entitySet.EntityType(), model, targetVersion, expandedNavigationProperties);
writer.WriteEnd();
}
/// <summary>
/// Writes an OData feed.
/// </summary>
/// <param name="writer">The ODataWriter that will write the feed.</param>
/// <param name="entries">The items from the data store to write to the feed.</param>
/// <param name="entitySet">The entity set in the model that the feed belongs to.</param>
/// <param name="model">The data store model.</param>
/// <param name="targetVersion">The OData version this segment is targeting.</param>
/// <param name="expandedNavigationProperties">A list of navigation property names to expand.</param>
public static void WriteFeed(ODataWriter writer, IEnumerable entries, IEdmEntitySet entitySet, IEdmModel model, ODataVersion targetVersion, IEnumerable<string> expandedNavigationProperties)
{
var feed = new ODataFeed {Id = new Uri(ServiceConstants.ServiceBaseUri, entitySet.Name)};
writer.WriteStart(feed);
foreach (var element in entries)
{
WriteEntry(writer, element, entitySet, model, targetVersion, expandedNavigationProperties);
}
writer.WriteEnd();
}
/// <summary>
/// Write the <paramref name="element"/> payload element to the <paramref name="writer"/> OData writer.
/// </summary>
/// <param name="writer">The OData writer to write to.</param>
/// <param name="element">The element to write.</param>
public void WritePayload(ODataWriter writer, ODataPayloadElement element)
{
this.writer = writer;
try
{
base.Recurse(element);
this.writer.Flush();
}
finally
{
this.writer = null;
}
}
private static void WriteEntry(ODataWriter writer, object entity, IEnumerable<string> projectedProperties)
{
var entry = new ODataEntry()
{
Id = new Uri("http://temp.org/" + Guid.NewGuid()),
SerializationInfo = MySerializationInfo
};
if (projectedProperties != null)
{
entry.SetAnnotation<ProjectedPropertiesAnnotation>(new ProjectedPropertiesAnnotation(projectedProperties));
}
entry.Properties = entity.GetType().GetProperties().Select(p => new ODataProperty() { Name = p.Name, Value = p.GetValue(entity, null) });
writer.WriteStart(entry);
writer.WriteEnd();
}
private void WriteEntry(object graph, ODataWriter writer, ODataSerializerContext writeContext)
{
Contract.Assert(writeContext != null);
IEdmEntityTypeReference entityType = GetEntityType(graph, writeContext);
EntityInstanceContext entityInstanceContext = new EntityInstanceContext(writeContext, entityType, graph);
SelectExpandNode selectExpandNode = CreateSelectExpandNode(entityInstanceContext);
if (selectExpandNode != null)
{
ODataEntry entry = CreateEntry(selectExpandNode, entityInstanceContext);
if (entry != null)
{
writer.WriteStart(entry);
WriteNavigationLinks(selectExpandNode.SelectedNavigationProperties, entityInstanceContext, writer);
WriteExpandedNavigationProperties(selectExpandNode.ExpandedNavigationProperties, entityInstanceContext, writer);
writer.WriteEnd();
}
}
}
private static void WriteNavigationLinks(ODataWriter writer, object element, Uri parentEntryUri, IEdmEntityType parentEntityType, IEdmModel model, ODataVersion targetVersion, IEnumerable<string> expandedNavigationProperties)
{
foreach (var navigationProperty in parentEntityType.NavigationProperties())
{
IEdmTypeReference propertyTypeReference = navigationProperty.Type;
bool isCollection = navigationProperty.Type.IsCollection();
var navigationLink = new ODataNavigationLink
{
Url = new Uri(parentEntryUri, navigationProperty.Name),
IsCollection = isCollection,
Name = navigationProperty.Name,
};
writer.WriteStart(navigationLink);
if (expandedNavigationProperties.Contains(navigationProperty.Name))
{
var propertyValue = DataContext.GetPropertyValue(element, navigationProperty.Name);
if (propertyValue != null)
{
var propertyEntityType = propertyTypeReference.Definition as IEdmEntityType;
IEdmEntitySet targetEntitySet = model.EntityContainer.EntitySets().Single(s => s.EntityType() == propertyEntityType);
if (isCollection)
{
WriteFeed(writer, propertyValue as IEnumerable, targetEntitySet, model, targetVersion, Enumerable.Empty<string>());
}
else
{
WriteEntry(writer, propertyValue, targetEntitySet, model, targetVersion, Enumerable.Empty<string>());
}
}
}
writer.WriteEnd();
}
}
/// <inheritdoc />
public override void WriteObjectInline(object graph, IEdmTypeReference expectedType, ODataWriter writer,
ODataSerializerContext writeContext)
{
if (writer == null)
{
throw Error.ArgumentNull("writer");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
if (graph == null)
{
throw new SerializationException(Error.Format(Properties.SRResources.CannotSerializerNull, Entry));
}
else
{
WriteEntry(graph, writer, writeContext);
}
}
private void WriteNavigationLinks(
IEnumerable<IEdmNavigationProperty> navigationProperties, EntityInstanceContext entityInstanceContext, ODataWriter writer)
{
Contract.Assert(entityInstanceContext != null);
IEnumerable<ODataNavigationLink> navigationLinks = CreateNavigationLinks(navigationProperties, entityInstanceContext);
foreach (ODataNavigationLink navigationLink in navigationLinks)
{
writer.WriteStart(navigationLink);
writer.WriteEnd();
}
}
private async Task WriteLinkAsync(ODataWriter entryWriter, Microsoft.OData.Core.ODataEntry entry, string linkName, IEnumerable<ReferenceLink> links)
{
var navigationProperty = (_model.FindDeclaredType(entry.TypeName) as IEdmEntityType).NavigationProperties()
.BestMatch(x => x.Name, linkName, _session.Pluralizer);
bool isCollection = navigationProperty.Type.Definition.TypeKind == EdmTypeKind.Collection;
var linkType = GetNavigationPropertyEntityType(navigationProperty);
var linkTypeWithKey = linkType;
while (linkTypeWithKey.DeclaredKey == null && linkTypeWithKey.BaseEntityType() != null)
{
linkTypeWithKey = linkTypeWithKey.BaseEntityType();
}
await entryWriter.WriteStartAsync(new ODataNavigationLink()
{
Name = linkName,
IsCollection = isCollection,
Url = new Uri(ODataNamespace.Related + linkType, UriKind.Absolute),
});
foreach (var referenceLink in links)
{
var linkKey = linkTypeWithKey.DeclaredKey;
var linkEntry = referenceLink.LinkData.ToDictionary();
var contentId = GetContentId(referenceLink);
string linkUri;
if (contentId != null)
{
linkUri = "$" + contentId;
}
else
{
bool isSingleton;
var formattedKey = _session.Adapter.GetCommandFormatter().ConvertKeyValuesToUriLiteral(
linkKey.ToDictionary(x => x.Name, x => linkEntry[x.Name]), true);
var linkedCollectionName = _session.Metadata.GetLinkedCollectionName(
referenceLink.LinkData.GetType().Name, linkTypeWithKey.Name, out isSingleton);
linkUri = linkedCollectionName + (isSingleton ? string.Empty : formattedKey);
}
var link = new ODataEntityReferenceLink
{
Url = Utils.CreateAbsoluteUri(_session.Settings.BaseUri.AbsoluteUri, linkUri)
};
await entryWriter.WriteEntityReferenceLinkAsync(link);
}
await entryWriter.WriteEndAsync();
}
private void WriteExpandedNavigationProperty(
KeyValuePair<IEdmNavigationProperty, SelectExpandClause> navigationPropertyToExpand,
EntityInstanceContext entityInstanceContext,
ODataWriter writer)
{
Contract.Assert(entityInstanceContext != null);
Contract.Assert(writer != null);
IEdmNavigationProperty navigationProperty = navigationPropertyToExpand.Key;
SelectExpandClause selectExpandClause = navigationPropertyToExpand.Value;
object propertyValue = entityInstanceContext.GetPropertyValue(navigationProperty.Name);
if (propertyValue != null)
{
// create the serializer context for the expanded item.
ODataSerializerContext nestedWriteContext = new ODataSerializerContext(entityInstanceContext, selectExpandClause, navigationProperty);
// write object.
ODataEdmTypeSerializer serializer = SerializerProvider.GetEdmTypeSerializer(navigationProperty.Type);
if (serializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeSerialized, navigationProperty.Type.ToTraceString(), typeof(ODataMediaTypeFormatter).Name));
}
serializer.WriteObjectInline(propertyValue, navigationProperty.Type, writer, nestedWriteContext);
}
}
/// <summary>
/// Writes the given object specified by the parameter graph as a part of an existing OData message using the given
/// messageWriter and the writeContext.
/// </summary>
/// <param name="graph">The object to be written.</param>
/// <param name="expectedType">The expected EDM type of the object represented by <paramref name="graph"/>.</param>
/// <param name="writer">The <see cref="ODataWriter" /> to be used for writing.</param>
/// <param name="writeContext">The <see cref="ODataSerializerContext"/>.</param>
public virtual void WriteObjectInline(object graph, IEdmTypeReference expectedType, ODataWriter writer,
ODataSerializerContext writeContext)
{
throw Error.NotSupported(SRResources.WriteObjectInlineNotSupported, GetType().Name);
}
/// <summary>
/// Writes a ReferenceLinks
/// </summary>
/// <param name="writer">The ODataWriter that will write the ReferenceLinks.</param>
public static void WriteReferenceLinks(ODataWriter writer, IEnumerable element, IEdmNavigationSource entitySource, ODataVersion targetVersion, ODataNavigationLink navigationLink)
{
IEnumerable<ODataEntry> links = ODataObjectModelConverter.ConvertToODataEntityReferenceLinks (element, entitySource, targetVersion);
var feed = new ODataFeed { };
writer.WriteStart(feed);
foreach (var entry in links)
{
writer.WriteStart(entry);
writer.WriteEnd();
}
writer.WriteEnd();
}
private void WriteFeed(IEnumerable enumerable, IEdmTypeReference feedType, ODataWriter writer,
ODataSerializerContext writeContext)
{
Contract.Assert(writer != null);
Contract.Assert(writeContext != null);
Contract.Assert(enumerable != null);
Contract.Assert(feedType != null);
IEdmEntityTypeReference elementType = GetEntityType(feedType);
ODataFeed feed = CreateODataFeed(enumerable, feedType.AsCollection(), writeContext);
if (feed == null)
{
throw new SerializationException(Error.Format(SRResources.CannotSerializerNull, Feed));
}
ODataEdmTypeSerializer entrySerializer = SerializerProvider.GetEdmTypeSerializer(elementType);
if (entrySerializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeSerialized, elementType.FullName(), typeof(ODataMediaTypeFormatter).Name));
}
// save this for later to support JSON odata.streaming.
Uri nextPageLink = feed.NextPageLink;
feed.NextPageLink = null;
writer.WriteStart(feed);
foreach (object entry in enumerable)
{
if (entry == null)
{
throw new SerializationException(SRResources.NullElementInCollection);
}
entrySerializer.WriteObjectInline(entry, elementType, writer, writeContext);
}
// Subtle and suprising behavior: If the NextPageLink property is set before calling WriteStart(feed),
// the next page link will be written early in a manner not compatible with odata.streaming=true. Instead, if
// the next page link is not set when calling WriteStart(feed) but is instead set later on that feed
// object before calling WriteEnd(), the next page link will be written at the end, as required for
// odata.streaming=true support.
if (nextPageLink != null)
{
feed.NextPageLink = nextPageLink;
}
writer.WriteEnd();
}
/// <summary>
/// Writes an OData feed.
/// </summary>
/// <param name="writer">The ODataWriter that will write the feed.</param>
/// <param name="entries">The items from the data store to write to the feed.</param>
/// <param name="entitySet">The entity set in the model that the feed belongs to.</param>
/// <param name="targetVersion">The OData version this segment is targeting.</param>
/// <param name="selectExpandClause">The SelectExpandClause.</param>
public static void WriteFeed(ODataWriter writer, IEnumerable entries, IEdmEntitySetBase entitySet, ODataVersion targetVersion, SelectExpandClause selectExpandClause, long? count, Uri deltaLink, Uri nextPageLink, Dictionary<string, string> incomingHeaders = null)
{
var feed = new ODataFeed
{
Id = new Uri(ServiceConstants.ServiceBaseUri, entitySet.Name),
DeltaLink = deltaLink,
NextPageLink = nextPageLink
};
if (count.HasValue)
{
feed.Count = count;
}
writer.WriteStart(feed);
foreach (var element in entries)
{
WriteEntry(writer, element, entitySet, targetVersion, selectExpandClause, incomingHeaders);
}
writer.WriteEnd();
}
private void WriteFeed(ODataWriter writer, Lazy<ODataReader> lazyReader, ODataFeed feed)
{
this.WriteStart(writer, feed);
var annotation = feed.GetAnnotation<ODataFeedEntriesObjectModelAnnotation>();
if (annotation != null)
{
int count = annotation.Count;
for (int i = 0; i < count; ++i)
{
this.WriteEntry(writer, lazyReader, annotation[i]);
}
}
this.WriteEnd(writer, ODataReaderState.FeedEnd);
this.Read(lazyReader);
}
private void WriteEntry(ODataWriter writer, ODataItem[] itemsToWrite, ref int currentIdx)
{
if (currentIdx < itemsToWrite.Length)
{
ODataEntry entry = (ODataEntry)itemsToWrite[currentIdx++];
writer.WriteStart(entry);
while (currentIdx < itemsToWrite.Length && itemsToWrite[currentIdx] is ODataNavigationLink)
{
this.WriteLink(writer, itemsToWrite, ref currentIdx);
}
writer.WriteEnd();
}
}
private void WriteFeed(ODataWriter writer, ODataItem[] itemsToWrite, ref int currentIdx)
{
if (currentIdx < itemsToWrite.Length)
{
ODataFeed feed = (ODataFeed)itemsToWrite[currentIdx++];
writer.WriteStart(feed);
while (currentIdx < itemsToWrite.Length && itemsToWrite[currentIdx] is ODataEntry)
{
this.WriteEntry(writer, itemsToWrite, ref currentIdx);
}
writer.WriteEnd();
}
}
private static void WriteNavigationLinks(ODataWriter writer, object element, Uri parentEntryUri, IEdmNavigationSource edmParent, ODataVersion targetVersion, IEnumerable<SelectItem> expandedItems)
{
foreach (var navigationProperty in ((IEdmEntityType)EdmClrTypeUtils.GetEdmType(DataSourceManager.GetCurrentDataSource().Model, element)).NavigationProperties())
{
// give proprity to ExpandedReferenceSelectItem
var expandedItem = GetExpandedReferenceItem(expandedItems, navigationProperty.Name);
if (expandedItem == null)
{
expandedItem = GetExpandedNavigationItem(expandedItems, navigationProperty.Name);
}
// For Atom, we always manually write out the links for the navigation properties off of the entity type
// Or if the navigation is expanded, we manually write out the links for the navigation properties along with the expanded entries
if (writer.GetType().Name != "ODataJsonLightWriter" || expandedItem != null)
{
bool isCollection = navigationProperty.Type.IsCollection();
var navigationLink = new ODataNavigationLink
{
IsCollection = isCollection,
Name = navigationProperty.Name,
};
if (writer.GetType().Name == "ODataAtomWriter")
{
//If the passed in parentEntryUri is null then exception will be thrown, to avoid this, create a relative 'potato' Uri.
navigationLink.Url = (parentEntryUri == null) ? new Uri("potato", UriKind.Relative) : new Uri(new Uri(parentEntryUri.AbsoluteUri + "/"), navigationProperty.Name);
}
writer.WriteStart(navigationLink);
if (expandedItem != null)
{
ExpandSelectItemHandler expandItemHandler = new ExpandSelectItemHandler(element);
expandedItem.HandleWith(expandItemHandler);
var propertyValue = expandItemHandler.ExpandedChildElement;
if (propertyValue != null)
{
IEdmNavigationSource targetSource = edmParent.FindNavigationTarget(navigationProperty);
if (isCollection)
{
long? count = null;
var collectionValue = propertyValue as IEnumerable;
if (collectionValue != null && expandedItem.CountOption == true)
{
count = collectionValue.Cast<object>().LongCount();
}
if (expandedItem.GetType() == typeof(ExpandedReferenceSelectItem))
{
WriteReferenceLinks(writer, collectionValue, targetSource as IEdmEntitySetBase, targetVersion, navigationLink);
}
else
{
WriteFeed(writer, collectionValue, targetSource as IEdmEntitySetBase, targetVersion, ((ExpandedNavigationSelectItem)expandedItem).SelectAndExpand, count, null, null);
}
}
else
{
if (expandedItem.GetType() == typeof(ExpandedReferenceSelectItem))
{
WriteReferenceLink(writer, propertyValue, targetSource, targetVersion, navigationLink);
}
else
{
WriteEntry(writer, propertyValue, targetSource, targetVersion, ((ExpandedNavigationSelectItem)expandedItem).SelectAndExpand);
}
}
}
}
writer.WriteEnd();
}
}
}
private void WriteExpandedNavigationProperties(
IDictionary<IEdmNavigationProperty, SelectExpandClause> navigationPropertiesToExpand,
EntityInstanceContext entityInstanceContext,
ODataWriter writer)
{
Contract.Assert(navigationPropertiesToExpand != null);
Contract.Assert(entityInstanceContext != null);
Contract.Assert(writer != null);
foreach (KeyValuePair<IEdmNavigationProperty, SelectExpandClause> navigationPropertyToExpand in navigationPropertiesToExpand)
{
IEdmNavigationProperty navigationProperty = navigationPropertyToExpand.Key;
ODataNavigationLink navigationLink = CreateNavigationLink(navigationProperty, entityInstanceContext);
if (navigationLink != null)
{
writer.WriteStart(navigationLink);
WriteExpandedNavigationProperty(navigationPropertyToExpand, entityInstanceContext, writer);
writer.WriteEnd();
}
}
}
private void WriteDynamicTypeEntry(object graph, ODataWriter writer, IEdmTypeReference expectedType,
ODataSerializerContext writeContext)
{
var navigationProperties = new Dictionary<IEdmTypeReference, object>();
var entityType = expectedType.Definition as EdmEntityType;
var entry = new ODataEntry()
{
TypeName = expectedType.FullName(),
Properties = CreateODataPropertiesFromDynamicType(entityType, graph, navigationProperties)
};
entry.IsTransient = true;
writer.WriteStart(entry);
foreach (IEdmTypeReference type in navigationProperties.Keys)
{
var entityContext = new EntityInstanceContext(writeContext, expectedType.AsEntity(), graph);
var navigationProperty = entityType.NavigationProperties().FirstOrDefault(p => p.Type.Equals(type));
var navigationLink = CreateNavigationLink(navigationProperty, entityContext);
if (navigationLink != null)
{
writer.WriteStart(navigationLink);
WriteDynamicTypeEntry(navigationProperties[type], writer, type, writeContext);
writer.WriteEnd();
}
}
writer.WriteEnd();
}
private void WriteExpandedNavigationProperty(
KeyValuePair<IEdmNavigationProperty, SelectExpandClause> navigationPropertyToExpand,
EntityInstanceContext entityInstanceContext,
ODataWriter writer)
{
Contract.Assert(entityInstanceContext != null);
Contract.Assert(writer != null);
IEdmNavigationProperty navigationProperty = navigationPropertyToExpand.Key;
SelectExpandClause selectExpandClause = navigationPropertyToExpand.Value;
object propertyValue = entityInstanceContext.GetPropertyValue(navigationProperty.Name);
if (propertyValue == null)
{
if (navigationProperty.Type.IsCollection())
{
// A navigation property whose Type attribute specifies a collection, the collection always exists,
// it may just be empty.
// If a collection of entities can be related, it is represented as a JSON array. An empty
// collection of entities (one that contains no entities) is represented as an empty JSON array.
writer.WriteStart(new ODataFeed());
}
else
{
// If at most one entity can be related, the value is null if no entity is currently related.
writer.WriteStart(entry: null);
}
writer.WriteEnd();
}
else
{
// create the serializer context for the expanded item.
ODataSerializerContext nestedWriteContext = new ODataSerializerContext(entityInstanceContext, selectExpandClause, navigationProperty);
// write object.
ODataEdmTypeSerializer serializer = SerializerProvider.GetEdmTypeSerializer(navigationProperty.Type);
if (serializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeSerialized, navigationProperty.Type.ToTraceString(), typeof(ODataMediaTypeFormatter).Name));
}
serializer.WriteObjectInline(propertyValue, navigationProperty.Type, writer, nestedWriteContext);
}
}
private void WriteEntry(object graph, ODataWriter writer, ODataSerializerContext writeContext,
IEdmTypeReference expectedType)
{
Contract.Assert(writeContext != null);
if (EdmLibHelpers.IsDynamicTypeWrapper(graph.GetType()))
{
WriteDynamicTypeEntry(graph, writer, expectedType, writeContext);
return;
}
IEdmEntityTypeReference entityType = GetEntityType(graph, writeContext);
EntityInstanceContext entityInstanceContext = new EntityInstanceContext(writeContext, entityType, graph);
SelectExpandNode selectExpandNode = CreateSelectExpandNode(entityInstanceContext);
if (selectExpandNode != null)
{
ODataEntry entry = CreateEntry(selectExpandNode, entityInstanceContext);
if (entry != null)
{
writer.WriteStart(entry);
WriteNavigationLinks(selectExpandNode.SelectedNavigationProperties, entityInstanceContext, writer);
WriteExpandedNavigationProperties(selectExpandNode.ExpandedNavigationProperties,
entityInstanceContext, writer);
writer.WriteEnd();
}
}
}
private void WriteLink(ODataWriter writer, ODataItem[] itemsToWrite, ref int currentIdx)
{
if (currentIdx < itemsToWrite.Length)
{
ODataNavigationLink link = (ODataNavigationLink)itemsToWrite[currentIdx++];
writer.WriteStart(link);
if (currentIdx < itemsToWrite.Length)
{
if (itemsToWrite[currentIdx] is ODataEntry)
{
this.WriteEntry(writer, itemsToWrite, ref currentIdx);
}
else if (itemsToWrite[currentIdx] is ODataFeed)
{
this.WriteFeed(writer, itemsToWrite, ref currentIdx);
}
}
writer.WriteEnd();
}
}
/// <summary>
/// Writes a ReferenceLink
/// </summary>
/// <param name="writer">The ODataWriter that will write the ReferenceLink.</param>
public static void WriteReferenceLink(ODataWriter writer, object element, IEdmNavigationSource entitySource, ODataVersion targetVersion, ODataNavigationLink navigationLink)
{
ODataEntry entry = ODataObjectModelConverter.ConvertToODataEntityReferenceLink (element, entitySource, targetVersion);
writer.WriteStart(entry);
writer.WriteEnd();
}
