private MaterializeAtom ReadPropertyFromRawData(ClientPropertyAnnotation property)
{
MaterializeAtom atom;
DataServiceContext source = (DataServiceContext)base.Source;
bool applyingChanges = source.ApplyingChanges;
try
{
source.ApplyingChanges = true;
string mime = null;
Encoding encoding = null;
Type type = property.EntityCollectionItemType ?? property.NullablePropertyType;
IList results = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(new Type[] { type }));
HttpProcessUtility.ReadContentType(base.ContentType, out mime, out encoding);
using (Stream stream = base.GetResponseStream())
{
if (property.PropertyType == typeof(byte[]))
{
int contentLength = (int)base.ContentLength;
byte[] buffer = null;
if (contentLength >= 0)
{
buffer = ReadByteArrayWithContentLength(stream, contentLength);
}
else
{
buffer = ReadByteArrayChunked(stream);
}
results.Add(buffer);
property.SetValue(this.entity, buffer, this.propertyName, false);
}
else
{
StreamReader reader = new StreamReader(stream, encoding);
object obj2 = (property.PropertyType == typeof(string)) ? reader.ReadToEnd() : ClientConvert.ChangeType(reader.ReadToEnd(), property.PropertyType);
results.Add(obj2);
property.SetValue(this.entity, obj2, this.propertyName, false);
}
}
if (property.MimeTypeProperty != null)
{
property.MimeTypeProperty.SetValue(this.entity, mime, null, false);
}
atom = MaterializeAtom.CreateWrapper(source, results);
}
finally
{
source.ApplyingChanges = applyingChanges;
}
return(atom);
}
internal static MaterializeAtom Materialize(DataServiceContext context, QueryComponents queryComponents, ProjectionPlan plan, string contentType, Stream response)
{
Debug.Assert(null != queryComponents, "querycomponents");
string mime = null;
Encoding encoding = null;
if (!String.IsNullOrEmpty(contentType))
{
HttpProcessUtility.ReadContentType(contentType, out mime, out encoding);
}
if (String.Equals(mime, XmlConstants.MimeApplicationAtom, StringComparison.OrdinalIgnoreCase) ||
String.Equals(mime, XmlConstants.MimeApplicationXml, StringComparison.OrdinalIgnoreCase))
{
if (null != response)
{
XmlReader reader = XmlUtil.CreateXmlReader(response, encoding);
return new MaterializeAtom(context, reader, queryComponents, plan, context.MergeOption);
}
}
return MaterializeAtom.EmptyResults;
}
internal static bool GetBoundaryAndEncodingFromMultipartMixedContentType(string contentType, out string boundary, out Encoding encoding)
{
boundary = null;
encoding = null;
string mime;
KeyValuePair <string, string>[] parameters = HttpProcessUtility.ReadContentType(contentType, out mime, out encoding);
if (String.Equals(XmlConstants.MimeMultiPartMixed, mime, StringComparison.OrdinalIgnoreCase))
{
if (null != parameters)
{
foreach (KeyValuePair <string, string> parameter in parameters)
{
if (String.Equals(parameter.Key, XmlConstants.HttpMultipartBoundary, StringComparison.OrdinalIgnoreCase))
{
if (boundary != null)
{
boundary = null;
break;
}
boundary = parameter.Value;
}
}
}
if (String.IsNullOrEmpty(boundary))
{
throw Error.BatchStreamMissingBoundary();
}
}
return(null != boundary);
}
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);
}
private DataServiceResponse HandleBatchResponse()
{
Func <Stream> func2 = null;
Func <Stream> getResponseStream = null;
DataServiceResponse response3;
bool flag = true;
try
{
Version version;
ODataBatchReader reader;
if ((base.batchResponse == null) || (base.batchResponse.StatusCode == HttpStatusCode.NoContent))
{
throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Batch_ExpectedResponse(1));
}
if (func2 == null)
{
func2 = () => this.ResponseStream;
}
Func <Stream> func = func2;
BaseSaveResult.HandleResponse(base.RequestInfo, base.batchResponse.StatusCode, base.batchResponse.Headers["DataServiceVersion"], func, true, out version);
if (this.ResponseStream == null)
{
System.Data.Services.Client.Error.ThrowBatchExpectedResponse(InternalError.NullResponseStream);
}
HttpWebResponseMessage responseMessage = new HttpWebResponseMessage(base.batchResponse, func);
ODataMessageReaderSettings settings = WebUtil.CreateODataMessageReaderSettings(base.RequestInfo.GetDeserializationInfo(null), null, false);
this.batchMessageReader = new ODataMessageReader(responseMessage, settings);
try
{
reader = this.batchMessageReader.CreateODataBatchReader();
}
catch (Exception responseText)
{
string str;
Encoding encoding;
HttpProcessUtility.ReadContentType(base.batchResponse.ContentType, out str, out encoding);
if (string.Equals("text/plain", str))
{
if (getResponseStream == null)
{
getResponseStream = () => WebUtil.GetResponseStream(base.batchResponse, (DataServiceContext)base.Source);
}
responseText = BaseSaveResult.GetResponseText(getResponseStream, base.batchResponse.StatusCode);
}
throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Batch_ExpectedContentType(base.batchResponse.ContentType), responseText);
}
DataServiceResponse response = this.HandleBatchResponseInternal(reader);
flag = false;
response3 = response;
}
catch (DataServiceRequestException)
{
throw;
}
catch (InvalidOperationException exception3)
{
Dictionary <string, string> headers = WebUtil.WrapResponseHeaders(base.batchResponse);
int statusCode = (base.batchResponse == null) ? 500 : ((int)base.batchResponse.StatusCode);
DataServiceResponse response2 = new DataServiceResponse(headers, statusCode, null, this.IsBatch);
throw new DataServiceRequestException(System.Data.Services.Client.Strings.DataServiceException_GeneralError, exception3, response2);
}
finally
{
if (flag)
{
Util.Dispose <ODataMessageReader>(ref this.batchMessageReader);
}
}
return(response3);
}