internal AtomMaterializerLog(ResponseInfo responseInfo) { this.responseInfo = responseInfo; this.mergeOption = responseInfo.MergeOption; this.identityStack = new Dictionary<string, ODataEntry>(EqualityComparer<string>.Default); this.links = new List<LinkDescriptor>(); }
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); }
internal static MaterializeAtom Materialize( ResponseInfo responseInfo, QueryComponents queryComponents, ProjectionPlan plan, string contentType, IODataResponseMessage message, ODataPayloadKind expectedPayloadKind) { Debug.Assert(null != queryComponents, "querycomponents"); Debug.Assert(null != message, "message"); // If there is no content (For e.g. /Customers(1)/BestFriend is null), we need to return empty results. if (message.StatusCode == (int)HttpStatusCode.NoContent || String.IsNullOrEmpty(contentType)) { return(MaterializeAtom.EmptyResults); } return(new MaterializeAtom(responseInfo, queryComponents, plan, message, expectedPayloadKind)); }
private void MaterializeResponse(EntityDescriptor entityDescriptor, ResponseInfo responseInfo, string etag) { using (MaterializeAtom atom = this.GetMaterializer(entityDescriptor, responseInfo)) { atom.SetInsertingObject(entityDescriptor.Entity); object obj2 = null; foreach (object obj3 in atom) { if (obj2 != null) { System.Data.Services.Client.Error.ThrowInternalError(InternalError.MaterializerReturningMoreThanOneEntity); } obj2 = obj3; } if (entityDescriptor.GetLatestETag() == null) { entityDescriptor.ETag = etag; } } }
internal static ODataMessageReaderSettings CreateODataMessageReaderSettings(ResponseInfo responseInfo, Func <ODataEntry, XmlReader, Uri, XmlReader> entryXmlCustomizer, bool projectionQuery) { ODataMessageReaderSettings settings = new ODataMessageReaderSettings(); responseInfo.TypeResolver = new TypeResolver(responseInfo, projectionQuery); settings.EnableWcfDataServicesClientBehavior(new Func <IEdmType, string, IEdmType>(responseInfo.TypeResolver.ResolveWireTypeName), responseInfo.DataNamespace, CommonUtil.UriToString(responseInfo.TypeScheme), entryXmlCustomizer); settings.BaseUri = (responseInfo.BaseUriResolver.GetRawBaseUriValue() != null) ? responseInfo.BaseUriResolver.GetBaseUriWithSlash() : null; settings.UndeclaredPropertyBehaviorKinds = ODataUndeclaredPropertyBehaviorKinds.ReportUndeclaredLinkProperty; settings.MaxProtocolVersion = CommonUtil.ConvertToODataVersion(responseInfo.MaxProtocolVersion); if (responseInfo.IgnoreMissingProperties) { settings.UndeclaredPropertyBehaviorKinds |= ODataUndeclaredPropertyBehaviorKinds.IgnoreUndeclaredValueProperty; } settings.MessageQuotas.MaxEntityPropertyMappingsPerType = 0x7fffffff; settings.MessageQuotas.MaxNestingDepth = 0x7fffffff; settings.MessageQuotas.MaxOperationsPerChangeset = 0x7fffffff; settings.MessageQuotas.MaxPartsPerBatch = 0x7fffffff; settings.MessageQuotas.MaxReceivedMessageSize = 0x7fffffffffffffffL; return(settings); }
private void HandleOperationResponseData(HttpWebResponse response, Stream responseStream) { Version version; Func <Stream> getResponseStream = null; Dictionary <string, string> headers = WebUtil.WrapResponseHeaders(response); Descriptor descriptor = base.ChangedEntries[base.entryIndex]; MaterializerEntry entry = null; Exception exception = BaseSaveResult.HandleResponse(base.RequestInfo, response.StatusCode, response.Headers["DataServiceVersion"], () => responseStream, false, out version); if (((responseStream != null) && (descriptor.DescriptorKind == DescriptorKind.Entity)) && (exception == null)) { EntityDescriptor entityDescriptor = (EntityDescriptor)descriptor; if (((entityDescriptor.State == EntityStates.Added) || (entityDescriptor.StreamState == EntityStates.Added)) || ((entityDescriptor.State == EntityStates.Modified) || (entityDescriptor.StreamState == EntityStates.Modified))) { try { ResponseInfo responseInfo = base.CreateResponseInfo(entityDescriptor); if (getResponseStream == null) { getResponseStream = () => responseStream; } HttpWebResponseMessage message = new HttpWebResponseMessage(response, getResponseStream); entry = ODataReaderEntityMaterializer.ParseSingleEntityPayload(message, responseInfo, entityDescriptor.Entity.GetType()); entityDescriptor.TransientEntityDescriptor = entry.EntityDescriptor; } catch (Exception exception2) { exception = exception2; if (!CommonUtil.IsCatchableExceptionType(exception2)) { throw; } } } } this.cachedResponses.Add(new CachedResponse(descriptor, headers, response.StatusCode, version, (entry != null) ? entry.Entry : null, exception)); if (exception != null) { descriptor.SaveError = exception; } }
#pragma warning restore 649 #endif #endregion Private fields /// <summary> /// constructor /// </summary> /// <param name="responseInfo">originating context</param> /// <param name="queryComponents">Query components (projection, expected type)</param> /// <param name="plan">Projection plan (if compiled in an earlier query).</param> /// <param name="responseMessage">responseMessage</param> /// <param name="payloadKind">The kind of the payload to materialize.</param> internal MaterializeAtom( ResponseInfo responseInfo, QueryComponents queryComponents, ProjectionPlan plan, IODataResponseMessage responseMessage, ODataPayloadKind payloadKind) { Debug.Assert(queryComponents != null, "queryComponents != null"); this.responseInfo = responseInfo; this.elementType = queryComponents.LastSegmentType; this.expectingPrimitiveValue = PrimitiveType.IsKnownNullableType(elementType); Debug.Assert(responseMessage != null, "Response message is null! Did you mean to use Materializer.ResultsWrapper/EmptyResults?"); this.responseMessage = responseMessage; Type implementationType; Type materializerType = GetTypeForMaterializer(this.expectingPrimitiveValue, this.elementType, responseInfo.Model, out implementationType); this.materializer = ODataMaterializer.CreateMaterializerForMessage(responseMessage, responseInfo, materializerType, queryComponents, plan, payloadKind); }
protected override MaterializeAtom GetMaterializer(EntityDescriptor entityDescriptor, ResponseInfo responseInfo) { return(new MaterializeAtom(responseInfo, new QueryComponents(null, Util.DataServiceVersionEmpty, entityDescriptor.Entity.GetType(), null, null), null, this.currentOperationResponse.CreateResponseMessage(), ODataPayloadKind.Entry)); }
protected static object CreateCollectionInstance(ODataProperty collectionProperty, Type userCollectionType, System.Data.Services.Client.ResponseInfo responseInfo) { object obj2; ODataCollectionValue value2 = collectionProperty.Value as ODataCollectionValue; ClientTypeAnnotation annotation = responseInfo.TypeResolver.ResolveEdmTypeName(userCollectionType, value2.TypeName); if (IsDataServiceCollection(annotation.ElementType)) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.AtomMaterializer_DataServiceCollectionNotSupportedForNonEntities); } try { obj2 = annotation.CreateInstance(); } catch (MissingMethodException exception) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.AtomMaterializer_NoParameterlessCtorForCollectionProperty(collectionProperty.Name, annotation.ElementTypeName), exception); } return(obj2); }
protected override MaterializeAtom GetMaterializer(EntityDescriptor entityDescriptor, ResponseInfo responseInfo) { return(new MaterializeAtom(responseInfo, new ODataEntry[] { this.cachedResponse.Entry }, entityDescriptor.Entity.GetType())); }
protected override MaterializeAtom GetMaterializer(EntityDescriptor entityDescriptor, ResponseInfo responseInfo) { return new MaterializeAtom(responseInfo, new QueryComponents(null, Util.DataServiceVersionEmpty, entityDescriptor.Entity.GetType(), null, null), null, this.currentOperationResponse.CreateResponseMessage(), ODataPayloadKind.Entry); }
public ODataMessageReaderMaterializer(ODataMessageReader reader, ResponseInfo info, Type expectedType, bool? singleResult) : base(info, expectedType) { this.messageReader = reader; this.SingleResult = singleResult; }
public ODataEntriesEntityMaterializer(IEnumerable<ODataEntry> entries, ResponseInfo responseInfo, QueryComponents queryComponents, Type expectedType, ProjectionPlan materializeEntryPlan) : base(responseInfo, queryComponents, expectedType, materializeEntryPlan) { this.feedEntries = entries.GetEnumerator(); }
protected static ODataMessageReader CreateODataMessageReader(IODataResponseMessage responseMessage, System.Data.Services.Client.ResponseInfo responseInfo, bool projectionQuery, ref ODataPayloadKind payloadKind) { Func <ODataEntry, XmlReader, Uri, XmlReader> entryXmlCustomizer = null; if (responseInfo.HasReadingEntityHandlers) { entryXmlCustomizer = new Func <ODataEntry, XmlReader, Uri, XmlReader>(ODataMaterializer.EntryXmlCustomizer); } ODataMessageReaderSettings settings = WebUtil.CreateODataMessageReaderSettings(responseInfo, entryXmlCustomizer, projectionQuery); ODataMessageReader reader = new ODataMessageReader(responseMessage, settings, ClientEdmModel.GetModel(responseInfo.MaxProtocolVersion)); if (payloadKind == ODataPayloadKind.Unsupported) { List <ODataPayloadKindDetectionResult> source = reader.DetectPayloadKind().ToList <ODataPayloadKindDetectionResult>(); if (source.Count == 0) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.AtomMaterializer_InvalidResponsePayload(responseInfo.DataNamespace)); } ODataPayloadKindDetectionResult result = source.FirstOrDefault <ODataPayloadKindDetectionResult>(delegate(ODataPayloadKindDetectionResult k) { if (k.PayloadKind != ODataPayloadKind.EntityReferenceLink) { return(k.PayloadKind == ODataPayloadKind.EntityReferenceLinks); } return(true); }); if (result == null) { result = source.First <ODataPayloadKindDetectionResult>(); } if ((result.Format != ODataFormat.Atom) && (result.Format != ODataFormat.RawValue)) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.AtomMaterializer_InvalidContentTypeEncountered(responseMessage.GetHeader("Content-Type"))); } payloadKind = result.PayloadKind; } return(reader); }
public ODataLinksMaterializer(ODataMessageReader reader, ResponseInfo info, Type expectedType, bool? singleResult) : base(reader, info, expectedType, singleResult) { }
protected static void ApplyDataValues(ClientTypeAnnotation type, IEnumerable <ODataProperty> properties, bool ignoreMissingProperties, System.Data.Services.Client.ResponseInfo responseInfo, object instance) { foreach (ODataProperty property in properties) { ApplyDataValue(type, property, ignoreMissingProperties, responseInfo, instance); } }
protected abstract MaterializeAtom GetMaterializer(EntityDescriptor entityDescriptor, ResponseInfo responseInfo);
protected override MaterializeAtom GetMaterializer(EntityDescriptor entityDescriptor, ResponseInfo responseInfo) { return new MaterializeAtom(responseInfo, new ODataEntry[] { this.cachedResponse.Entry }, entityDescriptor.Entity.GetType()); }
protected static void ApplyDataValue(ClientTypeAnnotation type, ODataProperty property, bool ignoreMissingProperties, System.Data.Services.Client.ResponseInfo responseInfo, object instance) { ClientPropertyAnnotation annotation = type.GetProperty(property.Name, ignoreMissingProperties); if (annotation != null) { if (annotation.IsPrimitiveOrComplexCollection) { if (property.Value == null) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Collection_NullCollectionNotSupported(property.Name)); } if (property.Value is string) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Deserialize_MixedTextWithComment); } if (property.Value is ODataComplexValue) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.AtomMaterializer_InvalidCollectionItem(property.Name)); } object obj2 = annotation.GetValue(instance); if (obj2 == null) { obj2 = CreateCollectionInstance(property, annotation.PropertyType, responseInfo); annotation.SetValue(instance, obj2, property.Name, false); } else { annotation.ClearBackingICollectionInstance(obj2); } ApplyCollectionDataValues(property, ignoreMissingProperties, responseInfo, obj2, annotation.PrimitiveOrComplexCollectionItemType, new Action <object, object>(annotation.AddValueToBackingICollectionInstance)); } else { object obj3 = property.Value; ODataComplexValue value2 = obj3 as ODataComplexValue; if ((obj3 != null) && (value2 != null)) { if (!annotation.EdmProperty.Type.IsComplex()) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Deserialize_ExpectingSimpleValue); } bool flag = false; ClientEdmModel model = ClientEdmModel.GetModel(responseInfo.MaxProtocolVersion); ClientTypeAnnotation clientTypeAnnotation = model.GetClientTypeAnnotation(model.GetOrCreateEdmType(annotation.PropertyType)); object obj4 = annotation.GetValue(instance); if (obj4 == null) { obj4 = clientTypeAnnotation.CreateInstance(); flag = true; } MaterializeDataValues(clientTypeAnnotation, value2.Properties, ignoreMissingProperties); ApplyDataValues(clientTypeAnnotation, value2.Properties, ignoreMissingProperties, responseInfo, obj4); if (flag) { annotation.SetValue(instance, obj4, property.Name, true); } } else { MaterializePrimitiveDataValue(annotation.NullablePropertyType, property); annotation.SetValue(instance, property.GetMaterializedValue(), property.Name, true); } } } }
protected static bool MaterializePrimitiveDataValue(Type type, string wireTypeName, object value, System.Data.Services.Client.ResponseInfo responseInfo, Func <string> throwOnNullMessage, out object materializedValue) { PrimitiveType type3; Type clrType = Nullable.GetUnderlyingType(type) ?? type; bool flag = PrimitiveType.TryGetPrimitiveType(clrType, out type3); if (!flag) { flag = PrimitiveType.TryGetPrimitiveType(responseInfo.TypeResolver.ResolveEdmTypeName(type, wireTypeName).ElementType, out type3); } if (flag) { if (value == null) { if (!ClientTypeUtil.CanAssignNull(type)) { throw new InvalidOperationException(throwOnNullMessage()); } materializedValue = null; } else { materializedValue = ConvertPrimitiveValue(value, clrType); } return(true); } materializedValue = null; return(false); }
protected static void MaterializeComplexTypeProperty(Type propertyType, ODataComplexValue complexValue, bool ignoreMissingProperties, System.Data.Services.Client.ResponseInfo responseInfo) { object instance = null; if ((complexValue != null) && !complexValue.HasMaterializedValue()) { ClientTypeAnnotation actualType = null; if (WebUtil.IsWireTypeCollection(complexValue.TypeName)) { actualType = responseInfo.TypeResolver.ResolveEdmTypeName(propertyType, complexValue.TypeName); } else { ClientEdmModel model = ClientEdmModel.GetModel(responseInfo.MaxProtocolVersion); actualType = model.GetClientTypeAnnotation(model.GetOrCreateEdmType(propertyType)); } instance = Util.ActivatorCreateInstance(propertyType, new object[0]); MaterializeDataValues(actualType, complexValue.Properties, ignoreMissingProperties); ApplyDataValues(actualType, complexValue.Properties, ignoreMissingProperties, responseInfo, instance); complexValue.SetMaterializedValue(instance); } }
protected static void ApplyCollectionDataValues(ODataProperty collectionProperty, bool ignoreMissingProperties, System.Data.Services.Client.ResponseInfo responseInfo, object collectionInstance, Type collectionItemType, Action <object, object> AddValueToBackingICollectionInstance) { ODataCollectionValue value2 = collectionProperty.Value as ODataCollectionValue; if (value2.Items != null) { bool flag = PrimitiveType.IsKnownNullableType(collectionItemType); ClientEdmModel model = ClientEdmModel.GetModel(responseInfo.MaxProtocolVersion); foreach (object obj2 in value2.Items) { if (obj2 == null) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Collection_NullCollectionItemsNotSupported); } if (flag) { object obj3; if ((obj2 is ODataComplexValue) || (obj2 is ODataCollectionValue)) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Collection_ComplexTypesInCollectionOfPrimitiveTypesNotAllowed); } MaterializePrimitiveDataValue(collectionItemType, value2.TypeName, obj2, responseInfo, () => System.Data.Services.Client.Strings.Collection_NullCollectionItemsNotSupported, out obj3); AddValueToBackingICollectionInstance(collectionInstance, ConvertPrimitiveValue(obj2, collectionItemType)); } else { ODataComplexValue value3 = obj2 as ODataComplexValue; if (value3 == null) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Collection_PrimitiveTypesInCollectionOfComplexTypesNotAllowed); } ClientTypeAnnotation clientTypeAnnotation = model.GetClientTypeAnnotation(model.GetOrCreateEdmType(collectionItemType)); object instance = clientTypeAnnotation.CreateInstance(); ApplyDataValues(clientTypeAnnotation, value3.Properties, ignoreMissingProperties, responseInfo, instance); AddValueToBackingICollectionInstance(collectionInstance, instance); } } } collectionProperty.SetMaterializedValue(collectionInstance); }
public ODataFeedOrEntryReader(ODataReader reader, ResponseInfo responseInfo) { this.reader = reader; this.responseInfo = responseInfo; this.currentEntry = null; this.currentFeed = null; this.feedEntries = null; }
public ODataReaderEntityMaterializer(ODataMessageReader odataMessageReader, ODataReader reader, ResponseInfo responseInfo, QueryComponents queryComponents, Type expectedType, ProjectionPlan materializeEntryPlan) : base(responseInfo, queryComponents, expectedType, materializeEntryPlan) { this.messageReader = odataMessageReader; this.itemReader = new ODataFeedOrEntryReader(reader, responseInfo); }
/// <summary> /// Initializes a new instance of the <see cref="ODataMessageReadingHelper"/> class. /// </summary> /// <param name="responseInfo">The response info.</param> internal ODataMessageReadingHelper(ResponseInfo responseInfo) { Debug.Assert(responseInfo != null, "responseInfo != null"); this.responseInfo = responseInfo; }
public static ODataMaterializer CreateMaterializerForMessage(IODataResponseMessage responseMessage, System.Data.Services.Client.ResponseInfo responseInfo, Type materializerType, QueryComponents queryComponents, ProjectionPlan plan, ODataPayloadKind payloadKind) { ODataMaterializer materializer2; bool projectionQuery = (plan != null) || (queryComponents.Projection != null); ODataMessageReader messageReader = CreateODataMessageReader(responseMessage, responseInfo, projectionQuery, ref payloadKind); IEdmType expectedType = null; try { ODataMaterializer materializer; if (materializerType != typeof(object)) { expectedType = ClientEdmModel.GetModel(responseInfo.MaxProtocolVersion).GetOrCreateEdmType(materializerType); } if ((payloadKind == ODataPayloadKind.Entry) || (payloadKind == ODataPayloadKind.Feed)) { if ((expectedType != null) && (expectedType.TypeKind != EdmTypeKind.Entity)) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.AtomMaterializer_InvalidNonEntityType(materializerType.FullName)); } ODataReader reader = CreateODataReader(messageReader, payloadKind, expectedType, responseInfo.MaxProtocolVersion); materializer = new ODataReaderEntityMaterializer(messageReader, reader, responseInfo, queryComponents, materializerType, plan); } else { switch (payloadKind) { case ODataPayloadKind.Property: if ((expectedType != null) && (expectedType.TypeKind == EdmTypeKind.Entity)) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.AtomMaterializer_InvalidEntityType(materializerType.FullName)); } break; case ODataPayloadKind.EntityReferenceLink: case ODataPayloadKind.EntityReferenceLinks: materializer = new ODataLinksMaterializer(messageReader, responseInfo, materializerType, queryComponents.SingleResult); goto Label_013A; case ODataPayloadKind.Value: materializer = new ODataValueMaterializer(messageReader, responseInfo, materializerType, queryComponents.SingleResult); goto Label_013A; case ODataPayloadKind.BinaryValue: case ODataPayloadKind.Collection: case ODataPayloadKind.ServiceDocument: case ODataPayloadKind.MetadataDocument: goto Label_0129; case ODataPayloadKind.Error: { ODataError error = messageReader.ReadError(); throw new ODataErrorException(error.Message, error); } default: goto Label_0129; } materializer = new ODataPropertyMaterializer(messageReader, responseInfo, materializerType, queryComponents.SingleResult); } goto Label_013A; Label_0129: throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.AtomMaterializer_InvalidResponsePayload(responseInfo.DataNamespace)); Label_013A: materializer2 = materializer; } catch (Exception exception) { if (CommonUtil.IsCatchableExceptionType(exception)) { messageReader.Dispose(); } throw; } return(materializer2); }
protected ODataMaterializer(System.Data.Services.Client.ResponseInfo responseInfo, Type expectedType) { this.ResponseInfo = responseInfo; this.ExpectedType = expectedType; this.nextLinkTable = new Dictionary <IEnumerable, DataServiceQueryContinuation>(System.Data.Services.Client.ReferenceEqualityComparer <IEnumerable> .Instance); }