public void ReadCompletedAsyncResponse()
{
string payload = "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nOData-Version: 4.0\r\n\r\n{\"@odata.context\":\"http://host/service/$metadata#MySingleton\",\"Id\":1}";
var asyncReader = this.CreateAsyncReader(payload);
var asyncResponse = asyncReader.CreateResponseMessage();
Assert.Equal(200, asyncResponse.StatusCode);
Assert.Equal("application/json", asyncResponse.GetHeader("Content-Type"));
Assert.Equal("4.0", asyncResponse.GetHeader("OData-Version"));
using (var innerMessageReader = new ODataMessageReader(asyncResponse, new ODataMessageReaderSettings(), userModel))
{
var reader = innerMessageReader.CreateODataEntryReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = reader.Item as ODataEntry;
Assert.Equal(1, entry.Properties.Single(p => p.Name == "Id").Value);
}
}
}
}
public void Can_deserialize_payload_with_complex_parameters()
{
string actionName = "Complex";
string body = @"{ ""Quantity"": 1 , ""Address"": { ""StreetAddress"":""1 Microsoft Way"", ""City"": ""Redmond"", ""State"": ""WA"", ""ZipCode"": 98052 } }";
ODataMessageWrapper message = new ODataMessageWrapper(GetStringAsStream(body));
message.SetHeader("Content-Type", "application/json;odata=verbose");
IEdmModel model = GetModel();
ODataMessageReader reader = new ODataMessageReader(message as IODataRequestMessage, new ODataMessageReaderSettings(), model);
ODataActionPayloadDeserializer deserializer = new ODataActionPayloadDeserializer(typeof(ODataActionParameters), new DefaultODataDeserializerProvider(model));
string url = "http://server/service/Customers(10)/" + actionName;
HttpRequestMessage request = GetPostRequest(url);
ODataDeserializerContext context = new ODataDeserializerContext { Request = request, Model = model };
ODataActionParameters payload = deserializer.Read(reader, context) as ODataActionParameters;
Assert.NotNull(payload);
Assert.Same(model.EntityContainers().Single().FunctionImports().SingleOrDefault(f => f.Name == "Complex"), payload.GetFunctionImport(context));
Assert.True(payload.ContainsKey("Quantity"));
Assert.Equal(1, payload["Quantity"]);
Assert.True(payload.ContainsKey("Address"));
MyAddress address = payload["Address"] as MyAddress;
Assert.NotNull(address);
Assert.Equal("1 Microsoft Way", address.StreetAddress);
Assert.Equal("Redmond", address.City);
Assert.Equal("WA", address.State);
Assert.Equal(98052, address.ZipCode);
}
/// <inheritdoc />
public override object Read(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
IEdmNavigationProperty navigationProperty = GetNavigationProperty(readContext.Path);
if (navigationProperty == null)
{
throw new SerializationException(SRResources.NavigationPropertyMissingDuringDeserialization);
}
ODataEntityReferenceLink entityReferenceLink = messageReader.ReadEntityReferenceLink(navigationProperty);
if (entityReferenceLink != null)
{
return ResolveContentId(entityReferenceLink.Url, readContext);
}
return null;
}
private void ProcessUpdateEntityReference(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage, ODataPath odataPath)
{
// This is for change the reference in single-valued navigation property
// PUT ~/Person(0)/Parent/$ref
// {
// "@odata.context": "http://host/service/$metadata#$ref",
// "@odata.id": "Orders(10643)"
// }
if (this.HttpMethod == HttpMethod.PATCH)
{
throw Utility.BuildException(HttpStatusCode.MethodNotAllowed, "PATCH on a reference link is not supported.", null);
}
// Get the parent first
var level = this.QueryContext.QueryPath.Count - 2;
var parent = this.QueryContext.ResolveQuery(this.DataSource, level);
var navigationPropertyName = ((NavigationPropertyLinkSegment)odataPath.LastSegment).NavigationProperty.Name;
using (var messageReader = new ODataMessageReader(requestMessage, this.GetReaderSettings(), this.DataSource.Model))
{
var referenceLink = messageReader.ReadEntityReferenceLink();
var queryContext = new QueryContext(this.ServiceRootUri, referenceLink.Url, this.DataSource.Model);
var target = queryContext.ResolveQuery(this.DataSource);
this.DataSource.UpdateProvider.UpdateLink(parent, navigationPropertyName, target);
this.DataSource.UpdateProvider.SaveChanges();
}
ResponseWriter.WriteEmptyResponse(responseMessage);
}
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();
}
}
public async Task ModelBuilderTest()
{
string requestUri = string.Format("{0}/odata/$metadata", this.BaseAddress);
HttpResponseMessage response = await this.Client.GetAsync(requestUri);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var stream = await response.Content.ReadAsStreamAsync();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
var container = edmModel.EntityContainer;
Assert.Equal("Container", container.Name);
var employeeType = edmModel.SchemaElements.Single(e => e.Name == "Employee") as IEdmEntityType;
employeeType.Properties().All(p => this.IsCamelCase(p.Name));
var managerType = edmModel.SchemaElements.Single(e => e.Name == "Manager") as IEdmEntityType;
Assert.Equal(7, managerType.Properties().Count());
managerType.Properties().All(p => this.IsCamelCase(p.Name));
var addressType = edmModel.SchemaElements.Single(e => e.Name == "Address") as IEdmComplexType;
addressType.Properties().All(p => this.IsCamelCase(p.Name));
}
public void ReadJsonLight()
{
// Arrange
var deserializer = new ODataEntityReferenceLinkDeserializer();
MockODataRequestMessage requestMessage = new MockODataRequestMessage();
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings();
writerSettings.SetContentType(ODataFormat.Json);
IEdmModel model = CreateModel();
ODataMessageWriter messageWriter = new ODataMessageWriter(requestMessage, writerSettings, model);
messageWriter.WriteEntityReferenceLink(new ODataEntityReferenceLink { Url = new Uri("http://localhost/samplelink") });
ODataMessageReader messageReader = new ODataMessageReader(new MockODataRequestMessage(requestMessage),
new ODataMessageReaderSettings(), model);
IEdmNavigationProperty navigationProperty = GetNavigationProperty(model);
ODataDeserializerContext context = new ODataDeserializerContext
{
Request = new HttpRequestMessage(),
Path = new ODataPath(new NavigationPathSegment(navigationProperty))
};
// Act
Uri uri = deserializer.Read(messageReader, typeof(Uri), context) as Uri;
// Assert
Assert.NotNull(uri);
Assert.Equal("http://localhost/samplelink", uri.AbsoluteUri);
}
public void Can_deserialize_payload_with_primitive_parameters()
{
string actionName = "Primitive";
int quantity = 1;
string productCode = "PCode";
string body = "{" + string.Format(@" ""Quantity"": {0} , ""ProductCode"": ""{1}"" ", quantity, productCode) + "}";
ODataMessageWrapper message = new ODataMessageWrapper(GetStringAsStream(body));
message.SetHeader("Content-Type", "application/json;odata=verbose");
IEdmModel model = GetModel();
ODataMessageReader reader = new ODataMessageReader(message as IODataRequestMessage, new ODataMessageReaderSettings(), model);
ODataActionPayloadDeserializer deserializer = new ODataActionPayloadDeserializer(new DefaultODataDeserializerProvider());
ODataPath path = CreatePath(model, actionName);
ODataDeserializerContext context = new ODataDeserializerContext { Path = path, Model = model };
ODataActionParameters payload = deserializer.Read(reader, context) as ODataActionParameters;
Assert.NotNull(payload);
Assert.Same(
model.EntityContainers().Single().FunctionImports().SingleOrDefault(f => f.Name == "Primitive"),
ODataActionPayloadDeserializer.GetFunctionImport(context));
Assert.True(payload.ContainsKey("Quantity"));
Assert.Equal(quantity, payload["Quantity"]);
Assert.True(payload.ContainsKey("ProductCode"));
Assert.Equal(productCode, payload["ProductCode"]);
}
/// <summary>
/// Specifically use to query single entry or multi entries(query with $expand)
/// </summary>
/// <param name="requestUri"></param>
/// <param name="mimeType"></param>
/// <returns></returns>
public List<ODataEntry> QueryEntries(string requestUri, string mimeType)
{
List<ODataEntry> entries = new List<ODataEntry>();
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings() { BaseUri = baseUri };
var requestMessage = new HttpWebRequestMessage(new Uri(baseUri.AbsoluteUri + requestUri, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, model))
{
var reader = messageReader.CreateODataEntryReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
entries.Add(reader.Item as ODataEntry);
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
return entries;
}
public void ReadValueOfTypeDefinitionShouldWork()
{
Stream stream = new MemoryStream(Encoding.Default.GetBytes("123"));
IODataResponseMessage responseMessage = new InMemoryMessage() { StatusCode = 200, Stream = stream };
ODataMessageReader reader = new ODataMessageReader(responseMessage, new ODataMessageReaderSettings(), new EdmModel());
reader.ReadValue(new EdmTypeDefinitionReference(new EdmTypeDefinition("NS", "Length", EdmPrimitiveTypeKind.Int32), true)).Should().Be(123);
}
public void ReadValueOfAbbreviativeDateShouldWork()
{
Stream stream = new MemoryStream(Encoding.Default.GetBytes("2014-1-3"));
IODataResponseMessage responseMessage = new InMemoryMessage() { StatusCode = 200, Stream = stream };
ODataMessageReader reader = new ODataMessageReader(responseMessage, new ODataMessageReaderSettings(), new EdmModel());
reader.ReadValue(new EdmTypeDefinitionReference(new EdmTypeDefinition("NS", "DateValue", EdmPrimitiveTypeKind.Date), true)).Should().Be(new Date(2014, 1, 3));
}
public void EntryMetadataUrlRoundTrip()
{
var stream = new MemoryStream();
var writerRequestMemoryMessage = new InMemoryMessage();
writerRequestMemoryMessage.Stream = stream;
writerRequestMemoryMessage.SetHeader("Content-Type", "application/json");
var writerSettings = new ODataMessageWriterSettings() {Version = ODataVersion.V4, DisableMessageStreamDisposal = true};
writerSettings.ODataUri = new ODataUri() {ServiceRoot = new Uri("http://christro.svc/")};
var messageWriter = new ODataMessageWriter((IODataResponseMessage)writerRequestMemoryMessage, writerSettings, this.model);
var organizationSetWriter = messageWriter.CreateODataEntryWriter(this.organizationsSet);
var odataEntry = new ODataEntry(){ TypeName = ModelNamespace + ".Corporation" };
odataEntry.Property("Id", 1);
odataEntry.Property("Name", "");
odataEntry.Property("TickerSymbol", "MSFT");
organizationSetWriter.WriteStart(odataEntry);
organizationSetWriter.WriteEnd();
var readerPayloadInput = Encoding.UTF8.GetString(stream.GetBuffer());
Console.WriteLine(readerPayloadInput);
var readerResponseMemoryMessage = new InMemoryMessage();
readerResponseMemoryMessage.Stream = new MemoryStream(stream.GetBuffer());
readerResponseMemoryMessage.SetHeader("Content-Type", "application/json");
var messageReader = new ODataMessageReader((IODataResponseMessage)readerResponseMemoryMessage, new ODataMessageReaderSettings() {MaxProtocolVersion = ODataVersion.V4, DisableMessageStreamDisposal = true}, this.model);
var organizationReader = messageReader.CreateODataEntryReader(this.organizationsSet, this.organizationsSet.EntityType());
organizationReader.Read().Should().Be(true);
organizationReader.Item.As<ODataEntry>();
}
public async Task ModelBuilderTest(string modelMode)
{
string requestUri = string.Format("{0}/{1}/$metadata", this.BaseAddress, modelMode);
HttpResponseMessage response = await this.Client.GetAsync(requestUri);
var stream = await response.Content.ReadAsStreamAsync();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
var fileType = edmModel.SchemaElements.OfType<IEdmEntityType>().Single(et => et.Name == "File");
Assert.Equal(5, fileType.Properties().Count());
var createdDateProperty = fileType.DeclaredProperties.Single(p => p.Name == "CreatedDate");
Assert.Equal(EdmTypeKind.Primitive, createdDateProperty.Type.TypeKind());
Assert.Equal("Edm.DateTimeOffset", createdDateProperty.Type.Definition.FullTypeName());
Assert.False(createdDateProperty.Type.IsNullable);
var deleteDateProperty = fileType.DeclaredProperties.Single(p => p.Name == "DeleteDate");
Assert.Equal(EdmTypeKind.Primitive, deleteDateProperty.Type.TypeKind());
Assert.Equal("Edm.DateTimeOffset", deleteDateProperty.Type.Definition.FullTypeName());
Assert.True(deleteDateProperty.Type.IsNullable);
var modifiedDates = fileType.DeclaredProperties.Single(p => p.Name == "ModifiedDates");
Assert.Equal(EdmTypeKind.Collection, modifiedDates.Type.TypeKind());
Assert.Equal("Collection(Edm.DateTimeOffset)", modifiedDates.Type.Definition.FullTypeName());
Assert.False(modifiedDates.Type.IsNullable);
}
public void CreateMessageReaderShouldSetAnnotationFilterWhenODataAnnotationIsSetOnPreferenceAppliedHeader()
{
IODataResponseMessage responseMessage = new InMemoryMessage();
responseMessage.PreferenceAppliedHeader().AnnotationFilter = "*";
ODataMessageReader reader = new ODataMessageReader(responseMessage, new ODataMessageReaderSettings());
reader.Settings.ShouldIncludeAnnotation.Should().NotBeNull();
}
/// <inheritdoc />
public override object Read(
ODataMessageReader messageReader,
Type type,
ODataDeserializerContext readContext)
{
return enumDeserializer.Read(messageReader, type, readContext);
}
/// <inheritdoc />
public override object Read(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
IEdmTypeReference edmType = readContext.GetEdmType(type);
Contract.Assert(edmType != null);
if (!edmType.IsCollection())
{
throw Error.Argument("type", SRResources.ArgumentMustBeOfType, EdmTypeKind.Collection);
}
IEdmCollectionTypeReference collectionType = edmType.AsCollection();
IEdmTypeReference elementType = collectionType.ElementType();
IEnumerable result = ReadInline(ReadCollection(messageReader, elementType), edmType, readContext) as IEnumerable;
if (result != null && readContext.IsUntyped && elementType.IsComplex())
{
EdmComplexObjectCollection complexCollection = new EdmComplexObjectCollection(collectionType);
foreach (EdmComplexObject complexObject in result)
{
complexCollection.Add(complexObject);
}
return complexCollection;
}
return result;
}
/// <inheritdoc />
public override object Read(ODataMessageReader messageReader, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (readContext.Path == null)
{
throw Error.Argument("readContext", SRResources.ODataPathMissing);
}
IEdmEntitySet entitySet = GetEntitySet(readContext.Path);
if (entitySet == null)
{
throw new SerializationException(SRResources.EntitySetMissingDuringDeserialization);
}
ODataReader odataReader = messageReader.CreateODataEntryReader(entitySet, EntityType.EntityDefinition());
ODataEntryWithNavigationLinks topLevelEntry = ReadEntryOrFeed(odataReader) as ODataEntryWithNavigationLinks;
Contract.Assert(topLevelEntry != null);
return ReadInline(topLevelEntry, readContext);
}
public async Task ReferentialConstraintModelBuilderTest(string modelMode)
{
string requestUri = string.Format("{0}/{1}/$metadata", this.BaseAddress, modelMode);
HttpResponseMessage response = await this.Client.GetAsync(requestUri);
var stream = await response.Content.ReadAsStreamAsync();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
var customer = edmModel.SchemaElements.OfType<IEdmEntityType>()
.Single(et => et.Name == "ForeignKeyCustomer");
Assert.Equal(3, customer.Properties().Count());
var order = edmModel.SchemaElements.OfType<IEdmEntityType>().Single(et => et.Name == "ForeignKeyOrder");
Assert.Equal(4, order.Properties().Count());
var customerIdProperty = order.DeclaredProperties.Single(p => p.Name == "CustomerId");
var navProperty = order.DeclaredNavigationProperties().Single(p => p.Name == "Customer");
Assert.Equal(EdmOnDeleteAction.Cascade, navProperty.OnDelete);
Assert.Equal(1, navProperty.DependentProperties.Count());
var dependentProperty = navProperty.DependentProperties.Single();
Assert.Same(customerIdProperty, dependentProperty);
}
public void EncodingShouldRemainInvariantInReader()
{
Stream stream = new MemoryStream(Encoding.GetEncoding("iso-8859-1").GetBytes("{\"@odata.context\":\"http://stuff/#Edm.Int32\",\"value\":4}"));
IODataResponseMessage responseMessage = new InMemoryMessage() { StatusCode = 200, Stream = stream };
responseMessage.SetHeader("Content-Type", "application/json;odata.metadata=minimal;");
ODataMessageReader reader = new ODataMessageReader(responseMessage, new ODataMessageReaderSettings(), new EdmModel());
reader.ReadProperty();
}
protected sealed override void OnDispose()
{
if (this.messageReader != null)
{
this.messageReader.Dispose();
this.messageReader = null;
}
}
public void CreateMessageReaderShouldNotSetAnnotationFilterWhenItIsAlreadySet()
{
IODataResponseMessage responseMessage = new InMemoryMessage();
responseMessage.PreferenceAppliedHeader().AnnotationFilter = "*";
Func<string, bool> shouldWrite = name => false;
ODataMessageReader reader = new ODataMessageReader(responseMessage, new ODataMessageReaderSettings { ShouldIncludeAnnotation = shouldWrite });
reader.Settings.ShouldIncludeAnnotation.Should().BeSameAs(shouldWrite);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="messageReader">The message reader to wrap.</param>
/// <param name="testConfiguration">The test configuration to use.</param>
/// <remarks>
/// This constructor is used if not special checks against a test message should be performed.
/// Use the constructor overload that takes a <see cref="TestMessage"/> argument to enforce checks
/// around disposal of the message.
/// </remarks>
public ODataMessageReaderTestWrapper(ODataMessageReader messageReader, ODataMessageReaderSettings messageReaderSettings, ReaderTestConfiguration testConfiguration)
{
ExceptionUtilities.CheckArgumentNotNull(messageReader, "messageReader");
ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");
this.messageReader = messageReader;
this.messageReaderSettings = messageReaderSettings;
this.testConfiguration = testConfiguration;
}
/// <inheritdoc />
public override object Read(ODataMessageReader messageReader, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
ODataCollectionValue value = ReadCollection(messageReader);
return ReadInline(value, readContext);
}
/// <inheritdoc />
public override object Read(ODataMessageReader messageReader, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
ODataProperty property = messageReader.ReadProperty();
return ReadInline(property, readContext);
}
public static IEdmModel GetServiceModel(Uri uri)
{
HttpWebRequestMessage message = new HttpWebRequestMessage(uri);
message.SetHeader("Accept", MimeTypes.ApplicationXml);
using (var messageReader = new ODataMessageReader(message.GetResponse()))
{
return messageReader.ReadMetadataDocument();
}
}
internal ODataMessageReaderDeserializer(bool update, IDataService dataService, UpdateTracker tracker, RequestDescription requestDescription, bool enableWcfDataServicesServerBehavior) : base(update, dataService, tracker, requestDescription)
{
System.Data.Services.ODataRequestMessage requestMessage = new System.Data.Services.ODataRequestMessage(dataService.OperationContext.Host);
if (WebUtil.CompareMimeType(requestMessage.ContentType, "*/*"))
{
requestMessage.ContentType = "application/atom+xml";
}
this.messageReader = new ODataMessageReader(requestMessage, WebUtil.CreateMessageReaderSettings(dataService, enableWcfDataServicesServerBehavior), dataService.Provider.GetMetadataModel(base.Service.OperationContext));
this.contentFormat = System.Data.Services.ContentFormat.Unknown;
}
public void ReadThrowsWhenPathIsMissing()
{
// Arrange
var deserializer = new ODataEntityReferenceLinkDeserializer();
ODataMessageReader reader = new ODataMessageReader(new MockODataRequestMessage());
ODataDeserializerContext context = new ODataDeserializerContext();
// Act & Assert
Assert.Throws<SerializationException>(() => deserializer.Read(reader, context),
"The operation cannot be completed because no ODataPath is available for the request.");
}
public override void CustomTestInitialize()
{
// retrieve IEdmModel of the test service
HttpWebRequestMessage message = new HttpWebRequestMessage(new Uri(this.ServiceUri.AbsoluteUri + "$metadata", UriKind.Absolute));
message.SetHeader("Accept", MimeTypes.ApplicationXml);
using (var messageReader = new ODataMessageReader(message.GetResponse()))
{
this.model = messageReader.ReadMetadataDocument();
}
}
public ODataAdapter(ISession session, string protocolVersion, HttpResponseMessage response)
: this(session, protocolVersion)
{
var readerSettings = new ODataMessageReaderSettings
{
MessageQuotas = { MaxReceivedMessageSize = Int32.MaxValue }
};
using (var messageReader = new ODataMessageReader(new ODataResponseMessage(response), readerSettings))
{
Model = messageReader.ReadMetadataDocument();
}
}
public override object Read(ODataMessageReader messageReader, ODataDeserializerReadContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
object value = messageReader.ReadValue(PrimitiveTypeReference);
// TODO: Bug 467612: do value conversions here.
return value;
}
