internal static MaterializerEntry ParseSingleEntityPayload(IODataResponseMessage message, ResponseInfo responseInfo, Type expectedType)
{
ODataPayloadKind payloadKind = ODataPayloadKind.Entry;
using (ODataMessageReader reader = ODataMaterializer.CreateODataMessageReader(message, responseInfo, false, ref payloadKind))
{
IEdmType orCreateEdmType = ClientEdmModel.GetModel(responseInfo.MaxProtocolVersion).GetOrCreateEdmType(expectedType);
ODataReader reader2 = ODataMaterializer.CreateODataReader(reader, payloadKind, orCreateEdmType, responseInfo.MaxProtocolVersion);
ODataFeedOrEntryReader reader3 = new ODataFeedOrEntryReader(reader2, responseInfo);
ODataEntry currentEntry = null;
bool flag = false;
while (reader3.Read())
{
flag |= reader3.CurrentFeed != null;
if (reader3.CurrentEntry != null)
{
if (currentEntry != null)
{
throw new InvalidOperationException(System.Data.Services.Client.Strings.AtomParser_SingleEntry_MultipleFound);
}
currentEntry = reader3.CurrentEntry;
}
}
if (currentEntry == null)
{
if (flag)
{
throw new InvalidOperationException(System.Data.Services.Client.Strings.AtomParser_SingleEntry_NoneFound);
}
throw new InvalidOperationException(System.Data.Services.Client.Strings.AtomParser_SingleEntry_ExpectedFeedOrEntry);
}
return(MaterializerEntry.GetEntry(currentEntry));
}
}
internal MaterializeAtom(ResponseInfo responseInfo, QueryComponents queryComponents, ProjectionPlan plan, IODataResponseMessage responseMessage, ODataPayloadKind payloadKind)
{
Type type;
this.responseInfo = responseInfo;
this.elementType = queryComponents.LastSegmentType;
this.MergeOptionValue = responseInfo.MergeOption;
this.expectingPrimitiveValue = PrimitiveType.IsKnownNullableType(this.elementType);
Type materializerType = GetTypeForMaterializer(this.expectingPrimitiveValue, this.elementType, responseInfo.MaxProtocolVersion, out type);
this.materializer = ODataMaterializer.CreateMaterializerForMessage(responseMessage, responseInfo, materializerType, queryComponents, plan, payloadKind);
}
internal MaterializeAtom(ResponseInfo responseInfo, IEnumerable<ODataEntry> entries, Type elementType)
{
Type type;
this.responseInfo = responseInfo;
this.elementType = elementType;
this.MergeOptionValue = responseInfo.MergeOption;
this.expectingPrimitiveValue = PrimitiveType.IsKnownNullableType(elementType);
Type expectedType = GetTypeForMaterializer(this.expectingPrimitiveValue, this.elementType, responseInfo.MaxProtocolVersion, out type);
QueryComponents queryComponents = new QueryComponents(null, Util.DataServiceVersionEmpty, elementType, null, null);
this.materializer = new ODataEntriesEntityMaterializer(entries, responseInfo, queryComponents, expectedType, null);
}
private static void MaterializeToList(ODataEntityMaterializer materializer, IEnumerable list, Type nestedExpectedType, IEnumerable <ODataEntry> entries)
{
Action <object, object> addToCollectionDelegate = ODataMaterializer.GetAddToCollectionDelegate(list.GetType());
foreach (ODataEntry entry in entries)
{
MaterializerEntry entry2 = MaterializerEntry.GetEntry(entry);
if (!entry2.EntityHasBeenResolved)
{
materializer.Materialize(entry2, nestedExpectedType, false);
}
addToCollectionDelegate(list, entry2.ResolvedObject);
}
}
internal static IEnumerable ProjectionSelect(ODataEntityMaterializer materializer, MaterializerEntry entry, Type expectedType, Type resultType, ProjectionPath path, Func <object, object, Type, object> selector)
{
ClientEdmModel model = ClientEdmModel.GetModel(materializer.ResponseInfo.MaxProtocolVersion);
ClientTypeAnnotation clientTypeAnnotation = entry.ActualType ?? model.GetClientTypeAnnotation(model.GetOrCreateEdmType(expectedType));
IEnumerable enumerable = (IEnumerable)Util.ActivatorCreateInstance(typeof(List <>).MakeGenericType(new Type[] { resultType }), new object[0]);
MaterializerNavigationLink link = null;
ClientPropertyAnnotation property = null;
for (int i = 0; i < path.Count; i++)
{
ProjectionPathSegment segment = path[i];
if (segment.SourceTypeAs != null)
{
clientTypeAnnotation = model.GetClientTypeAnnotation(model.GetOrCreateEdmType(segment.SourceTypeAs));
}
if (segment.Member != null)
{
string member = segment.Member;
property = clientTypeAnnotation.GetProperty(member, false);
link = GetPropertyOrThrow(entry.NavigationLinks, member, entry.Id);
if (link.Entry != null)
{
entry = link.Entry;
clientTypeAnnotation = model.GetClientTypeAnnotation(model.GetOrCreateEdmType(property.PropertyType));
}
}
}
ValidatePropertyMatch(property, link.Link);
MaterializerFeed feed = MaterializerFeed.GetFeed(link.Feed);
Action <object, object> addToCollectionDelegate = ODataMaterializer.GetAddToCollectionDelegate(enumerable.GetType());
foreach (ODataEntry entry2 in feed.Entries)
{
object obj2 = selector(materializer, entry2, property.EntityCollectionItemType);
addToCollectionDelegate(enumerable, obj2);
}
ProjectionPlan plan = new ProjectionPlan {
LastSegmentType = property.EntityCollectionItemType,
Plan = selector,
ProjectedType = resultType
};
materializer.FoundNextLinkForCollection(enumerable, feed.NextPageLink, plan);
return(enumerable);
}
protected override void ReadFromMessageReader(ODataMessageReader reader, IEdmTypeReference expectedType)
{
ODataProperty collectionProperty = reader.ReadProperty(expectedType);
Type type = Nullable.GetUnderlyingType(base.ExpectedType) ?? base.ExpectedType;
object obj2 = collectionProperty.Value;
if (expectedType.IsCollection())
{
object obj3;
Type collectionItemType = type;
Type implementationType = ClientTypeUtil.GetImplementationType(type, typeof(ICollection <>));
if (implementationType != null)
{
collectionItemType = implementationType.GetGenericArguments()[0];
obj3 = ODataMaterializer.CreateCollectionInstance(collectionProperty, type, base.ResponseInfo);
}
else
{
implementationType = typeof(ICollection <>).MakeGenericType(new Type[] { collectionItemType });
obj3 = ODataMaterializer.CreateCollectionInstance(collectionProperty, implementationType, base.ResponseInfo);
}
ODataMaterializer.ApplyCollectionDataValues(collectionProperty, base.ResponseInfo.IgnoreMissingProperties, base.ResponseInfo, obj3, collectionItemType, ODataMaterializer.GetAddToCollectionDelegate(implementationType));
this.currentValue = obj3;
}
else if (expectedType.IsComplex())
{
ODataComplexValue complexValue = obj2 as ODataComplexValue;
ODataMaterializer.MaterializeComplexTypeProperty(type, complexValue, base.ResponseInfo.IgnoreMissingProperties, base.ResponseInfo);
this.currentValue = complexValue.GetMaterializedValue();
}
else
{
ODataMaterializer.MaterializePrimitiveDataValue(base.ExpectedType, collectionProperty);
this.currentValue = collectionProperty.GetMaterializedValue();
}
}
internal static object ProjectionValueForPath(ODataEntityMaterializer materializer, MaterializerEntry entry, Type expectedType, ProjectionPath path)
{
if ((path.Count == 0) || ((path.Count == 1) && (path[0].Member == null)))
{
if (!entry.EntityHasBeenResolved)
{
materializer.Materialize(entry, expectedType, false);
}
return(entry.ResolvedObject);
}
object streamLink = null;
ODataNavigationLink link = null;
ODataProperty atomProperty = null;
ICollection <ODataNavigationLink> navigationLinks = entry.NavigationLinks;
IEnumerable <ODataProperty> properties = entry.Entry.Properties;
ClientEdmModel model = ClientEdmModel.GetModel(materializer.ResponseInfo.MaxProtocolVersion);
for (int i = 0; i < path.Count; i++)
{
Func <StreamDescriptor, bool> predicate = null;
Func <ODataNavigationLink, bool> func2 = null;
Func <ODataProperty, bool> func3 = null;
Func <ODataProperty, bool> func4 = null;
Func <ODataNavigationLink, bool> func5 = null;
string propertyName;
ProjectionPathSegment segment = path[i];
if (segment.Member != null)
{
bool flag = i == (path.Count - 1);
propertyName = segment.Member;
expectedType = segment.SourceTypeAs ?? expectedType;
ClientPropertyAnnotation property = model.GetClientTypeAnnotation(model.GetOrCreateEdmType(expectedType)).GetProperty(propertyName, false);
if (property.IsStreamLinkProperty)
{
if (predicate == null)
{
predicate = sd => sd.Name == propertyName;
}
StreamDescriptor descriptor = entry.EntityDescriptor.StreamDescriptors.Where <StreamDescriptor>(predicate).SingleOrDefault <StreamDescriptor>();
if (descriptor == null)
{
if (segment.SourceTypeAs == null)
{
throw new InvalidOperationException(System.Data.Services.Client.Strings.AtomMaterializer_PropertyMissing(propertyName, entry.Entry.Id));
}
return(WebUtil.GetDefaultValue <DataServiceStreamLink>());
}
streamLink = descriptor.StreamLink;
}
else
{
if (segment.SourceTypeAs != null)
{
if (func2 == null)
{
func2 = p => p.Name == propertyName;
}
if (!navigationLinks.Any <ODataNavigationLink>(func2))
{
if (func3 == null)
{
func3 = p => p.Name == propertyName;
}
if (!properties.Any <ODataProperty>(func3) && flag)
{
return(WebUtil.GetDefaultValue(property.PropertyType));
}
}
}
if (func4 == null)
{
func4 = p => p.Name == propertyName;
}
atomProperty = properties.Where <ODataProperty>(func4).FirstOrDefault <ODataProperty>();
if (func5 == null)
{
func5 = p => p.Name == propertyName;
}
link = ((atomProperty == null) && (navigationLinks != null)) ? navigationLinks.Where <ODataNavigationLink>(func5).FirstOrDefault <ODataNavigationLink>() : null;
if ((link == null) && (atomProperty == null))
{
throw new InvalidOperationException(System.Data.Services.Client.Strings.AtomMaterializer_PropertyMissing(propertyName, entry.Entry.Id));
}
if (link != null)
{
ValidatePropertyMatch(property, link);
MaterializerNavigationLink link2 = MaterializerNavigationLink.GetLink(link);
if (link2.Feed != null)
{
MaterializerFeed feed = MaterializerFeed.GetFeed(link2.Feed);
Type implementationType = ClientTypeUtil.GetImplementationType(segment.ProjectionType, typeof(ICollection <>));
if (implementationType == null)
{
implementationType = ClientTypeUtil.GetImplementationType(segment.ProjectionType, typeof(IEnumerable <>));
}
Type nestedExpectedType = implementationType.GetGenericArguments()[0];
Type projectionType = segment.ProjectionType;
if (projectionType.IsInterfaceEx() || ODataMaterializer.IsDataServiceCollection(projectionType))
{
projectionType = typeof(Collection <>).MakeGenericType(new Type[] { nestedExpectedType });
}
IEnumerable list = (IEnumerable)Util.ActivatorCreateInstance(projectionType, new object[0]);
MaterializeToList(materializer, list, nestedExpectedType, feed.Entries);
if (ODataMaterializer.IsDataServiceCollection(segment.ProjectionType))
{
list = (IEnumerable)Util.ActivatorCreateInstance(WebUtil.GetDataServiceCollectionOfT(new Type[] { nestedExpectedType }), new object[] { list, TrackingMode.None });
}
ProjectionPlan plan = CreatePlanForShallowMaterialization(nestedExpectedType);
materializer.FoundNextLinkForCollection(list, feed.Feed.NextPageLink, plan);
streamLink = list;
}
else if (link2.Entry != null)
{
MaterializerEntry entry2 = link2.Entry;
if (flag)
{
if ((entry2.Entry != null) && !entry2.EntityHasBeenResolved)
{
materializer.Materialize(entry2, property.PropertyType, false);
}
}
else
{
CheckEntryToAccessNotNull(entry2, propertyName);
}
properties = entry2.Properties;
navigationLinks = entry2.NavigationLinks;
streamLink = entry2.ResolvedObject;
entry = entry2;
}
}
else
{
if (atomProperty.Value is ODataStreamReferenceValue)
{
streamLink = null;
navigationLinks = ODataMaterializer.EmptyLinks;
properties = ODataMaterializer.EmptyProperties;
continue;
}
ValidatePropertyMatch(property, atomProperty);
if (ClientTypeUtil.TypeOrElementTypeIsEntity(property.PropertyType))
{
throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.AtomMaterializer_InvalidEntityType(property.EntityCollectionItemType ?? property.PropertyType));
}
if (property.IsPrimitiveOrComplexCollection)
{
object instance = streamLink ?? (entry.ResolvedObject ?? Util.ActivatorCreateInstance(expectedType, new object[0]));
ODataMaterializer.ApplyDataValue(model.GetClientTypeAnnotation(model.GetOrCreateEdmType(instance.GetType())), atomProperty, materializer.ResponseInfo.IgnoreMissingProperties, materializer.ResponseInfo, instance);
navigationLinks = ODataMaterializer.EmptyLinks;
properties = ODataMaterializer.EmptyProperties;
}
else if (atomProperty.Value is ODataComplexValue)
{
ODataComplexValue complexValue = atomProperty.Value as ODataComplexValue;
ODataMaterializer.MaterializeComplexTypeProperty(property.PropertyType, complexValue, materializer.ResponseInfo.IgnoreMissingProperties, materializer.ResponseInfo);
properties = complexValue.Properties;
navigationLinks = ODataMaterializer.EmptyLinks;
}
else
{
if ((atomProperty.Value == null) && !ClientTypeUtil.CanAssignNull(property.NullablePropertyType))
{
throw new InvalidOperationException(System.Data.Services.Client.Strings.AtomMaterializer_CannotAssignNull(atomProperty.Name, property.NullablePropertyType));
}
ODataMaterializer.MaterializePrimitiveDataValue(property.NullablePropertyType, atomProperty);
navigationLinks = ODataMaterializer.EmptyLinks;
properties = ODataMaterializer.EmptyProperties;
}
streamLink = atomProperty.GetMaterializedValue();
}
}
expectedType = property.PropertyType;
}
}
return(streamLink);
}
private void MaterializeResolvedEntry(MaterializerEntry entry, bool includeLinks)
{
ClientTypeAnnotation actualType = entry.ActualType;
if (!actualType.IsEntityType)
{
throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.AtomMaterializer_InvalidNonEntityType(actualType.ElementTypeName));
}
ODataMaterializer.MaterializeDataValues(actualType, entry.Properties, base.ResponseInfo.IgnoreMissingProperties);
if (entry.NavigationLinks != null)
{
foreach (ODataNavigationLink link in entry.NavigationLinks)
{
ClientPropertyAnnotation annotation2 = actualType.GetProperty(link.Name, true);
if (annotation2 != null)
{
ValidatePropertyMatch(annotation2, link, base.ResponseInfo, true);
}
}
}
if (includeLinks && (entry.NavigationLinks != null))
{
foreach (ODataNavigationLink link2 in entry.NavigationLinks)
{
MaterializerNavigationLink link3 = MaterializerNavigationLink.GetLink(link2);
if (link3 != null)
{
ClientPropertyAnnotation annotation3 = actualType.GetProperty(link2.Name, base.ResponseInfo.IgnoreMissingProperties);
if (annotation3 != null)
{
if (link3.Feed != null)
{
this.ApplyFeedToCollection(entry, annotation3, link3.Feed, includeLinks);
}
else if (link3.Entry != null)
{
MaterializerEntry entry2 = link3.Entry;
if (entry2.Entry != null)
{
this.Materialize(entry2, annotation3.PropertyType, includeLinks);
}
if (entry.ShouldUpdateFromPayload)
{
annotation3.SetValue(entry.ResolvedObject, entry2.ResolvedObject, link2.Name, true);
this.log.SetLink(entry, annotation3.PropertyName, entry2.ResolvedObject);
}
}
}
}
}
}
foreach (ODataProperty property in entry.Properties)
{
if (!(property.Value is ODataStreamReferenceValue))
{
ClientPropertyAnnotation annotation4 = actualType.GetProperty(property.Name, base.ResponseInfo.IgnoreMissingProperties);
if ((annotation4 != null) && entry.ShouldUpdateFromPayload)
{
ValidatePropertyMatch(annotation4, property, base.ResponseInfo, true);
ODataMaterializer.ApplyDataValue(actualType, property, base.ResponseInfo.IgnoreMissingProperties, base.ResponseInfo, entry.ResolvedObject);
}
}
}
ApplyLinkProperties(actualType, entry);
if (base.ResponseInfo.HasReadingEntityHandlers)
{
ODataMaterializer.ReadingEntityInfo annotation = entry.Entry.GetAnnotation <ODataMaterializer.ReadingEntityInfo>();
base.ResponseInfo.FireReadingEntityEvent(entry.ResolvedObject, annotation.EntryPayload, annotation.BaseUri);
}
}
protected override void ReadFromMessageReader(ODataMessageReader reader, IEdmTypeReference expectedType)
{
object obj2 = reader.ReadValue(expectedType);
ODataMaterializer.MaterializePrimitiveDataValue(base.ExpectedType, null, obj2, base.ResponseInfo, () => "TODO: Is this reachable?", out this.currentValue);
}