internal void Execute()
{
try
{
#if false
if ((null != requestContent) && (0 < requestContent.Length))
{
using (System.IO.Stream stream = Util.NullCheck(this.Request.GetRequestStream(), InternalError.InvalidGetRequestStream))
{
byte[] buffer = requestContent.GetBuffer();
int bufferOffset = checked ((int)requestContent.Position);
int bufferLength = checked ((int)requestContent.Length) - bufferOffset;
stream.Write(buffer, bufferOffset, bufferLength);
}
}
#endif
HttpWebResponse response = null;
try
{
response = (HttpWebResponse)this.Request.GetResponse();
}
catch (WebException ex)
{
response = (HttpWebResponse)ex.Response;
if (null == response)
{
throw;
}
}
this.SetHttpWebResponse(Util.NullCheck(response, InternalError.InvalidGetResponse));
if (HttpStatusCode.NoContent != this.StatusCode)
{
using (Stream stream = this.httpWebResponse.GetResponseStream())
{
if (null != stream)
{
Stream copy = this.GetAsyncResponseStreamCopy();
this.responseStream = copy;
Byte[] buffer = this.GetAsyncResponseStreamCopyBuffer();
long copied = WebUtil.CopyStream(stream, copy, ref buffer);
if (this.responseStreamOwner)
{
if (0 == copied)
{
this.responseStream = null;
}
else if (copy.Position < copy.Length)
{
((MemoryStream)copy).SetLength(copy.Position);
}
}
this.PutAsyncResponseStreamCopyBuffer(buffer);
}
}
}
}
catch (Exception e)
{
this.HandleFailure(e);
throw;
}
finally
{
this.SetCompleted();
this.CompletedRequest();
}
if (null != this.Failure)
{
throw this.Failure;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageWriterSettingsArgs"/> class.
/// </summary>
/// <param name="settings">The settings.</param>
public MessageWriterSettingsArgs(ODataMessageWriterSettingsBase settings)
{
WebUtil.CheckArgumentNull(settings, "settings");
this.Settings = settings;
}
/// <summary>
/// VisitCountOptions visit method.
/// </summary>
internal void VisitCountOptions()
{
this.AddAsCachedQueryOption(UriHelper.DOLLARSIGN + UriHelper.OPTIONCOUNT, UriHelper.COUNTALL);
WebUtil.RaiseVersion(ref this.uriVersion, Util.DataServiceVersion2);
}
internal override Expression VisitMethodCall(MethodCallExpression m)
{
string str;
SequenceMethod method;
if (TypeSystem.TryGetQueryOptionMethod(m.Method, out str))
{
this.builder.Append(str);
this.builder.Append('(');
if (str == "substringof")
{
this.Visit(m.Arguments[0]);
this.builder.Append(',');
this.Visit(m.Object);
}
else
{
if (m.Object != null)
{
this.Visit(m.Object);
}
if (m.Arguments.Count > 0)
{
if (m.Object != null)
{
this.builder.Append(',');
}
for (int i = 0; i < m.Arguments.Count; i++)
{
this.Visit(m.Arguments[i]);
if (i < (m.Arguments.Count - 1))
{
this.builder.Append(',');
}
}
}
}
this.builder.Append(')');
return(m);
}
if (ReflectionUtil.TryIdentifySequenceMethod(m.Method, out method))
{
if (ReflectionUtil.IsAnyAllMethod(method))
{
WebUtil.RaiseVersion(ref this.uriVersion, Util.DataServiceVersion3);
this.Visit(m.Arguments[0]);
this.builder.Append('/');
if (method == SequenceMethod.All)
{
this.builder.Append("all");
}
else
{
this.builder.Append("any");
}
this.builder.Append('(');
if (method != SequenceMethod.Any)
{
LambdaExpression expression = (LambdaExpression)m.Arguments[1];
string name = expression.Parameters[0].Name;
this.builder.Append(name);
this.builder.Append(':');
this.scopeCount++;
this.Visit(expression.Body);
this.scopeCount--;
}
this.builder.Append(')');
return(m);
}
if ((method == SequenceMethod.OfType) && (this.parent != null))
{
MethodCallExpression parent = this.parent as MethodCallExpression;
if (((parent != null) && ReflectionUtil.TryIdentifySequenceMethod(parent.Method, out method)) && ReflectionUtil.IsAnyAllMethod(method))
{
Type type = parent.Method.GetGenericArguments().SingleOrDefault <Type>();
if (ClientTypeUtil.TypeOrElementTypeIsEntity(type))
{
this.Visit(m.Arguments[0]);
this.builder.Append('/');
this.builder.Append(System.Data.Services.Client.UriHelper.GetEntityTypeNameForUriAndValidateMaxProtocolVersion(type, this.context, ref this.uriVersion));
return(m);
}
}
}
}
this.cantTranslateExpression = true;
return(m);
}
/// <summary>Synchronous web request</summary>
internal void Execute()
{
try
{
#if false
if ((null != requestContent) && (0 < requestContent.Length))
{
using (System.IO.Stream stream = Util.NullCheck(this.Request.GetRequestStream(), InternalError.InvalidGetRequestStream))
{
byte[] buffer = requestContent.GetBuffer();
int bufferOffset = checked ((int)requestContent.Position);
int bufferLength = checked ((int)requestContent.Length) - bufferOffset;
// the following is useful in the debugging Immediate Window
// string x = System.Text.Encoding.UTF8.GetString(buffer, bufferOffset, bufferLength);
stream.Write(buffer, bufferOffset, bufferLength);
}
}
#endif
HttpWebResponse response = null;
try
{
response = (HttpWebResponse)this.Request.GetResponse();
}
catch (WebException ex)
{
response = (HttpWebResponse)ex.Response;
if (null == response)
{
throw;
}
}
this.SetHttpWebResponse(Util.NullCheck(response, InternalError.InvalidGetResponse));
if (HttpStatusCode.NoContent != this.StatusCode)
{
using (Stream stream = this.httpWebResponse.GetResponseStream())
{
if (null != stream)
{
Stream copy = this.GetAsyncResponseStreamCopy();
this.responseStream = copy;
Byte[] buffer = this.GetAsyncResponseStreamCopyBuffer();
long copied = WebUtil.CopyStream(stream, copy, ref buffer);
if (this.responseStreamOwner)
{
if (0 == copied)
{
this.responseStream = null;
}
else if (copy.Position < copy.Length)
{ // In Silverlight, generally 3 bytes less than advertised by ContentLength are read
((MemoryStream)copy).SetLength(copy.Position);
}
}
this.PutAsyncResponseStreamCopyBuffer(buffer);
}
}
}
}
catch (Exception e)
{
this.HandleFailure(e);
throw;
}
finally
{
this.SetCompleted();
this.CompletedRequest();
}
if (null != this.Failure)
{
throw this.Failure;
}
}
/// <summary>
/// Creates and returns an ODataCollectionValue from the given value.
/// </summary>
/// <param name="collectionItemType">The type of the value.</param>
/// <param name="propertyName">If the value is a property, then it represents the name of the property. Can be null, for non-property.</param>
/// <param name="value">The value.</param>
/// <param name="visitedComplexTypeObjects">Set of instances of complex types encountered in the hierarchy. Used to detect cycles.</param>
/// <returns>An ODataCollectionValue representing the given value.</returns>
internal ODataCollectionValue CreateODataCollection(Type collectionItemType, string propertyName, object value, HashSet <object> visitedComplexTypeObjects)
{
Debug.Assert(collectionItemType != null, "collectionItemType != null");
WebUtil.ValidateCollection(collectionItemType, value, propertyName);
PrimitiveType ptype;
bool isCollectionOfPrimitiveTypes = PrimitiveType.TryGetPrimitiveType(collectionItemType, out ptype);
ODataCollectionValue collection = new ODataCollectionValue();
IEnumerable enumerablePropertyValue = (IEnumerable)value;
string collectionItemTypeName;
string collectionTypeName;
if (isCollectionOfPrimitiveTypes)
{
collectionItemTypeName = ClientConvert.GetEdmType(Nullable.GetUnderlyingType(collectionItemType) ?? collectionItemType);
collection.Items = Util.GetEnumerable(
enumerablePropertyValue,
(val) =>
{
WebUtil.ValidateCollectionItem(val);
WebUtil.ValidatePrimitiveCollectionItem(val, propertyName, collectionItemType);
return(ConvertPrimitiveValueToRecognizedODataType(val, collectionItemType));
});
// TypeName for primitives should be the EDM name since that's what we will be able to look up in the model
collectionTypeName = collectionItemTypeName;
}
else
{
// Note that the collectionItemTypeName will be null if the context does not have the ResolveName func.
collectionItemTypeName = this.requestInfo.ResolveNameFromType(collectionItemType);
collection.Items = Util.GetEnumerable(
enumerablePropertyValue,
(val) =>
{
WebUtil.ValidateCollectionItem(val);
WebUtil.ValidateComplexCollectionItem(val, propertyName, collectionItemType);
return(this.CreateODataComplexValue(collectionItemType, val, propertyName, true /*isCollectionItem*/, visitedComplexTypeObjects));
});
// TypeName for complex types needs to be the client type name (not the one we resolved above) since it will be looked up in the client model
collectionTypeName = collectionItemType.FullName;
}
// Set the type name to use for client type lookups and validation. Because setting this value can cause validation to occur, we will
// only do it for JSON Light, in order to avoid breaking changes with the WCF Data Services 5.0 release, since it was already shipped without this.
if (!this.requestInfo.Format.UsingAtom)
{
collection.TypeName = GetCollectionName(collectionTypeName);
}
string wireTypeName = GetCollectionName(collectionItemTypeName);
collection.SetAnnotation(new SerializationTypeNameAnnotation {
TypeName = wireTypeName
});
return(collection);
}
/// <summary>
/// MethodCallExpression visit method
/// </summary>
/// <param name="m">The MethodCallExpression expression to visit</param>
/// <returns>The visited MethodCallExpression expression </returns>
internal override Expression VisitMethodCall(MethodCallExpression m)
{
string methodName;
if (TypeSystem.TryGetQueryOptionMethod(m.Method, out methodName))
{
this.builder.Append(methodName);
this.builder.Append(UriHelper.LEFTPAREN);
// There is a single function, 'substringof', which reorders its argument with
// respect to the CLR method. Thus handling it as a special case rather than
// using a more general argument reordering mechanism.
if (methodName == "substringof")
{
Debug.Assert(m.Method.Name == "Contains", "m.Method.Name == 'Contains'");
Debug.Assert(m.Object != null, "m.Object != null");
Debug.Assert(m.Arguments.Count == 1, "m.Arguments.Count == 1");
this.Visit(m.Arguments[0]);
this.builder.Append(UriHelper.COMMA);
this.Visit(m.Object);
}
else
{
if (m.Object != null)
{
this.Visit(m.Object);
}
if (m.Arguments.Count > 0)
{
if (m.Object != null)
{
this.builder.Append(UriHelper.COMMA);
}
for (int ii = 0; ii < m.Arguments.Count; ii++)
{
this.Visit(m.Arguments[ii]);
if (ii < m.Arguments.Count - 1)
{
this.builder.Append(UriHelper.COMMA);
}
}
}
}
this.builder.Append(UriHelper.RIGHTPAREN);
}
else
{
SequenceMethod sequenceMethod;
if (ReflectionUtil.TryIdentifySequenceMethod(m.Method, out sequenceMethod))
{
if (ReflectionUtil.IsAnyAllMethod(sequenceMethod))
{
// Raise the uriVersion each time we write any or all methods to the uri.
WebUtil.RaiseVersion(ref this.uriVersion, Util.DataServiceVersion3);
this.Visit(m.Arguments[0]);
this.builder.Append(UriHelper.FORWARDSLASH);
if (sequenceMethod == SequenceMethod.All)
{
this.builder.Append(XmlConstants.AllMethodName);
}
else
{
this.builder.Append(XmlConstants.AnyMethodName);
}
this.builder.Append(UriHelper.LEFTPAREN);
if (sequenceMethod != SequenceMethod.Any)
{
// SequenceMethod.Any represents Enumerable.Any(), which has only source argument
// AnyPredicate and All has a second parameter which is the predicate lambda.
Debug.Assert(m.Arguments.Count() == 2, "m.Arguments.Count() == 2");
LambdaExpression le = (LambdaExpression)m.Arguments[1];
string rangeVariable = le.Parameters[0].Name;
this.builder.Append(rangeVariable);
this.builder.Append(UriHelper.COLON);
this.scopeCount++;
this.Visit(le.Body);
this.scopeCount--;
}
this.builder.Append(UriHelper.RIGHTPAREN);
return(m);
}
else if (sequenceMethod == SequenceMethod.OfType && this.parent != null)
{
// check to see if this is an OfType filter for Any or All.
// e.g. ctx.CreateQuery<Movie>("Movies").Where(m=>m.Actors.OfType<MegaStar>().Any())
// which translates to /Movies()?$filter=Actors/MegaStar/any()
MethodCallExpression mce = this.parent as MethodCallExpression;
if (mce != null &&
ReflectionUtil.TryIdentifySequenceMethod(mce.Method, out sequenceMethod) &&
ReflectionUtil.IsAnyAllMethod(sequenceMethod))
{
Type filteredType = mce.Method.GetGenericArguments().SingleOrDefault();
if (ClientTypeUtil.TypeOrElementTypeIsEntity(filteredType))
{
this.Visit(m.Arguments[0]);
this.builder.Append(UriHelper.FORWARDSLASH);
UriHelper.AppendTypeSegment(this.builder, filteredType, this.context, this.inPath, ref this.uriVersion);
return(m);
}
}
}
}
this.cantTranslateExpression = true;
}
return(m);
}
internal HttpWebResponseMessage(HttpWebResponse httpResponse, Func <Stream> getResponseStream) : this(WebUtil.WrapResponseHeaders(httpResponse), (int)httpResponse.StatusCode, getResponseStream)
{
}