public void UpdateAsync(SsdsBlobEntity blob, ConcurrencyPattern concurrencyPattern, BlobOperationComplete onComplete)
{
Exception exception = null;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += new DoWorkEventHandler(delegate(object sender, DoWorkEventArgs e)
{
try
{
this.Update(blob, concurrencyPattern);
}
catch (Exception ex)
{
exception = ex;
}
});
worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(delegate(object sender, RunWorkerCompletedEventArgs e)
{
if (onComplete != null)
{
onComplete(blob, exception);
}
});
worker.RunWorkerAsync();
}
/// <summary>
/// Updates the item on the container.
/// </summary>
/// <param name="entity">The item with the information to be updated.</param>
public void Update <T>(SsdsEntity <T> entity, ConcurrencyPattern concurrencyPattern) where T : class, new()
{
Uri updateLocation = HttpRestUriTemplates.UpdateTemplate.BindByPosition(this.authority, this.container, entity.Id);
SsdsRestFacade facade = this.CreateFacade(updateLocation);
SsdsEntitySerializer <T> serializer = new SsdsEntitySerializer <T>();
string payload = serializer.Serialize(entity);
facade.Update(payload, concurrencyPattern, entity.Version.ToString());
}
/// <summary>
/// Sends a Put message to the current container using the paylod as the message body.
/// </summary>
/// <param name="payload">The message body.</param>
public void Update(string payload, ConcurrencyPattern concurrencyPattern, string version)
{
WebRequest request = this.CreateRequest(this.scope, HttpVerbs.Put, payload);
if (concurrencyPattern == ConcurrencyPattern.IfMatch)
{
request.Headers.Add("if-match", version);
}
else if (concurrencyPattern == ConcurrencyPattern.IfNoneMatch)
{
request.Headers.Add("if-none-match", version);
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
if (response.StatusCode != HttpStatusCode.OK)
{
string message = string.Format(CultureInfo.InvariantCulture, "Unexpected return code: {0}", response.StatusCode);
throw new InvalidOperationException(message);
}
}
}
/// <summary>
/// Sends a Delete message to the current container using the entityId
/// as the last fragment of the Uri.
/// </summary>
/// <param name="entityId">The identifier for the object where the message is going.</param>
public void Delete(string entityId, ConcurrencyPattern concurrencyPattern, string version)
{
Uri destination = HttpRestUriTemplates.EntityTemplate.BindByPosition(this.scope, entityId);
WebRequest request = this.CreateRequest(destination, HttpVerbs.Delete);
if (concurrencyPattern == ConcurrencyPattern.IfMatch)
{
request.Headers.Add("if-match", version);
}
else if (concurrencyPattern == ConcurrencyPattern.IfNoneMatch)
{
request.Headers.Add("if-none-match", version);
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
if (response.StatusCode != HttpStatusCode.OK)
{
string message = string.Format(CultureInfo.InvariantCulture, "Unexpected return code: {0}", response.StatusCode);
throw new InvalidOperationException(message);
}
}
}
private string InsertOrUpdate(SsdsBlobEntity blob, string verb, ConcurrencyPattern concurrencyPattern)
{
string locationResult = String.Empty;
IAsyncResult asyncResult = null;
Exception backgroundError = null;
blob.InitRead();
Uri containerScope = this.scope;
if (verb == HttpVerbs.Put)
{
containerScope = new Uri(String.Format(CultureInfo.InvariantCulture, "{0}/{1}", this.scope, blob.Id));
}
HttpWebRequest uploadRequest = CreateStreamingRequest(containerScope, verb, blob);
if (verb == HttpVerbs.Post)
{
uploadRequest.Headers["Slug"] = blob.Id;
}
if (concurrencyPattern == ConcurrencyPattern.IfMatch)
{
uploadRequest.Headers.Add("if-match", blob.Version);
}
else if (concurrencyPattern == ConcurrencyPattern.IfNoneMatch)
{
uploadRequest.Headers.Add("if-none-match", blob.Version);
}
try
{
using (Stream requestStream = uploadRequest.GetRequestStream())
{
while (blob.ReadBuffer() > 0)
{
requestStream.Write(blob.Buffer, 0, blob.ReadSize);
if (asyncResult == null)
{
asyncResult = uploadRequest.BeginGetResponse((IAsyncResult res) =>
{
HttpWebRequest req = (HttpWebRequest)res.AsyncState;
try
{
using (HttpWebResponse response = (HttpWebResponse)req.EndGetResponse(res))
{
locationResult = response.Headers[HttpResponseHeader.Location];
}
}
catch (Exception ex)
{
backgroundError = ex;
}
}, uploadRequest);
}
}
}
if (asyncResult != null)
{
asyncResult.AsyncWaitHandle.WaitOne();
if (backgroundError != null)
{
throw backgroundError;
}
}
}
catch (WebException ex)
{
string errorMsg = ex.Message;
if (ex.Response != null)
{
using (HttpWebResponse errorResponse = (HttpWebResponse)ex.Response)
{
errorMsg = ReadResponse(errorResponse);
}
}
throw new ApplicationException(errorMsg);
}
return(locationResult);
}
public void Update(SsdsBlobEntity blob, ConcurrencyPattern concurrencyPattern)
{
this.InsertOrUpdate(blob, HttpVerbs.Put, concurrencyPattern);
}
public void Update(SsdsBlobEntity blob, ConcurrencyPattern concurrencyPattern)
{
SsdsRestFacade facade = this.CreateFacade();
facade.Update(blob, concurrencyPattern);
}
/// <summary>
/// Updates the entity with the given concurrency pattern
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="item"></param>
/// <param name="id"></param>
/// <param name="pattern"></param>
public void Update <T>(T item, string id, ConcurrencyPattern pattern) where T : class, new()
{
Update(new SsdsEntity <T> {
Id = id, Entity = item
}, pattern);
}
private void Delete(string id, ConcurrencyPattern concurrencyPattern, string version)
{
SsdsRestFacade facade = this.CreateFacade();
facade.Delete(id, concurrencyPattern, version);
}
public void Delete(SsdsBlobEntity entity, ConcurrencyPattern concurrencyPattern)
{
this.Delete(entity.Id, concurrencyPattern, entity.Version);
}
public void Delete <T>(SsdsEntity <T> entity, ConcurrencyPattern concurrencyPattern) where T : class, new()
{
this.Delete(entity.Id, concurrencyPattern, entity.Version.ToString());
}
