Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataWeb / Server / System / Data / Services / UpdatableWrapper.cs / 1305376 / UpdatableWrapper.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// Wraps all the calls to IUpdatable interface.
//
//
// @owner [....]
//---------------------------------------------------------------------
namespace System.Data.Services
{
using System.Linq;
using System.Diagnostics;
using System.Collections.Generic;
using System.Data.Services.Providers;
///
/// This class wraps all the calls to IUpdatable interface.
///
internal class UpdatableWrapper
{
/// instance implementation of IUpdatable.
private IUpdatable updateProvider;
/// data service instance.
private IDataService service;
///
/// creates an instance of UpdatableWrapper, which wraps all the calls to IUpdatable interface.
///
/// instance of the data service.
internal UpdatableWrapper(IDataService serviceInstance)
{
this.service = serviceInstance;
}
///
/// Get the instance of IUpdatable.
///
private IUpdatable UpdateProvider
{
get
{
if (this.updateProvider == null)
{
// We need to call IUpdatable only for V1 providers. For ObjectContextServiceProvider, this always returns null.
// Hence basically, this call is only for reflection service provider.
if (this.service.Provider.IsV1Provider)
{
this.updateProvider = this.service.Provider.GetService((IDataService)this.service.Instance);
}
if (this.updateProvider == null)
{
this.updateProvider = this.service.Provider.GetService((IDataService)this.service.Instance);
}
}
if (this.updateProvider == null)
{
if (this.service.Provider.IsV1Provider)
{
throw DataServiceException.CreateMethodNotImplemented(Strings.UpdatableWrapper_MissingIUpdatableForV1Provider);
}
else
{
throw DataServiceException.CreateMethodNotImplemented(Strings.UpdatableWrapper_MissingUpdateProviderInterface);
}
}
return this.updateProvider;
}
}
///
/// Creates the resource of the given type and belonging to the given container
///
/// container name to which the resource needs to be added
/// full type name i.e. Namespace qualified type name of the resource
/// object representing a resource of given type and belonging to the given container
internal object CreateResource(string containerName, string fullTypeName)
{
// container name can be null for complex types
// type name can be null when we don't know the type - e.g. DELETE /Customers(1)
// In case of inheritance we don't know the actual type of customer instance.
object resource = this.UpdateProvider.CreateResource(containerName, fullTypeName);
if (resource == null)
{
throw new InvalidOperationException(Strings.BadProvider_CreateResourceReturnedNull);
}
return resource;
}
///
/// Gets the resource of the given type that the query points to
///
/// query pointing to a particular resource
/// full type name i.e. Namespace qualified type name of the resource
/// object representing a resource of given type and as referenced by the query
internal object GetResource(IQueryable query, string fullTypeName)
{
Debug.Assert(query != null, "query != null");
try
{
// TypeName can be null since for open types, we may not know the type yet.
return this.UpdateProvider.GetResource(query, fullTypeName);
}
catch (ArgumentException e)
{
throw DataServiceException.CreateBadRequestError(Strings.BadRequest_InvalidUriSpecified, e);
}
}
///
/// Resets the value of the given resource to its default value
///
/// resource whose value needs to be reset
/// same resource with its value reset
internal object ResetResource(object resource)
{
Debug.Assert(resource != null, "resource != null");
object resetResource = this.UpdateProvider.ResetResource(resource);
if (resetResource == null)
{
throw new InvalidOperationException(Strings.BadProvider_ResetResourceReturnedNull);
}
return resetResource;
}
///
/// If the provider implements IConcurrencyProvider, then this method passes the etag values
/// to the provider, otherwise compares the etag itself.
///
/// etag values for the given resource.
/// container for the given resource.
internal void SetETagValues(object resourceCookie, ResourceSetWrapper container)
{
Debug.Assert(resourceCookie != null, "resourceCookie != null");
Debug.Assert(container != null, "container != null");
DataServiceHostWrapper host = this.service.OperationContext.Host;
Debug.Assert(String.IsNullOrEmpty(host.RequestIfNoneMatch), "IfNoneMatch header cannot be specified for Update/Delete operations");
// Resolve the cookie first to the actual resource type
object actualEntity = this.ResolveResource(resourceCookie);
Debug.Assert(actualEntity != null, "actualEntity != null");
ResourceType resourceType = WebUtil.GetNonPrimitiveResourceType(this.service.Provider, actualEntity);
Debug.Assert(resourceType != null, "resourceType != null");
IList etagProperties = this.service.Provider.GetETagProperties(container.Name, resourceType);
if (etagProperties.Count == 0)
{
if (!String.IsNullOrEmpty(host.RequestIfMatch))
{
throw DataServiceException.CreateBadRequestError(Strings.Serializer_NoETagPropertiesForType);
}
// If the type has no etag properties, then we do not need to do any etag checks
return;
}
// If the provider implements IConcurrencyProvider, then we need to call the provider
// and pass the etag values. Else, we need to compare the etag values ourselves.
IDataServiceUpdateProvider concurrencyProvider = this.updateProvider as IDataServiceUpdateProvider;
if (concurrencyProvider != null)
{
bool? checkForEquality = null;
IEnumerable> etagValues = null;
if (!String.IsNullOrEmpty(host.RequestIfMatch))
{
checkForEquality = true;
etagValues = ParseETagValue(etagProperties, host.RequestIfMatch);
}
else
{
etagValues = new KeyValuePair[0];
}
concurrencyProvider.SetConcurrencyValues(resourceCookie, checkForEquality, etagValues);
}
else if (String.IsNullOrEmpty(host.RequestIfMatch))
{
throw DataServiceException.CreateBadRequestError(Strings.DataService_CannotPerformOperationWithoutETag(resourceType.FullName));
}
else if (host.RequestIfMatch != XmlConstants.HttpAnyETag)
{
// Compare If-Match header value with the current etag value, if the If-Match header value is not equal to '*'
string etagValue = WebUtil.GetETagValue(resourceCookie, resourceType, etagProperties, this.service, false /*getMethod*/);
Debug.Assert(!String.IsNullOrEmpty(etagValue), "etag value can never be null");
if (etagValue != host.RequestIfMatch)
{
throw DataServiceException.CreatePreConditionFailedError(Strings.Serializer_ETagValueDoesNotMatch);
}
}
}
///
/// Sets the value of the given property on the target object
///
/// target object which defines the property
/// name of the property whose value needs to be updated
/// value of the property
internal void SetValue(object targetResource, string propertyName, object propertyValue)
{
Debug.Assert(targetResource != null, "targetResource != null");
Debug.Assert(!String.IsNullOrEmpty(propertyName), "!String.IsNullOrEmpty(propertyName)");
this.UpdateProvider.SetValue(targetResource, propertyName, propertyValue);
}
///
/// Gets the value of the given property on the target object
///
/// target object which defines the property
/// name of the property whose value needs to be updated
/// the value of the property for the given target resource
internal object GetValue(object targetResource, string propertyName)
{
Debug.Assert(targetResource != null, "targetResource != null");
Debug.Assert(!String.IsNullOrEmpty(propertyName), "!String.IsNullOrEmpty(propertyName)");
return this.UpdateProvider.GetValue(targetResource, propertyName);
}
///
/// Sets the value of the given reference property on the target object
///
/// target object which defines the property
/// name of the property whose value needs to be updated
/// value of the property
internal void SetReference(object targetResource, string propertyName, object propertyValue)
{
Debug.Assert(targetResource != null, "targetResource != null");
Debug.Assert(!String.IsNullOrEmpty(propertyName), "!String.IsNullOrEmpty(propertyName)");
this.UpdateProvider.SetReference(targetResource, propertyName, propertyValue);
}
///
/// Adds the given value to the collection
///
/// target object which defines the property
/// name of the property whose value needs to be updated
/// value of the property which needs to be added
internal void AddReferenceToCollection(object targetResource, string propertyName, object resourceToBeAdded)
{
Debug.Assert(targetResource != null, "targetResource != null");
Debug.Assert(!String.IsNullOrEmpty(propertyName), "!String.IsNullOrEmpty(propertyName)");
this.UpdateProvider.AddReferenceToCollection(targetResource, propertyName, resourceToBeAdded);
}
///
/// Removes the given value from the collection
///
/// target object which defines the property
/// name of the property whose value needs to be updated
/// value of the property which needs to be removed
internal void RemoveReferenceFromCollection(object targetResource, string propertyName, object resourceToBeRemoved)
{
Debug.Assert(targetResource != null, "targetResource != null");
Debug.Assert(!String.IsNullOrEmpty(propertyName), "!String.IsNullOrEmpty(propertyName)");
this.UpdateProvider.RemoveReferenceFromCollection(targetResource, propertyName, resourceToBeRemoved);
}
///
/// Delete the given resource
///
/// resource that needs to be deleted
internal void DeleteResource(object targetResource)
{
Debug.Assert(targetResource != null, "targetResource != null");
this.UpdateProvider.DeleteResource(targetResource);
}
///
/// Saves all the pending changes made till now
///
internal void SaveChanges()
{
this.UpdateProvider.SaveChanges();
}
///
/// Returns the actual instance of the resource represented by the given resource object
///
/// object representing the resource whose instance needs to be fetched
/// The actual instance of the resource represented by the given resource object
internal object ResolveResource(object resource)
{
Debug.Assert(resource != null, "resource != null");
object resolvedResource = this.UpdateProvider.ResolveResource(resource);
if (resolvedResource == null)
{
throw new InvalidOperationException(Strings.BadProvider_ResolveResourceReturnedNull);
}
return resolvedResource;
}
///
/// Revert all the pending changes.
///
internal void ClearChanges()
{
this.UpdateProvider.ClearChanges();
}
///
/// Dispose the update provider instance
///
internal void DisposeProvider()
{
if (this.updateProvider != null)
{
WebUtil.Dispose(this.updateProvider);
this.updateProvider = null;
}
}
///
/// Parse the given etag value in the If-Match request header.
///
/// List of etag properties for the type whose etag values we are parsing.
/// value of the If-Match header as specified in the request.
/// returns the etag value as a list containing the property name and its corresponding value. If the If-Match header value is '*', then returns an empty collection.
private static IEnumerable> ParseETagValue(IList etagProperties, string ifMatchHeaderValue)
{
Debug.Assert(etagProperties != null && etagProperties.Count != 0, "There must be atleast one etag property specified");
Debug.Assert(!String.IsNullOrEmpty(ifMatchHeaderValue), "IfMatch header cannot be null");
if (ifMatchHeaderValue == XmlConstants.HttpAnyETag)
{
// if the value is '*', then we return an empty IEnumerable.
return new KeyValuePair[0];
}
Debug.Assert(ifMatchHeaderValue.StartsWith(XmlConstants.HttpWeakETagPrefix, StringComparison.Ordinal), "If-Match header must be properly formatted - this check is done in DataService.CheckETagValues method");
Debug.Assert(ifMatchHeaderValue.Length >= XmlConstants.HttpWeakETagPrefix.Length + 1, "If-Match header must be properly formatted - this check is done in DataService.CheckETagValues method");
// Just get the etag value - we need to ignore the 'W/"' and the last '"' character from the etag
string strippedETag = ifMatchHeaderValue.Substring(XmlConstants.HttpWeakETagPrefix.Length, ifMatchHeaderValue.Length - XmlConstants.HttpWeakETagPrefix.Length - 1);
KeyInstance keyInstance = null;
bool success;
Exception innerException = null;
// In V1, when we didn't have IConcurrencyProvider interface, we always used to compute the
// latest etag from the entity instance we got from IUpdatable.GetResource and then comparing
// it with the If-Match request header. Hence all invalid cases always used to throw
// DataServiceException with 412, since the etags didn't match.
// In V1.5, we have added the support for IConcurrencyProvider, which means we need to parse
// the etag values and parse it to the provider, if it has implement this interface. To avoid
// breaking changes, we need to catch all parsing errors and report them as 412 instead of 400
// to avoid it from becoming a breaking change.
try
{
success = KeyInstance.TryParseNullableTokens(Uri.UnescapeDataString(strippedETag), out keyInstance);
}
catch (DataServiceException e)
{
success = false;
innerException = e;
}
if (!success)
{
// We could have throwed BadRequest here since the etag value is not properly formattted. But since
// we used to do throw 412 in V1, keeping it that way to avoid breaking change.
throw DataServiceException.CreatePreConditionFailedError(Strings.Serializer_ETagValueDoesNotMatch, innerException);
}
if (keyInstance.PositionalValues.Count != etagProperties.Count)
{
// We could have throwed BadRequest here since the etag value is not properly formattted. But since
// we used to do throw 412 in V1, keeping it that way to avoid breaking change.
throw DataServiceException.CreatePreConditionFailedError(Strings.Serializer_ETagValueDoesNotMatch);
}
KeyValuePair[] etagPropertyInfo = new KeyValuePair[etagProperties.Count];
for (int i = 0; i < etagPropertyInfo.Length; i++)
{
ResourceProperty etagProperty = etagProperties[i];
object propertyValue = null;
string value = (string)keyInstance.PositionalValues[i];
if (value != XmlConstants.NullLiteralInETag)
{
// The reason we need to catch the Overflow Exception here is because of the Bug #679728.
// In V1, when we didn't have IConcurrencyProvider interface, we always used to compute the
// latest etag from the entity instance we got from IUpdatable.GetResource and then comparing
// it with the If-Match request header. Hence all invalid cases always used to throw
// DataServiceException with 412, since the etags didn't match.
// In V1.5, we have added the support for IConcurrencyProvider, which means we need to parse
// the etag values and parse it to the provider, if it has implement this interface. To avoid
// breaking changes, we need to catch all parsing errors and report them as 412 instead of 400
// to avoid it from becoming a breaking change.
try
{
success = System.Data.Services.Parsing.WebConvert.TryKeyStringToPrimitive(value, etagProperty.Type, out propertyValue);
}
catch (OverflowException e)
{
success = false;
innerException = e;
}
if (!success)
{
// We could have throwed BadRequest here since the etag value is not properly formattted. But since
// we used to do throw 412 in V1, keeping it that way to avoid breaking change.
throw DataServiceException.CreatePreConditionFailedError(Strings.Serializer_ETagValueDoesNotMatch, innerException);
}
}
etagPropertyInfo[i] = new KeyValuePair(etagProperties[i].Name, propertyValue);
}
return etagPropertyInfo;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// Wraps all the calls to IUpdatable interface.
//
//
// @owner [....]
//---------------------------------------------------------------------
namespace System.Data.Services
{
using System.Linq;
using System.Diagnostics;
using System.Collections.Generic;
using System.Data.Services.Providers;
///
/// This class wraps all the calls to IUpdatable interface.
///
internal class UpdatableWrapper
{
/// instance implementation of IUpdatable.
private IUpdatable updateProvider;
/// data service instance.
private IDataService service;
///
/// creates an instance of UpdatableWrapper, which wraps all the calls to IUpdatable interface.
///
/// instance of the data service.
internal UpdatableWrapper(IDataService serviceInstance)
{
this.service = serviceInstance;
}
///
/// Get the instance of IUpdatable.
///
private IUpdatable UpdateProvider
{
get
{
if (this.updateProvider == null)
{
// We need to call IUpdatable only for V1 providers. For ObjectContextServiceProvider, this always returns null.
// Hence basically, this call is only for reflection service provider.
if (this.service.Provider.IsV1Provider)
{
this.updateProvider = this.service.Provider.GetService((IDataService)this.service.Instance);
}
if (this.updateProvider == null)
{
this.updateProvider = this.service.Provider.GetService((IDataService)this.service.Instance);
}
}
if (this.updateProvider == null)
{
if (this.service.Provider.IsV1Provider)
{
throw DataServiceException.CreateMethodNotImplemented(Strings.UpdatableWrapper_MissingIUpdatableForV1Provider);
}
else
{
throw DataServiceException.CreateMethodNotImplemented(Strings.UpdatableWrapper_MissingUpdateProviderInterface);
}
}
return this.updateProvider;
}
}
///
/// Creates the resource of the given type and belonging to the given container
///
/// container name to which the resource needs to be added
/// full type name i.e. Namespace qualified type name of the resource
/// object representing a resource of given type and belonging to the given container
internal object CreateResource(string containerName, string fullTypeName)
{
// container name can be null for complex types
// type name can be null when we don't know the type - e.g. DELETE /Customers(1)
// In case of inheritance we don't know the actual type of customer instance.
object resource = this.UpdateProvider.CreateResource(containerName, fullTypeName);
if (resource == null)
{
throw new InvalidOperationException(Strings.BadProvider_CreateResourceReturnedNull);
}
return resource;
}
///
/// Gets the resource of the given type that the query points to
///
/// query pointing to a particular resource
/// full type name i.e. Namespace qualified type name of the resource
/// object representing a resource of given type and as referenced by the query
internal object GetResource(IQueryable query, string fullTypeName)
{
Debug.Assert(query != null, "query != null");
try
{
// TypeName can be null since for open types, we may not know the type yet.
return this.UpdateProvider.GetResource(query, fullTypeName);
}
catch (ArgumentException e)
{
throw DataServiceException.CreateBadRequestError(Strings.BadRequest_InvalidUriSpecified, e);
}
}
///
/// Resets the value of the given resource to its default value
///
/// resource whose value needs to be reset
/// same resource with its value reset
internal object ResetResource(object resource)
{
Debug.Assert(resource != null, "resource != null");
object resetResource = this.UpdateProvider.ResetResource(resource);
if (resetResource == null)
{
throw new InvalidOperationException(Strings.BadProvider_ResetResourceReturnedNull);
}
return resetResource;
}
///
/// If the provider implements IConcurrencyProvider, then this method passes the etag values
/// to the provider, otherwise compares the etag itself.
///
/// etag values for the given resource.
/// container for the given resource.
internal void SetETagValues(object resourceCookie, ResourceSetWrapper container)
{
Debug.Assert(resourceCookie != null, "resourceCookie != null");
Debug.Assert(container != null, "container != null");
DataServiceHostWrapper host = this.service.OperationContext.Host;
Debug.Assert(String.IsNullOrEmpty(host.RequestIfNoneMatch), "IfNoneMatch header cannot be specified for Update/Delete operations");
// Resolve the cookie first to the actual resource type
object actualEntity = this.ResolveResource(resourceCookie);
Debug.Assert(actualEntity != null, "actualEntity != null");
ResourceType resourceType = WebUtil.GetNonPrimitiveResourceType(this.service.Provider, actualEntity);
Debug.Assert(resourceType != null, "resourceType != null");
IList etagProperties = this.service.Provider.GetETagProperties(container.Name, resourceType);
if (etagProperties.Count == 0)
{
if (!String.IsNullOrEmpty(host.RequestIfMatch))
{
throw DataServiceException.CreateBadRequestError(Strings.Serializer_NoETagPropertiesForType);
}
// If the type has no etag properties, then we do not need to do any etag checks
return;
}
// If the provider implements IConcurrencyProvider, then we need to call the provider
// and pass the etag values. Else, we need to compare the etag values ourselves.
IDataServiceUpdateProvider concurrencyProvider = this.updateProvider as IDataServiceUpdateProvider;
if (concurrencyProvider != null)
{
bool? checkForEquality = null;
IEnumerable> etagValues = null;
if (!String.IsNullOrEmpty(host.RequestIfMatch))
{
checkForEquality = true;
etagValues = ParseETagValue(etagProperties, host.RequestIfMatch);
}
else
{
etagValues = new KeyValuePair[0];
}
concurrencyProvider.SetConcurrencyValues(resourceCookie, checkForEquality, etagValues);
}
else if (String.IsNullOrEmpty(host.RequestIfMatch))
{
throw DataServiceException.CreateBadRequestError(Strings.DataService_CannotPerformOperationWithoutETag(resourceType.FullName));
}
else if (host.RequestIfMatch != XmlConstants.HttpAnyETag)
{
// Compare If-Match header value with the current etag value, if the If-Match header value is not equal to '*'
string etagValue = WebUtil.GetETagValue(resourceCookie, resourceType, etagProperties, this.service, false /*getMethod*/);
Debug.Assert(!String.IsNullOrEmpty(etagValue), "etag value can never be null");
if (etagValue != host.RequestIfMatch)
{
throw DataServiceException.CreatePreConditionFailedError(Strings.Serializer_ETagValueDoesNotMatch);
}
}
}
///
/// Sets the value of the given property on the target object
///
/// target object which defines the property
/// name of the property whose value needs to be updated
/// value of the property
internal void SetValue(object targetResource, string propertyName, object propertyValue)
{
Debug.Assert(targetResource != null, "targetResource != null");
Debug.Assert(!String.IsNullOrEmpty(propertyName), "!String.IsNullOrEmpty(propertyName)");
this.UpdateProvider.SetValue(targetResource, propertyName, propertyValue);
}
///
/// Gets the value of the given property on the target object
///
/// target object which defines the property
/// name of the property whose value needs to be updated
/// the value of the property for the given target resource
internal object GetValue(object targetResource, string propertyName)
{
Debug.Assert(targetResource != null, "targetResource != null");
Debug.Assert(!String.IsNullOrEmpty(propertyName), "!String.IsNullOrEmpty(propertyName)");
return this.UpdateProvider.GetValue(targetResource, propertyName);
}
///
/// Sets the value of the given reference property on the target object
///
/// target object which defines the property
/// name of the property whose value needs to be updated
/// value of the property
internal void SetReference(object targetResource, string propertyName, object propertyValue)
{
Debug.Assert(targetResource != null, "targetResource != null");
Debug.Assert(!String.IsNullOrEmpty(propertyName), "!String.IsNullOrEmpty(propertyName)");
this.UpdateProvider.SetReference(targetResource, propertyName, propertyValue);
}
///
/// Adds the given value to the collection
///
/// target object which defines the property
/// name of the property whose value needs to be updated
/// value of the property which needs to be added
internal void AddReferenceToCollection(object targetResource, string propertyName, object resourceToBeAdded)
{
Debug.Assert(targetResource != null, "targetResource != null");
Debug.Assert(!String.IsNullOrEmpty(propertyName), "!String.IsNullOrEmpty(propertyName)");
this.UpdateProvider.AddReferenceToCollection(targetResource, propertyName, resourceToBeAdded);
}
///
/// Removes the given value from the collection
///
/// target object which defines the property
/// name of the property whose value needs to be updated
/// value of the property which needs to be removed
internal void RemoveReferenceFromCollection(object targetResource, string propertyName, object resourceToBeRemoved)
{
Debug.Assert(targetResource != null, "targetResource != null");
Debug.Assert(!String.IsNullOrEmpty(propertyName), "!String.IsNullOrEmpty(propertyName)");
this.UpdateProvider.RemoveReferenceFromCollection(targetResource, propertyName, resourceToBeRemoved);
}
///
/// Delete the given resource
///
/// resource that needs to be deleted
internal void DeleteResource(object targetResource)
{
Debug.Assert(targetResource != null, "targetResource != null");
this.UpdateProvider.DeleteResource(targetResource);
}
///
/// Saves all the pending changes made till now
///
internal void SaveChanges()
{
this.UpdateProvider.SaveChanges();
}
///
/// Returns the actual instance of the resource represented by the given resource object
///
/// object representing the resource whose instance needs to be fetched
/// The actual instance of the resource represented by the given resource object
internal object ResolveResource(object resource)
{
Debug.Assert(resource != null, "resource != null");
object resolvedResource = this.UpdateProvider.ResolveResource(resource);
if (resolvedResource == null)
{
throw new InvalidOperationException(Strings.BadProvider_ResolveResourceReturnedNull);
}
return resolvedResource;
}
///
/// Revert all the pending changes.
///
internal void ClearChanges()
{
this.UpdateProvider.ClearChanges();
}
///
/// Dispose the update provider instance
///
internal void DisposeProvider()
{
if (this.updateProvider != null)
{
WebUtil.Dispose(this.updateProvider);
this.updateProvider = null;
}
}
///
/// Parse the given etag value in the If-Match request header.
///
/// List of etag properties for the type whose etag values we are parsing.
/// value of the If-Match header as specified in the request.
/// returns the etag value as a list containing the property name and its corresponding value. If the If-Match header value is '*', then returns an empty collection.
private static IEnumerable> ParseETagValue(IList etagProperties, string ifMatchHeaderValue)
{
Debug.Assert(etagProperties != null && etagProperties.Count != 0, "There must be atleast one etag property specified");
Debug.Assert(!String.IsNullOrEmpty(ifMatchHeaderValue), "IfMatch header cannot be null");
if (ifMatchHeaderValue == XmlConstants.HttpAnyETag)
{
// if the value is '*', then we return an empty IEnumerable.
return new KeyValuePair[0];
}
Debug.Assert(ifMatchHeaderValue.StartsWith(XmlConstants.HttpWeakETagPrefix, StringComparison.Ordinal), "If-Match header must be properly formatted - this check is done in DataService.CheckETagValues method");
Debug.Assert(ifMatchHeaderValue.Length >= XmlConstants.HttpWeakETagPrefix.Length + 1, "If-Match header must be properly formatted - this check is done in DataService.CheckETagValues method");
// Just get the etag value - we need to ignore the 'W/"' and the last '"' character from the etag
string strippedETag = ifMatchHeaderValue.Substring(XmlConstants.HttpWeakETagPrefix.Length, ifMatchHeaderValue.Length - XmlConstants.HttpWeakETagPrefix.Length - 1);
KeyInstance keyInstance = null;
bool success;
Exception innerException = null;
// In V1, when we didn't have IConcurrencyProvider interface, we always used to compute the
// latest etag from the entity instance we got from IUpdatable.GetResource and then comparing
// it with the If-Match request header. Hence all invalid cases always used to throw
// DataServiceException with 412, since the etags didn't match.
// In V1.5, we have added the support for IConcurrencyProvider, which means we need to parse
// the etag values and parse it to the provider, if it has implement this interface. To avoid
// breaking changes, we need to catch all parsing errors and report them as 412 instead of 400
// to avoid it from becoming a breaking change.
try
{
success = KeyInstance.TryParseNullableTokens(Uri.UnescapeDataString(strippedETag), out keyInstance);
}
catch (DataServiceException e)
{
success = false;
innerException = e;
}
if (!success)
{
// We could have throwed BadRequest here since the etag value is not properly formattted. But since
// we used to do throw 412 in V1, keeping it that way to avoid breaking change.
throw DataServiceException.CreatePreConditionFailedError(Strings.Serializer_ETagValueDoesNotMatch, innerException);
}
if (keyInstance.PositionalValues.Count != etagProperties.Count)
{
// We could have throwed BadRequest here since the etag value is not properly formattted. But since
// we used to do throw 412 in V1, keeping it that way to avoid breaking change.
throw DataServiceException.CreatePreConditionFailedError(Strings.Serializer_ETagValueDoesNotMatch);
}
KeyValuePair[] etagPropertyInfo = new KeyValuePair[etagProperties.Count];
for (int i = 0; i < etagPropertyInfo.Length; i++)
{
ResourceProperty etagProperty = etagProperties[i];
object propertyValue = null;
string value = (string)keyInstance.PositionalValues[i];
if (value != XmlConstants.NullLiteralInETag)
{
// The reason we need to catch the Overflow Exception here is because of the Bug #679728.
// In V1, when we didn't have IConcurrencyProvider interface, we always used to compute the
// latest etag from the entity instance we got from IUpdatable.GetResource and then comparing
// it with the If-Match request header. Hence all invalid cases always used to throw
// DataServiceException with 412, since the etags didn't match.
// In V1.5, we have added the support for IConcurrencyProvider, which means we need to parse
// the etag values and parse it to the provider, if it has implement this interface. To avoid
// breaking changes, we need to catch all parsing errors and report them as 412 instead of 400
// to avoid it from becoming a breaking change.
try
{
success = System.Data.Services.Parsing.WebConvert.TryKeyStringToPrimitive(value, etagProperty.Type, out propertyValue);
}
catch (OverflowException e)
{
success = false;
innerException = e;
}
if (!success)
{
// We could have throwed BadRequest here since the etag value is not properly formattted. But since
// we used to do throw 412 in V1, keeping it that way to avoid breaking change.
throw DataServiceException.CreatePreConditionFailedError(Strings.Serializer_ETagValueDoesNotMatch, innerException);
}
}
etagPropertyInfo[i] = new KeyValuePair(etagProperties[i].Name, propertyValue);
}
return etagPropertyInfo;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- DataGridViewHeaderCell.cs
- XmlILOptimizerVisitor.cs
- AutomationAttributeInfo.cs
- InkCanvasSelectionAdorner.cs
- AjaxFrameworkAssemblyAttribute.cs
- RsaSecurityKey.cs
- CacheEntry.cs
- IntegerValidatorAttribute.cs
- ScriptingProfileServiceSection.cs
- httpserverutility.cs
- PowerStatus.cs
- RequestCacheValidator.cs
- SerializationBinder.cs
- SqlBuilder.cs
- OdbcInfoMessageEvent.cs
- FastEncoder.cs
- ToolStripDropTargetManager.cs
- CatchDesigner.xaml.cs
- ToolStripPanelRow.cs
- SmtpTransport.cs
- XmlDataImplementation.cs
- StatusStrip.cs
- LoadedOrUnloadedOperation.cs
- EmptyEnumerable.cs
- Lasso.cs
- ObsoleteAttribute.cs
- HtmlTable.cs
- SByteStorage.cs
- SharedPersonalizationStateInfo.cs
- ScaleTransform3D.cs
- IApplicationTrustManager.cs
- Accessible.cs
- KeyedCollection.cs
- Timeline.cs
- AttributeInfo.cs
- ObjectStateFormatter.cs
- Input.cs
- LinkArea.cs
- FixedSOMElement.cs
- ToolStripDropDownMenu.cs
- FloatAverageAggregationOperator.cs
- RelationshipFixer.cs
- DesignTimeXamlWriter.cs
- UnsafeNativeMethods.cs
- XPathMultyIterator.cs
- MetadataItemCollectionFactory.cs
- EndPoint.cs
- linebase.cs
- CannotUnloadAppDomainException.cs
- BuildProviderUtils.cs
- EmptyStringExpandableObjectConverter.cs
- DBAsyncResult.cs
- ClassHandlersStore.cs
- OpenTypeLayoutCache.cs
- TripleDES.cs
- RepeaterItem.cs
- DataGridViewCheckBoxCell.cs
- ToolStripCustomTypeDescriptor.cs
- QueryResults.cs
- DBSchemaRow.cs
- IArgumentProvider.cs
- TableRowGroup.cs
- DbProviderConfigurationHandler.cs
- TreeNodeClickEventArgs.cs
- DateRangeEvent.cs
- SqlTrackingQuery.cs
- StateWorkerRequest.cs
- QueryCursorEventArgs.cs
- ImportCatalogPart.cs
- oledbmetadatacollectionnames.cs
- ContextMenu.cs
- SyntaxCheck.cs
- MouseOverProperty.cs
- AddingNewEventArgs.cs
- ListenerSessionConnectionReader.cs
- PageCodeDomTreeGenerator.cs
- CLSCompliantAttribute.cs
- EmptyStringExpandableObjectConverter.cs
- Emitter.cs
- Size.cs
- EdmError.cs
- SkipStoryboardToFill.cs
- DebugView.cs
- SpotLight.cs
- DataReceivedEventArgs.cs
- Vector3DCollectionValueSerializer.cs
- XmlCDATASection.cs
- precedingsibling.cs
- _AcceptOverlappedAsyncResult.cs
- ConfigurationSettings.cs
- BinaryMethodMessage.cs
- ToolboxService.cs
- StringValueSerializer.cs
- _SslSessionsCache.cs
- PackWebRequestFactory.cs
- SqlDependency.cs
- SBCSCodePageEncoding.cs
- HtmlHead.cs
- StringAnimationBase.cs
- securitycriticaldata.cs