internal ODataEntriesEntityMaterializer CreateODataEntriesEntityMaterializer(
List <ODataResource> resources,
Type resourceType,
TestMaterializerContext materializerContext = null)
{
var clientEdmModel = new ClientEdmModel(ODataProtocolVersion.V4);
var context = new DataServiceContext();
var resourceSet = new ODataResourceSet();
MaterializerFeed.CreateFeed(resourceSet, resources);
resources.ForEach(r =>
{
if (r == null)
{
MaterializerEntry.CreateEmpty();
}
else
{
MaterializerEntry.CreateEntry(r, ODataFormat.Json, true, clientEdmModel);
}
});
materializerContext = materializerContext ?? new TestMaterializerContext()
{
Model = clientEdmModel, Context = context
};
var adapter = new EntityTrackingAdapter(new TestEntityTracker(), MergeOption.OverwriteChanges, clientEdmModel, context);
QueryComponents components = new QueryComponents(new Uri("http://foo.com/Service"), new Version(4, 0), resourceType, null, new Dictionary <Expression, Expression>());
return(new ODataEntriesEntityMaterializer(resources, materializerContext, adapter, components, resourceType, null, ODataFormat.Json));
}
/// <summary>
/// Initializes a new instance of the <see cref="EntryValueMaterializationPolicy" /> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="entityTrackingAdapter">The entity tracking adapter.</param>
/// <param name="lazyPrimitivePropertyConverter">The lazy primitive property converter.</param>
/// <param name="nextLinkTable">The next link table.</param>
internal EntryValueMaterializationPolicy(
IODataMaterializerContext context,
EntityTrackingAdapter entityTrackingAdapter,
DSClient.SimpleLazy <PrimitivePropertyConverter> lazyPrimitivePropertyConverter,
Dictionary <IEnumerable, DataServiceQueryContinuation> nextLinkTable)
: base(context, lazyPrimitivePropertyConverter)
{
this.nextLinkTable = nextLinkTable;
this.EntityTrackingAdapter = entityTrackingAdapter;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataEntriesEntityMaterializer" /> class.
/// </summary>
/// <param name="entries">The entries.</param>
/// <param name="materializerContext">The materializer context.</param>
/// <param name="entityTrackingAdapter">The entity tracking adapter.</param>
/// <param name="queryComponents">The query components.</param>
/// <param name="expectedType">The expected type.</param>
/// <param name="materializeEntryPlan">The materialize entry plan.</param>
/// <param name="format">The format.</param>
public ODataEntriesEntityMaterializer(
IEnumerable <ODataResource> entries,
IODataMaterializerContext materializerContext,
EntityTrackingAdapter entityTrackingAdapter,
QueryComponents queryComponents,
Type expectedType,
ProjectionPlan materializeEntryPlan,
ODataFormat format)
: base(materializerContext, entityTrackingAdapter, queryComponents, expectedType, materializeEntryPlan)
{
this.format = format;
this.feedEntries = entries.GetEnumerator();
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataReaderEntityMaterializer" /> class.
/// </summary>
/// <param name="odataMessageReader">The odata message reader.</param>
/// <param name="reader">The reader.</param>
/// <param name="materializerContext">The materializer context.</param>
/// <param name="entityTrackingAdapter">The entity tracking adapter.</param>
/// <param name="queryComponents">The query components.</param>
/// <param name="expectedType">The expected type.</param>
/// <param name="materializeEntryPlan">The materialize entry plan.</param>
public ODataReaderEntityMaterializer(
ODataMessageReader odataMessageReader,
ODataReaderWrapper reader,
IODataMaterializerContext materializerContext,
EntityTrackingAdapter entityTrackingAdapter,
QueryComponents queryComponents,
Type expectedType,
ProjectionPlan materializeEntryPlan)
: base(materializerContext, entityTrackingAdapter, queryComponents, expectedType, materializeEntryPlan)
{
this.messageReader = odataMessageReader;
this.feedEntryAdapter = new FeedAndEntryMaterializerAdapter(odataMessageReader, reader, materializerContext.Model, entityTrackingAdapter.MergeOption);
}
/// <summary>
/// constructor
/// </summary>
/// <param name="responseInfo">originating context</param>
/// <param name="entries">entries that needs to be materialized.</param>
/// <param name="elementType">result type.</param>
/// <param name="format">The format of the response being materialized from.</param>
internal MaterializeAtom(ResponseInfo responseInfo, IEnumerable <ODataResource> entries, Type elementType, ODataFormat format)
{
this.responseInfo = responseInfo;
this.elementType = elementType;
this.expectingPrimitiveValue = PrimitiveType.IsKnownNullableType(elementType);
Type implementationType;
Type materializerType = GetTypeForMaterializer(this.expectingPrimitiveValue, this.elementType, responseInfo.Model, out implementationType);
QueryComponents qc = new QueryComponents(null, Util.ODataVersionEmpty, elementType, null, null);
ODataMaterializerContext context = new ODataMaterializerContext(responseInfo);
EntityTrackingAdapter entityTrackingAdapter = new EntityTrackingAdapter(responseInfo.EntityTracker, responseInfo.MergeOption, responseInfo.Model, responseInfo.Context);
this.materializer = new ODataEntriesEntityMaterializer(entries, context, entityTrackingAdapter, qc, materializerType, null, format);
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataLoadNavigationPropertyMaterializer" /> class.
/// </summary>
/// <param name="odataMessageReader">The odata message reader.</param>
/// <param name="reader">The reader.</param>
/// <param name="materializerContext">The materializer context.</param>
/// <param name="entityTrackingAdapter">The entity tracking adapter.</param>
/// <param name="queryComponents">The query components.</param>
/// <param name="expectedType">The expected type.</param>
/// <param name="materializeEntryPlan">The materialize entry plan.</param>
/// <param name="responseInfo">LoadProperty Response Info object.</param>
public ODataLoadNavigationPropertyMaterializer(
ODataMessageReader odataMessageReader,
ODataReaderWrapper reader,
IODataMaterializerContext materializerContext,
EntityTrackingAdapter entityTrackingAdapter,
QueryComponents queryComponents,
Type expectedType,
ProjectionPlan materializeEntryPlan,
LoadPropertyResponseInfo responseInfo)
: base(odataMessageReader, reader, materializerContext, entityTrackingAdapter, queryComponents, expectedType, materializeEntryPlan)
{
this.responseInfo = responseInfo;
this.items = new List <object>();
}
private void TestApplyItemsToCollection(
TestCustomer customer,
IEnumerable orders,
MergeOption option,
TestEntityTracker entityTracker,
bool isContinuation)
{
var customerDescriptor = new EntityDescriptor(this.clientEdmModel)
{
Entity = customer
};
var materializerEntry = MaterializerEntry.CreateEntryForLoadProperty(customerDescriptor, ODataFormat.Json, true);
materializerEntry.ActualType = this.clientEdmModel.GetClientTypeAnnotation(clientEdmModel.GetOrCreateEdmType(typeof(TestCustomer)));
var adapter = new EntityTrackingAdapter(
entityTracker,
option,
clientEdmModel,
new DataServiceContext());
EntryValueMaterializationPolicy evmp = new EntryValueMaterializationPolicy(
materializerContext,
adapter,
null,
new Dictionary <IEnumerable, DataServiceQueryContinuation>());
evmp.ApplyItemsToCollection(
materializerEntry,
ordersProperty,
orders,
null,
null,
isContinuation);
if (entityTracker.GetEntityDescriptorFunc != null)
{
adapter.MaterializationLog.ApplyToContext();
}
}
internal EntryValueMaterializationPolicy CreateEntryMaterializationPolicy(TestMaterializerContext materializerContext = null)
{
var clientEdmModel = new ClientEdmModel(ODataProtocolVersion.V4);
var context = new DataServiceContext();
materializerContext = materializerContext ?? new TestMaterializerContext()
{
Model = clientEdmModel, Context = context
};
var adapter = new EntityTrackingAdapter(new TestEntityTracker(), MergeOption.OverwriteChanges, clientEdmModel, context);
var lazyPrimitivePropertyConverter = new Microsoft.OData.Client.SimpleLazy <PrimitivePropertyConverter>(() => new PrimitivePropertyConverter());
var primitiveValueMaterializerPolicy = new PrimitiveValueMaterializationPolicy(materializerContext, lazyPrimitivePropertyConverter);
var entryPolicy = new EntryValueMaterializationPolicy(materializerContext, adapter, lazyPrimitivePropertyConverter, null);
var collectionPolicy = new CollectionValueMaterializationPolicy(materializerContext, primitiveValueMaterializerPolicy);
var intanceAnnotationPolicy = new InstanceAnnotationMaterializationPolicy(materializerContext);
entryPolicy.CollectionValueMaterializationPolicy = collectionPolicy;
entryPolicy.InstanceAnnotationMaterializationPolicy = intanceAnnotationPolicy;
return(entryPolicy);
}
public void ShortIntegrationTestToValidateEntryShouldBeRead()
{
var odataEntry = new ODataResource()
{
Id = new Uri("http://services.odata.org/OData/OData.svc/Customers(0)")
};
odataEntry.Properties = new ODataProperty[] { new ODataProperty()
{
Name = "ID", Value = 0
}, new ODataProperty()
{
Name = "Description", Value = "Simple Stuff"
} };
var clientEdmModel = new ClientEdmModel(ODataProtocolVersion.V4);
var context = new DataServiceContext();
MaterializerEntry.CreateEntry(odataEntry, ODataFormat.Json, true, clientEdmModel);
var materializerContext = new TestMaterializerContext()
{
Model = clientEdmModel, Context = context
};
var adapter = new EntityTrackingAdapter(new TestEntityTracker(), MergeOption.OverwriteChanges, clientEdmModel, context);
QueryComponents components = new QueryComponents(new Uri("http://foo.com/Service"), new Version(4, 0), typeof(Customer), null, new Dictionary <Expression, Expression>());
var entriesMaterializer = new ODataEntriesEntityMaterializer(new ODataResource[] { odataEntry }, materializerContext, adapter, components, typeof(Customer), null, ODataFormat.Json);
var customersRead = new List <Customer>();
// This line will call ODataEntityMaterializer.ReadImplementation() which will reconstruct the entity, and will get non-public setter called.
while (entriesMaterializer.Read())
{
customersRead.Add(entriesMaterializer.CurrentValue as Customer);
}
customersRead.Should().HaveCount(1);
customersRead[0].ID.Should().Be(0);
customersRead[0].Description.Should().Be("Simple Stuff");
}
/// <summary>
/// Creates an <see cref="ODataMaterializer"/> for a response.
/// </summary>
/// <param name="responseMessage">The response message.</param>
/// <param name="responseInfo">The response context.</param>
/// <param name="materializerType">The type to materialize.</param>
/// <param name="queryComponents">The query components for the request.</param>
/// <param name="plan">The projection plan.</param>
/// <param name="payloadKind">expected payload kind.</param>
/// <returns>A materializer specialized for the given response.</returns>
public static ODataMaterializer CreateMaterializerForMessage(
IODataResponseMessage responseMessage,
ResponseInfo responseInfo,
Type materializerType,
QueryComponents queryComponents,
ProjectionPlan plan,
ODataPayloadKind payloadKind)
{
ODataMessageReader messageReader = CreateODataMessageReader(responseMessage, responseInfo, ref payloadKind);
ODataMaterializer result;
IEdmType edmType = null;
try
{
ODataMaterializerContext materializerContext = new ODataMaterializerContext(responseInfo);
// Since in V1/V2, astoria client allowed Execute<object> and depended on the typeresolver or the wire type name
// to get the clr type to materialize. Hence if we see the materializer type as object, we should set the edmtype
// to null, since there is no expected type.
if (materializerType != typeof(System.Object))
{
edmType = responseInfo.TypeResolver.ResolveExpectedTypeForReading(materializerType);
}
if (payloadKind == ODataPayloadKind.Property && edmType != null)
{
if (edmType.TypeKind.IsStructured())
{
payloadKind = ODataPayloadKind.Resource;
}
else if (edmType.TypeKind == EdmTypeKind.Collection && (edmType as IEdmCollectionType).ElementType.IsStructured())
{
payloadKind = ODataPayloadKind.ResourceSet;
}
}
if (payloadKind == ODataPayloadKind.Resource || payloadKind == ODataPayloadKind.ResourceSet)
{
// In V1/V2, we allowed System.Object type to be allowed to pass to ExecuteQuery.
// Hence we need to explicitly check for System.Object to allow this
if (edmType != null && !edmType.TypeKind.IsStructured())
{
throw DSClient.Error.InvalidOperation(DSClient.Strings.AtomMaterializer_InvalidNonEntityType(materializerType.FullName));
}
ODataReaderWrapper reader = ODataReaderWrapper.Create(messageReader, payloadKind, edmType, responseInfo.ResponsePipeline);
EntityTrackingAdapter entityTrackingAdapter = new EntityTrackingAdapter(responseInfo.EntityTracker, responseInfo.MergeOption, responseInfo.Model, responseInfo.Context);
LoadPropertyResponseInfo loadPropertyResponseInfo = responseInfo as LoadPropertyResponseInfo;
if (loadPropertyResponseInfo != null)
{
result = new ODataLoadNavigationPropertyMaterializer(
messageReader,
reader,
materializerContext,
entityTrackingAdapter,
queryComponents,
materializerType,
plan,
loadPropertyResponseInfo);
}
else
{
result = new ODataReaderEntityMaterializer(
messageReader,
reader,
materializerContext,
entityTrackingAdapter,
queryComponents,
materializerType,
plan);
}
}
else
{
switch (payloadKind)
{
case ODataPayloadKind.Value:
result = new ODataValueMaterializer(messageReader, materializerContext, materializerType, queryComponents.SingleResult);
break;
case ODataPayloadKind.Collection:
result = new ODataCollectionMaterializer(messageReader, materializerContext, materializerType, queryComponents.SingleResult);
break;
case ODataPayloadKind.Property:
case ODataPayloadKind.IndividualProperty:
// Top level properties cannot be of entity type.
if (edmType != null && (edmType.TypeKind == EdmTypeKind.Entity || edmType.TypeKind == EdmTypeKind.Complex))
{
throw DSClient.Error.InvalidOperation(DSClient.Strings.AtomMaterializer_InvalidEntityType(materializerType.FullName));
}
result = new ODataPropertyMaterializer(messageReader, materializerContext, materializerType, queryComponents.SingleResult);
break;
case ODataPayloadKind.EntityReferenceLinks:
case ODataPayloadKind.EntityReferenceLink:
result = new ODataLinksMaterializer(messageReader, materializerContext, materializerType, queryComponents.SingleResult);
break;
case ODataPayloadKind.Error:
var odataError = messageReader.ReadError();
throw new ODataErrorException(odataError.Message, odataError);
default:
throw DSClient.Error.InvalidOperation(DSClient.Strings.AtomMaterializer_InvalidResponsePayload(XmlConstants.DataWebNamespace));
}
}
return(result);
}
catch (Exception ex)
{
if (CommonUtil.IsCatchableExceptionType(ex))
{
// Dispose the message reader in all error scenarios.
messageReader.Dispose();
}
throw;
}
}
public void MaterializeEntityShouldWork()
{
var odataEntry = new OData.ODataResource()
{
Id = new Uri("http://www.odata.org/service.svc/entitySet(1)")
};
odataEntry.Properties = new OData.ODataProperty[]
{
new OData.ODataProperty {
Name = "keyProp", Value = 1
},
new OData.ODataProperty {
Name = "colorProp", Value = new OData.ODataEnumValue("blue")
},
new OData.ODataProperty {
Name = "primitiveCollection",
Value = new OData.ODataCollectionValue
{
TypeName = "Edm.Int32",
Items = new List <object> {
1, 2, 3
}
}
},
new OData.ODataProperty {
Name = "enumCollection",
Value = new OData.ODataCollectionValue
{
TypeName = "color",
Items = new List <OData.ODataEnumValue> {
new OData.ODataEnumValue("white"), new OData.ODataEnumValue("blue")
}
}
}
};
var complexP = new OData.ODataNestedResourceInfo()
{
Name = "complexProp",
IsCollection = false
};
var complexResource = new OData.ODataResource
{
Properties = new OData.ODataProperty[]
{
new OData.ODataProperty {
Name = "age", Value = 11
},
new OData.ODataProperty {
Name = "name", Value = "June"
}
}
};
var complexColP = new OData.ODataNestedResourceInfo
{
Name = "complexCollection",
IsCollection = true
};
var complexColResourceSet = new OData.ODataResourceSet();
var items = new List <OData.ODataResource>
{
new OData.ODataResource
{
Properties = new OData.ODataProperty[]
{
new OData.ODataProperty {
Name = "name", Value = "Aug"
},
new OData.ODataProperty {
Name = "age", Value = 8
},
new OData.ODataProperty {
Name = "color", Value = new OData.ODataEnumValue("white")
}
}
},
new OData.ODataResource
{
Properties = new OData.ODataProperty[]
{
new OData.ODataProperty {
Name = "name", Value = "Sep"
},
new OData.ODataProperty {
Name = "age", Value = 9
},
new OData.ODataProperty {
Name = "color", Value = new OData.ODataEnumValue("blue")
}
}
}
};
var clientEdmModel = new ClientEdmModel(ODataProtocolVersion.V4);
var context = new DataServiceContext();
var materializerEntry = MaterializerEntry.CreateEntry(odataEntry, OData.ODataFormat.Json, true, clientEdmModel);
MaterializerNavigationLink.CreateLink(complexP, MaterializerEntry.CreateEntry(complexResource, OData.ODataFormat.Json, true, clientEdmModel));
MaterializerFeed.CreateFeed(complexColResourceSet, items);
MaterializerNavigationLink.CreateLink(complexColP, complexColResourceSet);
var materializerContext = new TestMaterializerContext()
{
Model = clientEdmModel, Context = context
};
var adapter = new EntityTrackingAdapter(new TestEntityTracker(), MergeOption.OverwriteChanges, clientEdmModel, context);
QueryComponents components = new QueryComponents(new Uri("http://foo.com/Service"), new Version(4, 0), typeof(EntityType), null, new Dictionary <Expression, Expression>());
var entriesMaterializer = new ODataEntriesEntityMaterializer(new OData.ODataResource[] { odataEntry }, materializerContext, adapter, components, typeof(EntityType), null, OData.ODataFormat.Json);
var customersRead = new List <EntityType>();
while (entriesMaterializer.Read())
{
customersRead.Add(entriesMaterializer.CurrentValue as EntityType);
}
customersRead.Should().HaveCount(1);
customersRead[0].KeyProp.Should().Be(1);
customersRead[0].ComplexProp.Should().Equals(new ComplexType {
Age = 11, Name = "June"
});
customersRead[0].ColorProp.Should().Equals(Color.Blue);
customersRead[0].PrimitiveCollection.Should().Equals(new List <int> {
1, 2, 3
});
ComplexType complex1 = new ComplexType {
Name = "Aug", Age = 8, Color = Color.White
};
ComplexType complex2 = new ComplexType {
Name = "Sep", Age = 9, Color = Color.Blue
};
customersRead[0].ComplexCollection.Should().Equals(new List <ComplexType> {
complex1, complex2
});
customersRead[0].EnumCollection.Should().Equals(new List <Color> {
Color.White, Color.Blue
});
}
