internal EntityDescriptor(String identity, Uri selfLink, Uri editLink, object entity, EntityDescriptor parentEntity, string parentProperty, string entitySetName, string etag, EntityStates state)
: base(state)
{
Debug.Assert(entity != null, "entity is null");
Debug.Assert((parentEntity == null && parentProperty == null) || (parentEntity != null && parentProperty != null), "When parentEntity is specified, must also specify parentProperyName");
#if DEBUG
if (state == EntityStates.Added)
{
Debug.Assert(identity == null && selfLink == null && editLink == null && etag == null, "For objects in added state, identity, self-link, edit-link and etag must be null");
Debug.Assert((!String.IsNullOrEmpty(entitySetName) && parentEntity == null && String.IsNullOrEmpty(parentProperty)) ||
(String.IsNullOrEmpty(entitySetName) && parentEntity != null && !String.IsNullOrEmpty(parentProperty)),
"For entities in added state, entity set name or the insert path must be specified");
}
else
{
Debug.Assert(identity != null, "For objects in non-added state, identity must never be null");
Debug.Assert(String.IsNullOrEmpty(entitySetName) && String.IsNullOrEmpty(parentProperty) && parentEntity == null, "For non-added entities, the entity set name and the insert path must be null");
}
#endif
this.identity = identity;
this.selfLink = selfLink;
this.editLink = editLink;
this.parentDescriptor = parentEntity;
this.parentProperty = parentProperty;
this.entity = entity;
this.etag = etag;
this.entitySetName = entitySetName;
}
private MaterializerEntry(ODataEntry entry, DataServiceProtocolVersion maxProtocolVersion)
{
this.entry = entry;
this.entityDescriptor = new System.Data.Services.Client.EntityDescriptor(maxProtocolVersion);
SerializationTypeNameAnnotation annotation = entry.GetAnnotation<SerializationTypeNameAnnotation>();
this.entityDescriptor.ServerTypeName = (annotation != null) ? annotation.TypeName : (this.entityDescriptor.ServerTypeName = this.Entry.TypeName);
}
private MaterializerEntry(ODataEntry entry, DataServiceProtocolVersion maxProtocolVersion)
{
this.entry = entry;
this.entityDescriptor = new System.Data.Services.Client.EntityDescriptor(maxProtocolVersion);
SerializationTypeNameAnnotation annotation = entry.GetAnnotation <SerializationTypeNameAnnotation>();
this.entityDescriptor.ServerTypeName = (annotation != null) ? annotation.TypeName : (this.entityDescriptor.ServerTypeName = this.Entry.TypeName);
}
internal void AddEntityDescriptor(EntityDescriptor descriptor)
{
try
{
this.entityDescriptors.Add(descriptor.Entity, descriptor);
}
catch (ArgumentException)
{
throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Context_EntityAlreadyContained);
}
}
internal EntityDescriptor(string identity, Uri selfLink, Uri editLink, Uri addToUri, object entity, EntityDescriptor parentEntity, string parentProperty, string etag, EntityStates state, DataServiceProtocolVersion maxProtocolVersion) : base(state)
{
this.identity = identity;
this.selfLink = selfLink;
this.editLink = editLink;
this.addToUri = addToUri;
this.parentDescriptor = parentEntity;
this.parentProperty = parentProperty;
this.MaxProtocolVersion = maxProtocolVersion;
this.Entity = entity;
this.etag = etag;
}
internal string GetServerTypeName(EntityDescriptor descriptor)
{
if (this.HasResolveName)
{
Type type = descriptor.Entity.GetType();
if (this.IsUserSuppliedResolver)
{
return (this.ResolveNameFromType(type) ?? descriptor.GetLatestServerTypeName());
}
return (descriptor.GetLatestServerTypeName() ?? this.ResolveNameFromType(type));
}
return descriptor.GetLatestServerTypeName();
}
internal void AttachIdentity(EntityDescriptor entityDescriptorFromMaterializer, MergeOption metadataMergeOption)
{
this.EnsureIdentityToResource();
EntityDescriptor descriptor = this.entityDescriptors[entityDescriptorFromMaterializer.Entity];
this.ValidateDuplicateIdentity(entityDescriptorFromMaterializer.Identity, descriptor);
this.DetachResourceIdentity(descriptor);
if (descriptor.IsDeepInsert)
{
LinkDescriptor descriptor2 = this.bindings[descriptor.GetRelatedEnd(this.maxProtocolVersion)];
descriptor2.State = EntityStates.Unchanged;
}
descriptor.Identity = entityDescriptorFromMaterializer.Identity;
AtomMaterializerLog.MergeEntityDescriptorInfo(descriptor, entityDescriptorFromMaterializer, true, metadataMergeOption);
descriptor.State = EntityStates.Unchanged;
this.identityToDescriptor[entityDescriptorFromMaterializer.Identity] = descriptor;
}
/// <summary>
/// Applies the media entry information (if any) to the specified
/// <paramref name="descriptor"/>.
/// </summary>
/// <param name="entry">Entry with (potential) media entry information to apply.</param>
/// <param name="descriptor">Descriptor to update.</param>
private void ApplyMediaEntryInformation(AtomEntry entry, EntityDescriptor descriptor)
{
Debug.Assert(entry != null, "entry != null");
Debug.Assert(descriptor != null, "descriptor != null");
if (entry.MediaEditUri != null || entry.MediaContentUri != null)
{
//
if (entry.MediaEditUri != null)
{
descriptor.EditStreamUri = new Uri(this.context.BaseUriWithSlash, entry.MediaEditUri);
}
if (entry.MediaContentUri != null)
{
descriptor.ReadStreamUri = new Uri(this.context.BaseUriWithSlash, entry.MediaContentUri);
}
descriptor.StreamETag = entry.StreamETagText;
}
}
protected abstract MaterializeAtom GetMaterializer(EntityDescriptor entityDescriptor, ResponseInfo responseInfo);
internal void WriteNavigationLink(EntityDescriptor entityDescriptor, IEnumerable<LinkDescriptor> relatedLinks, ODataWriter odataWriter)
{
ClientTypeAnnotation clientTypeAnnotation = null;
foreach (LinkDescriptor descriptor in relatedLinks)
{
descriptor.ContentGeneratedForSave = true;
if (clientTypeAnnotation == null)
{
ClientEdmModel model = ClientEdmModel.GetModel(this.requestInfo.MaxProtocolVersion);
clientTypeAnnotation = model.GetClientTypeAnnotation(model.GetOrCreateEdmType(entityDescriptor.Entity.GetType()));
}
ODataNavigationLink navigationLink = new ODataNavigationLink {
Url = this.requestInfo.EntityTracker.GetEntityDescriptor(descriptor.Target).GetLatestEditLink(),
IsCollection = new bool?(clientTypeAnnotation.GetProperty(descriptor.SourceProperty, false).IsEntityCollection),
Name = descriptor.SourceProperty
};
odataWriter.WriteStart(navigationLink);
ODataEntityReferenceLink entityReferenceLink = new ODataEntityReferenceLink {
Url = navigationLink.Url
};
odataWriter.WriteEntityReferenceLink(entityReferenceLink);
odataWriter.WriteEnd();
}
}
internal void WriteEntry(EntityDescriptor entityDescriptor, IEnumerable<LinkDescriptor> relatedLinks, ODataRequestMessageWrapper requestMessage)
{
ClientEdmModel model = ClientEdmModel.GetModel(this.requestInfo.MaxProtocolVersion);
ClientTypeAnnotation clientTypeAnnotation = model.GetClientTypeAnnotation(model.GetOrCreateEdmType(entityDescriptor.Entity.GetType()));
using (ODataMessageWriter writer = CreateMessageWriter(requestMessage, this.requestInfo))
{
ODataWriter odataWriter = writer.CreateODataEntryWriter();
ODataEntry entry = new ODataEntry();
if (this.requestInfo.HasWritingEventHandlers)
{
entry.SetAnnotation<WritingEntityInfo>(new WritingEntityInfo(entityDescriptor.Entity, this.requestInfo));
}
string serverTypeName = this.requestInfo.GetServerTypeName(entityDescriptor);
if (clientTypeAnnotation.ElementTypeName != serverTypeName)
{
SerializationTypeNameAnnotation annotation = new SerializationTypeNameAnnotation {
TypeName = serverTypeName
};
entry.SetAnnotation<SerializationTypeNameAnnotation>(annotation);
}
entry.TypeName = clientTypeAnnotation.ElementTypeName;
if (EntityStates.Modified == entityDescriptor.State)
{
entry.Id = entityDescriptor.GetLatestIdentity();
}
if (entityDescriptor.IsMediaLinkEntry || clientTypeAnnotation.IsMediaLinkEntry)
{
entry.MediaResource = new ODataStreamReferenceValue();
}
odataWriter.WriteStart(entry);
if (EntityStates.Added == entityDescriptor.State)
{
this.WriteNavigationLink(entityDescriptor, relatedLinks, odataWriter);
}
entry.Properties = this.PopulateProperties(clientTypeAnnotation, entityDescriptor.Entity, null);
odataWriter.WriteEnd();
}
}
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 ResponseInfo CreateResponseInfo(EntityDescriptor entityDescriptor)
{
MergeOption overwriteChanges = MergeOption.OverwriteChanges;
if (entityDescriptor.StreamState == EntityStates.Added)
{
overwriteChanges = MergeOption.PreserveChanges;
}
return this.RequestInfo.GetDeserializationInfo(new MergeOption?(overwriteChanges));
}
internal static EntityDescriptor RestoreState(EntityDescriptorState state)
{
SaveStreamState saveStreamState = state.SaveStream;
DataServiceContext.DataServiceSaveStream saveStream = (saveStreamState != null)
? DataServiceContext.DataServiceSaveStream.RestoreState(saveStreamState)
: null;
var entityDescriptor = new EntityDescriptor(
state.Identity,
state.SelfLink,
state.EditLink,
state.Entity,
null,
null,
state.EntitySetName,
state.Etag,
state.State)
{
editMediaLink = state.EditMediaLink,
readStreamLink = state.ReadStreamLink,
saveStream = saveStream,
selfLink = state.SelfLink,
serverTypeName = state.ServerTypeName,
streamETag = state.StreamETag,
streamState = state.StreamState,
};
entityDescriptor.RestoreState((DescriptorState)state);
return entityDescriptor;
}
private void HandleResponsePost(EntityDescriptor entityDescriptor, string etag)
{
try
{
if ((EntityStates.Added != entityDescriptor.State) && (EntityStates.Added != entityDescriptor.StreamState))
{
System.Data.Services.Client.Error.ThrowBatchUnexpectedContent(InternalError.EntityNotAddedState);
}
if (this.ProcessResponsePayload)
{
this.MaterializeResponse(entityDescriptor, this.CreateResponseInfo(entityDescriptor), etag);
}
else
{
entityDescriptor.ETag = etag;
entityDescriptor.State = EntityStates.Unchanged;
}
if (entityDescriptor.StreamState != EntityStates.Added)
{
foreach (LinkDescriptor descriptor in this.RelatedLinks(entityDescriptor))
{
if (Util.IncludeLinkState(descriptor.SaveResultWasProcessed) || (descriptor.SaveResultWasProcessed == EntityStates.Added))
{
HandleResponsePost(descriptor);
}
}
}
}
finally
{
if (entityDescriptor.StreamState == EntityStates.Added)
{
entityDescriptor.State = EntityStates.Modified;
entityDescriptor.StreamState = EntityStates.Unchanged;
}
}
}
internal void DetachResourceIdentity(EntityDescriptor resource)
{
EntityDescriptor descriptor = null;
if (((resource.Identity != null) && this.identityToDescriptor.TryGetValue(resource.Identity, out descriptor)) && object.ReferenceEquals(descriptor, resource))
{
this.identityToDescriptor.Remove(resource.Identity);
}
}
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 override void ClearChanges()
{
this.transientEntityDescriptor = null;
this.CloseSaveStream();
}
protected IEnumerable<LinkDescriptor> RelatedLinks(EntityDescriptor entityDescriptor)
{
foreach (LinkDescriptor iteratorVariable0 in this.RequestInfo.EntityTracker.Links)
{
if ((iteratorVariable0.Source == entityDescriptor.Entity) && (iteratorVariable0.Target != null))
{
EntityDescriptor iteratorVariable1 = this.RequestInfo.EntityTracker.GetEntityDescriptor(iteratorVariable0.Target);
if ((Util.IncludeLinkState(iteratorVariable1.SaveResultWasProcessed) || ((iteratorVariable1.SaveResultWasProcessed == 0) && Util.IncludeLinkState(iteratorVariable1.State))) || (((iteratorVariable1.Identity != null) && (iteratorVariable1.ChangeOrder < entityDescriptor.ChangeOrder)) && (((iteratorVariable1.SaveResultWasProcessed == 0) && (EntityStates.Added == iteratorVariable1.State)) || (EntityStates.Added == iteratorVariable1.SaveResultWasProcessed))))
{
yield return iteratorVariable0;
}
}
}
}
internal void RestoreParentState(EntityDescriptor parentDescriptor, string parentProperty)
{
this.parentDescriptor = parentDescriptor;
this.parentProperty = parentProperty;
}
/// <summary>Applies all accumulated changes to the associated data context.</summary>
/// <remarks>The log should be cleared after this method successfully executed.</remarks>
internal void ApplyToContext()
{
Debug.Assert(
this.mergeOption != MergeOption.OverwriteChanges || this.foundEntriesWithMedia.Count == 0,
"mergeOption != MergeOption.OverwriteChanges || foundEntriesWithMedia.Count == 0 - we only use the 'entries-with-media' lookaside when we're not in overwrite mode, otherwise we track everything through identity stack");
if (!this.Tracking)
{
return;
}
foreach (KeyValuePair<String, AtomEntry> entity in this.identityStack)
{
AtomEntry entry = entity.Value;
if (entry.CreatedByMaterializer ||
entry.ResolvedObject == this.insertRefreshObject ||
entry.ShouldUpdateFromPayload)
{
// Create a new descriptor and try to attach, if one already exists, get the existing reference instead.
EntityDescriptor descriptor = new EntityDescriptor(entity.Key, entry.QueryLink, entry.EditLink, entry.ResolvedObject, null, null, null, entry.ETagText, EntityStates.Unchanged);
descriptor = this.context.InternalAttachEntityDescriptor(descriptor, false);
// we should always reset descriptor's state to Unchanged (old v1 behaviour)
descriptor.State = EntityStates.Unchanged;
this.ApplyMediaEntryInformation(entry, descriptor);
descriptor.ServerTypeName = entry.TypeName;
}
else
{
// Refresh the entity state indirectly by calling TryGetEntity.
EntityStates state;
this.context.TryGetEntity(entity.Key, entry.ETagText, this.mergeOption, out state);
}
}
// Regardless of the merge mode, media link information should
// always be applied to the context.
foreach (AtomEntry entry in this.foundEntriesWithMedia.Values)
{
Debug.Assert(entry.ResolvedObject != null, "entry.ResolvedObject != null -- otherwise it wasn't found");
EntityDescriptor descriptor = this.context.GetEntityDescriptor(entry.ResolvedObject);
this.ApplyMediaEntryInformation(entry, descriptor);
}
foreach (LinkDescriptor link in this.links)
{
if (EntityStates.Added == link.State)
{
// Added implies collection
if ((EntityStates.Deleted == this.context.GetEntityDescriptor(link.Target).State) ||
(EntityStates.Deleted == this.context.GetEntityDescriptor(link.Source).State))
{
this.context.DeleteLink(link.Source, link.SourceProperty, link.Target);
}
else
{
this.context.AttachLink(link.Source, link.SourceProperty, link.Target, this.mergeOption);
}
}
else if (EntityStates.Modified == link.State)
{
// Modified implies reference
object target = link.Target;
if (MergeOption.PreserveChanges == this.mergeOption)
{
LinkDescriptor end = this.context.GetLinks(link.Source, link.SourceProperty).FirstOrDefault();
if (null != end && null == end.Target)
{
// leave the SetLink(link.Source, link.SourceProperty, null)
continue;
}
if ((null != target) && (EntityStates.Deleted == this.context.GetEntityDescriptor(target).State) ||
(EntityStates.Deleted == this.context.GetEntityDescriptor(link.Source).State))
{
target = null;
}
}
this.context.AttachLink(link.Source, link.SourceProperty, target, this.mergeOption);
}
else
{
// detach link
Debug.Assert(EntityStates.Detached == link.State, "not detached link");
this.context.DetachLink(link.Source, link.SourceProperty, link.Target);
}
}
}
internal static void MergeEntityDescriptorInfo(EntityDescriptor trackedEntityDescriptor, EntityDescriptor entityDescriptorFromMaterializer, bool mergeInfo, MergeOption mergeOption)
{
if (!object.ReferenceEquals(trackedEntityDescriptor, entityDescriptorFromMaterializer))
{
if ((entityDescriptorFromMaterializer.ETag != null) && (mergeOption != MergeOption.AppendOnly))
{
trackedEntityDescriptor.ETag = entityDescriptorFromMaterializer.ETag;
}
if (mergeInfo)
{
if (entityDescriptorFromMaterializer.SelfLink != null)
{
trackedEntityDescriptor.SelfLink = entityDescriptorFromMaterializer.SelfLink;
}
if (entityDescriptorFromMaterializer.EditLink != null)
{
trackedEntityDescriptor.EditLink = entityDescriptorFromMaterializer.EditLink;
}
foreach (LinkInfo info in entityDescriptorFromMaterializer.LinkInfos)
{
trackedEntityDescriptor.MergeLinkInfo(info);
}
foreach (StreamDescriptor descriptor in entityDescriptorFromMaterializer.StreamDescriptors)
{
trackedEntityDescriptor.MergeStreamDescriptor(descriptor);
}
trackedEntityDescriptor.ServerTypeName = entityDescriptorFromMaterializer.ServerTypeName;
}
if (entityDescriptorFromMaterializer.ReadStreamUri != null)
{
trackedEntityDescriptor.ReadStreamUri = entityDescriptorFromMaterializer.ReadStreamUri;
}
if (entityDescriptorFromMaterializer.EditStreamUri != null)
{
trackedEntityDescriptor.EditStreamUri = entityDescriptorFromMaterializer.EditStreamUri;
}
if ((entityDescriptorFromMaterializer.ReadStreamUri != null) || (entityDescriptorFromMaterializer.EditStreamUri != null))
{
trackedEntityDescriptor.StreamETag = entityDescriptorFromMaterializer.StreamETag;
}
}
}
internal void ApplyToContext()
{
Debug.Assert(
this.mergeOption != MergeOption.OverwriteChanges || this.foundEntriesWithMedia.Count == 0,
"mergeOption != MergeOption.OverwriteChanges || foundEntriesWithMedia.Count == 0 - we only use the 'entries-with-media' lookaside when we're not in overwrite mode, otherwise we track everything through identity stack");
if (!this.Tracking)
{
return;
}
foreach (KeyValuePair<String, AtomEntry> entity in this.identityStack)
{
AtomEntry entry = entity.Value;
if (entry.CreatedByMaterializer ||
entry.ResolvedObject == this.insertRefreshObject ||
entry.ShouldUpdateFromPayload)
{
EntityDescriptor descriptor = new EntityDescriptor(entity.Key, entry.QueryLink, entry.EditLink, entry.ResolvedObject, null, null, null, entry.ETagText, EntityStates.Unchanged);
descriptor = this.context.InternalAttachEntityDescriptor(descriptor, false);
descriptor.State = EntityStates.Unchanged;
this.ApplyMediaEntryInformation(entry, descriptor);
descriptor.ServerTypeName = entry.TypeName;
}
else
{
EntityStates state;
this.context.TryGetEntity(entity.Key, entry.ETagText, this.mergeOption, out state);
}
}
foreach (AtomEntry entry in this.foundEntriesWithMedia.Values)
{
Debug.Assert(entry.ResolvedObject != null, "entry.ResolvedObject != null -- otherwise it wasn't found");
EntityDescriptor descriptor = this.context.GetEntityDescriptor(entry.ResolvedObject);
this.ApplyMediaEntryInformation(entry, descriptor);
}
foreach (LinkDescriptor link in this.links)
{
if (EntityStates.Added == link.State)
{
if ((EntityStates.Deleted == this.context.GetEntityDescriptor(link.Target).State) ||
(EntityStates.Deleted == this.context.GetEntityDescriptor(link.Source).State))
{
this.context.DeleteLink(link.Source, link.SourceProperty, link.Target);
}
else
{
this.context.AttachLink(link.Source, link.SourceProperty, link.Target, this.mergeOption);
}
}
else if (EntityStates.Modified == link.State)
{
object target = link.Target;
if (MergeOption.PreserveChanges == this.mergeOption)
{
LinkDescriptor end = this.context.GetLinks(link.Source, link.SourceProperty).FirstOrDefault();
if (null != end && null == end.Target)
{
continue;
}
if ((null != target) && (EntityStates.Deleted == this.context.GetEntityDescriptor(target).State) ||
(EntityStates.Deleted == this.context.GetEntityDescriptor(link.Source).State))
{
target = null;
}
}
this.context.AttachLink(link.Source, link.SourceProperty, target, this.mergeOption);
}
else
{
Debug.Assert(EntityStates.Detached == link.State, "not detached link");
this.context.DetachLink(link.Source, link.SourceProperty, link.Target);
}
}
}
internal bool DetachResource(EntityDescriptor resource)
{
foreach (LinkDescriptor descriptor in this.bindings.Values.Where<LinkDescriptor>(new Func<LinkDescriptor, bool>(resource.IsRelatedEntity)).ToList<LinkDescriptor>())
{
this.DetachExistingLink(descriptor, (descriptor.Target == resource.Entity) && (resource.State == EntityStates.Added));
}
resource.ChangeOrder = uint.MaxValue;
resource.State = EntityStates.Detached;
this.entityDescriptors.Remove(resource.Entity);
this.DetachResourceIdentity(resource);
return true;
}
private ODataRequestMessageWrapper CheckAndProcessMediaEntryPost(EntityDescriptor entityDescriptor)
{
ClientEdmModel model = ClientEdmModel.GetModel(base.RequestInfo.MaxProtocolVersion);
ClientTypeAnnotation clientTypeAnnotation = model.GetClientTypeAnnotation(model.GetOrCreateEdmType(entityDescriptor.Entity.GetType()));
if (!clientTypeAnnotation.IsMediaLinkEntry && !entityDescriptor.IsMediaLinkEntry)
{
return null;
}
if ((clientTypeAnnotation.MediaDataMember == null) && (entityDescriptor.SaveStream == null))
{
throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Context_MLEWithoutSaveStream(clientTypeAnnotation.ElementTypeName));
}
ODataRequestMessageWrapper mediaResourceRequest = null;
if (clientTypeAnnotation.MediaDataMember != null)
{
string contentType = null;
int length = 0;
if (clientTypeAnnotation.MediaDataMember.MimeTypeProperty == null)
{
contentType = "application/octet-stream";
}
else
{
object obj2 = clientTypeAnnotation.MediaDataMember.MimeTypeProperty.GetValue(entityDescriptor.Entity);
string str2 = (obj2 != null) ? obj2.ToString() : null;
if (string.IsNullOrEmpty(str2))
{
throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Context_NoContentTypeForMediaLink(clientTypeAnnotation.ElementTypeName, clientTypeAnnotation.MediaDataMember.MimeTypeProperty.PropertyName));
}
contentType = str2;
}
object propertyValue = clientTypeAnnotation.MediaDataMember.GetValue(entityDescriptor.Entity);
if (propertyValue == null)
{
base.mediaResourceRequestStream = null;
}
else
{
byte[] bytes = propertyValue as byte[];
if (bytes == null)
{
string str3;
Encoding encoding;
HttpProcessUtility.ReadContentType(contentType, out str3, out encoding);
if (encoding == null)
{
encoding = Encoding.UTF8;
contentType = contentType + ";charset=UTF-8";
}
bytes = encoding.GetBytes(ClientConvert.ToString(propertyValue));
}
length = bytes.Length;
base.mediaResourceRequestStream = new MemoryStream(bytes, 0, bytes.Length, false, true);
}
mediaResourceRequest = this.CreateMediaResourceRequest(entityDescriptor.GetResourceUri(base.RequestInfo.BaseUriResolver, false), "POST", Util.DataServiceVersion1, clientTypeAnnotation.MediaDataMember == null, true);
mediaResourceRequest.SetHeader("Content-Length", length.ToString(CultureInfo.InvariantCulture));
mediaResourceRequest.SetHeader("Content-Type", contentType);
mediaResourceRequest.AddHeadersToReset("Content-Length");
mediaResourceRequest.AddHeadersToReset("Content-Type");
}
else
{
mediaResourceRequest = this.CreateMediaResourceRequest(entityDescriptor.GetResourceUri(base.RequestInfo.BaseUriResolver, false), "POST", Util.DataServiceVersion1, clientTypeAnnotation.MediaDataMember == null, true);
this.SetupMediaResourceRequest(mediaResourceRequest, entityDescriptor.SaveStream, null);
}
entityDescriptor.State = EntityStates.Modified;
return mediaResourceRequest;
}
internal EntityDescriptor InternalAttachEntityDescriptor(EntityDescriptor entityDescriptorFromMaterializer, bool failIfDuplicated)
{
EntityDescriptor descriptor;
EntityDescriptor descriptor2;
this.EnsureIdentityToResource();
this.entityDescriptors.TryGetValue(entityDescriptorFromMaterializer.Entity, out descriptor);
this.identityToDescriptor.TryGetValue(entityDescriptorFromMaterializer.Identity, out descriptor2);
if (failIfDuplicated && (descriptor != null))
{
throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Context_EntityAlreadyContained);
}
if (descriptor != descriptor2)
{
throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Context_DifferentEntityAlreadyContained);
}
if (descriptor == null)
{
descriptor = entityDescriptorFromMaterializer;
this.IncrementChange(entityDescriptorFromMaterializer);
this.entityDescriptors.Add(entityDescriptorFromMaterializer.Entity, entityDescriptorFromMaterializer);
this.identityToDescriptor.Add(entityDescriptorFromMaterializer.Identity, entityDescriptorFromMaterializer);
}
return descriptor;
}
private ODataRequestMessageWrapper CheckAndProcessMediaEntryPut(EntityDescriptor entityDescriptor)
{
if (entityDescriptor.SaveStream == null)
{
return null;
}
Uri latestEditStreamUri = entityDescriptor.GetLatestEditStreamUri();
if (latestEditStreamUri == null)
{
throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Context_SetSaveStreamWithoutEditMediaLink);
}
ODataRequestMessageWrapper mediaResourceRequest = this.CreateMediaResourceRequest(latestEditStreamUri, "PUT", Util.DataServiceVersion1, true, false);
this.SetupMediaResourceRequest(mediaResourceRequest, entityDescriptor.SaveStream, entityDescriptor.GetLatestStreamETag());
return mediaResourceRequest;
}
private void ValidateDuplicateIdentity(string identity, EntityDescriptor descriptor)
{
EntityDescriptor descriptor2;
if ((this.identityToDescriptor.TryGetValue(identity, out descriptor2) && (descriptor != descriptor2)) && ((descriptor2.State != EntityStates.Deleted) && (descriptor2.State != EntityStates.Detached)))
{
throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Context_DifferentEntityAlreadyContained);
}
}
protected override MaterializeAtom GetMaterializer(EntityDescriptor entityDescriptor, ResponseInfo responseInfo)
{
return new MaterializeAtom(responseInfo, new ODataEntry[] { this.cachedResponse.Entry }, entityDescriptor.Entity.GetType());
}
private MaterializeAtom ReadPropertyFromAtom(EntityDescriptor box, ClientPropertyAnnotation property)
{
MaterializeAtom atom2;
DataServiceContext source = (DataServiceContext) base.Source;
bool applyingChanges = source.ApplyingChanges;
try
{
source.ApplyingChanges = true;
bool flag2 = EntityStates.Deleted == box.State;
bool instanceCreated = false;
object instance = null;
if (property.IsEntityCollection)
{
instance = this.GetCollectionInstance(property, out instanceCreated);
}
Type type = property.IsEntityCollection ? property.EntityCollectionItemType : property.NullablePropertyType;
IList results = (IList) Activator.CreateInstance(typeof(List<>).MakeGenericType(new Type[] { type }));
DataServiceQueryContinuation continuation = null;
using (MaterializeAtom atom = base.GetMaterializer(this.plan))
{
bool flag4 = property.EdmProperty.PropertyKind == EdmPropertyKind.Navigation;
int num = 0;
foreach (object obj3 in atom)
{
if (property.IsEntityCollection)
{
property.SetValue(instance, obj3, this.propertyName, true);
results.Add(obj3);
}
else if (property.IsPrimitiveOrComplexCollection)
{
object obj4 = property.GetValue(this.entity);
if (obj4 == null)
{
obj4 = Activator.CreateInstance(obj3.GetType());
property.SetValue(this.entity, obj4, this.propertyName, false);
}
else
{
property.ClearBackingICollectionInstance(obj4);
}
foreach (object obj5 in (IEnumerable) obj3)
{
property.AddValueToBackingICollectionInstance(obj4, obj5);
}
results.Add(obj4);
}
else
{
property.SetValue(this.entity, obj3, this.propertyName, false);
results.Add(obj3);
}
num++;
if (((obj3 != null) && (MergeOption.NoTracking != atom.MergeOptionValue)) && flag4)
{
if (flag2)
{
source.DeleteLink(this.entity, this.propertyName, obj3);
}
else
{
source.AttachLink(this.entity, this.propertyName, obj3, atom.MergeOptionValue);
}
}
}
continuation = atom.GetContinuation(null);
Util.SetNextLinkForCollection(property.IsEntityCollection ? instance : this.entity, continuation);
}
if (instanceCreated)
{
property.SetValue(this.entity, instance, this.propertyName, false);
}
atom2 = MaterializeAtom.CreateWrapper(source, results, continuation);
}
finally
{
source.ApplyingChanges = applyingChanges;
}
return atom2;
}
protected Uri CreateRequestUri(EntityDescriptor sourceResource, LinkDescriptor binding)
{
Uri uri;
LinkInfo linkInfo = null;
if (sourceResource.TryGetLinkInfo(binding.SourceProperty, out linkInfo) && ((uri = linkInfo.AssociationLink) != null))
{
if (binding.IsSourcePropertyCollection && (EntityStates.Deleted == binding.State))
{
EntityDescriptor entityDescriptor = this.RequestInfo.EntityTracker.GetEntityDescriptor(binding.Target);
uri = DataServiceContext.AppendKeysToUri(uri.AbsoluteUri, entityDescriptor.Entity, UriKind.Absolute, this.RequestInfo.MaxProtocolVersion);
}
return uri;
}
return Util.CreateUri(sourceResource.GetResourceUri(this.RequestInfo.BaseUriResolver, false), this.CreateRequestRelativeUri(binding));
}
