Quick and dirty proxying of CloudTable

gistfile1.cs

public class CloudTableProxy
{
    CloudTable _table;

    public CloudTableProxy(CloudTable table)
    {
        _table = table;
    }

    public virtual string Name { get { return _table.Name; } }
    public virtual CloudTableClient ServiceClient { get { return _table.ServiceClient; } }
    public virtual Uri Uri { get { return _table.Uri; } }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginCreate(AsyncCallback callback, object state)
    {
        return _table.BeginCreate(callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginCreate(TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
    {
        return _table.BeginCreate(requestOptions, operationContext, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginCreateIfNotExists(AsyncCallback callback, object state)
    {
        return _table.BeginCreateIfNotExists(callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginCreateIfNotExists(TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
    {
        return _table.BeginCreateIfNotExists(requestOptions, operationContext, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginDelete(AsyncCallback callback, object state)
    {
        return _table.BeginDelete(callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginDelete(TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
    {
        return _table.BeginDelete(requestOptions, operationContext, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginDeleteIfExists(AsyncCallback callback, object state)
    {
        return _table.BeginDeleteIfExists(callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginDeleteIfExists(TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
    {
        return _table.BeginDeleteIfExists(requestOptions, operationContext, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginExecute(TableOperation operation, AsyncCallback callback, object state)
    {
        return _table.BeginExecute(operation, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginExecute(TableOperation operation, TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
    {
        return _table.BeginExecute(operation, requestOptions, operationContext, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginExecuteBatch(TableBatchOperation batch, AsyncCallback callback, object state)
    {
        return _table.BeginExecuteBatch(batch, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginExecuteBatch(TableBatchOperation batch, TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
    {
        return _table.BeginExecuteBatch(batch, requestOptions, operationContext, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginExecuteQuerySegmented<TElement>(TableQuery<TElement> query, TableContinuationToken token, AsyncCallback callback, object state) where TElement : ITableEntity, new()
    {
        return _table.BeginExecuteQuerySegmented<TElement>(query, token, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginExecuteQuerySegmented(TableQuery query, TableContinuationToken token, AsyncCallback callback, object state)
    {
        return _table.BeginExecuteQuerySegmented(query, token, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginExecuteQuerySegmented<TElement, R>(TableQuery<TElement> query, EntityResolver<R> resolver, TableContinuationToken token, AsyncCallback callback, object state) where TElement : ITableEntity, new()
    {
        return _table.BeginExecuteQuerySegmented<TElement, R>(query, resolver, token, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginExecuteQuerySegmented<TElement>(TableQuery<TElement> query, TableContinuationToken token, TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state) where TElement : ITableEntity, new()
    {
        return _table.BeginExecuteQuerySegmented<TElement>(query, token, requestOptions, operationContext, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginExecuteQuerySegmented(TableQuery query, TableContinuationToken token, TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
    {
        return _table.BeginExecuteQuerySegmented(query, token, requestOptions, operationContext, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginExecuteQuerySegmented<TElement, R>(TableQuery<TElement> query, EntityResolver<R> resolver, TableContinuationToken token, TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state) where TElement : ITableEntity, new()
    {
        return _table.BeginExecuteQuerySegmented<TElement, R>(query, resolver, token, requestOptions, operationContext, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginExists(AsyncCallback callback, object state)
    {
        return _table.BeginExists(callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginExists(TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
    {
        return _table.BeginExists(requestOptions, operationContext, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginGetPermissions(AsyncCallback callback, object state)
    {
        return _table.BeginGetPermissions(callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginGetPermissions(TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
    {
        return _table.BeginGetPermissions(requestOptions, operationContext, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginSetPermissions(TablePermissions permissions, AsyncCallback callback, object state)
    {
        return _table.BeginSetPermissions(permissions, callback, state);
    }

    [DoesServiceRequest]
    public virtual ICancellableAsyncResult BeginSetPermissions(TablePermissions permissions, TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
    {
        return _table.BeginSetPermissions(permissions, requestOptions, operationContext, callback, state);
    }

    [DoesServiceRequest]
    public virtual void Create(TableRequestOptions requestOptions = null, OperationContext operationContext = null)
    {
        _table.Create(requestOptions, operationContext);
    }

    [DoesServiceRequest]
    public virtual bool CreateIfNotExists(TableRequestOptions requestOptions = null, OperationContext operationContext = null)
    {
        return _table.CreateIfNotExists(requestOptions, operationContext);
    }

    [DoesServiceRequest]
    public virtual void Delete(TableRequestOptions requestOptions = null, OperationContext operationContext = null)
    {
        _table.Delete(requestOptions, operationContext);
    }

    [DoesServiceRequest]
    public virtual bool DeleteIfExists(TableRequestOptions requestOptions = null, OperationContext operationContext = null)
    {
        return _table.DeleteIfExists(requestOptions, operationContext);
    }

    public virtual void EndCreate(IAsyncResult asyncResult)
    {
        _table.EndCreate(asyncResult);
    }

    public virtual bool EndCreateIfNotExists(IAsyncResult asyncResult)
    {
        return _table.EndCreateIfNotExists(asyncResult);
    }

    public virtual void EndDelete(IAsyncResult asyncResult)
    {
        _table.EndDelete(asyncResult);
    }

    public virtual bool EndDeleteIfExists(IAsyncResult asyncResult)
    {
        return _table.EndDeleteIfExists(asyncResult);
    }

    public virtual TableResult EndExecute(IAsyncResult asyncResult)
    {
        return _table.EndExecute(asyncResult);
    }

    [DoesServiceRequest]
    public virtual IList<TableResult> EndExecuteBatch(IAsyncResult asyncResult) 
    {
        return _table.EndExecuteBatch(asyncResult);
    }

    public virtual TableQuerySegment<R> EndExecuteQuerySegmented<TElement, R>(IAsyncResult asyncResult)
    {
        return _table.EndExecuteQuerySegmented<TElement, R>(asyncResult);
    }

    public virtual TableQuerySegment<DynamicTableEntity> EndExecuteQuerySegmented(IAsyncResult asyncResult)
    {
        return _table.EndExecuteQuerySegmented(asyncResult);
    }

    public virtual TableQuerySegment<TElement> EndExecuteQuerySegmented<TElement>(IAsyncResult asyncResult)
    {
        return _table.EndExecuteQuerySegmented<TElement>(asyncResult);
    }

    public virtual bool EndExists(IAsyncResult asyncResult)
    {
        return _table.EndExists(asyncResult);
    }

    public virtual TablePermissions EndGetPermissions(IAsyncResult asyncResult)
    {
        return _table.EndGetPermissions(asyncResult);
    }

    public virtual void EndSetPermissions(IAsyncResult asyncResult)
    {
        _table.EndSetPermissions(asyncResult);
    }

    [DoesServiceRequest]
    public virtual TableResult Execute(TableOperation operation, TableRequestOptions requestOptions = null, OperationContext operationContext = null)
    {
        return _table.Execute(operation, requestOptions, operationContext);
    }

    [DoesServiceRequest]
    public virtual IList<TableResult> ExecuteBatch(TableBatchOperation batch, TableRequestOptions requestOptions = null, OperationContext operationContext = null)
    {
        return _table.ExecuteBatch(batch, requestOptions, operationContext);
    }

    [DoesServiceRequest]
    public virtual IEnumerable<TElement> ExecuteQuery<TElement>(TableQuery<TElement> query, TableRequestOptions requestOptions = null, OperationContext operationContext = null) where TElement : ITableEntity, new()
    {
        return _table.ExecuteQuery<TElement>(query, requestOptions, operationContext).ToList();
    }

    [DoesServiceRequest]
    public virtual IEnumerable<DynamicTableEntity> ExecuteQuery(TableQuery query, TableRequestOptions requestOptions = null, OperationContext operationContext = null)
    {
        return _table.ExecuteQuery(query, requestOptions, operationContext).ToList();
    }

    [DoesServiceRequest]
    public virtual IEnumerable<R> ExecuteQuery<TElement, R>(TableQuery<TElement> query, EntityResolver<R> resolver, TableRequestOptions requestOptions = null, OperationContext operationContext = null) where TElement : ITableEntity, new()
    {
        return _table.ExecuteQuery<TElement, R>(query, resolver, requestOptions, operationContext).ToList();
    }

    [DoesServiceRequest]
    public virtual TableQuerySegment<TElement> ExecuteQuerySegmented<TElement>(TableQuery<TElement> query, TableContinuationToken token, TableRequestOptions requestOptions = null, OperationContext operationContext = null) where TElement : ITableEntity, new()
    {
        return _table.ExecuteQuerySegmented<TElement>(query, token, requestOptions, operationContext);
    }

    [DoesServiceRequest]
    public virtual TableQuerySegment<DynamicTableEntity> ExecuteQuerySegmented(TableQuery query, TableContinuationToken token, TableRequestOptions requestOptions = null, OperationContext operationContext = null)
    {
        return _table.ExecuteQuerySegmented(query, token, requestOptions, operationContext);
    }

    [DoesServiceRequest]
    public virtual TableQuerySegment<R> ExecuteQuerySegmented<TElement, R>(TableQuery<TElement> query, EntityResolver<R> resolver, TableContinuationToken token, TableRequestOptions requestOptions = null, OperationContext operationContext = null) where TElement : ITableEntity, new()
    {
        return _table.ExecuteQuerySegmented<TElement, R>(query, resolver, token, requestOptions, operationContext);
    }

    [DoesServiceRequest]
    public virtual bool Exists(TableRequestOptions requestOptions = null, OperationContext operationContext = null)
    {
        return _table.Exists(requestOptions, operationContext);
    }

    [DoesServiceRequest]
    public virtual TablePermissions GetPermissions(TableRequestOptions requestOptions = null, OperationContext operationContext = null)
    {
        return _table.GetPermissions(requestOptions, operationContext);
    }

    public virtual string GetSharedAccessSignature(SharedAccessTablePolicy policy, string accessPolicyIdentifier, string startPartitionKey, string startRowKey, string endPartitionKey, string endRowKey)
    {
        return _table.GetSharedAccessSignature(policy, accessPolicyIdentifier, startPartitionKey, startRowKey, endPartitionKey, endRowKey);
    }

    [DoesServiceRequest]
    public virtual void SetPermissions(TablePermissions permissions, TableRequestOptions requestOptions = null, OperationContext operationContext = null)
    {
        _table.SetPermissions(permissions, requestOptions, operationContext);
    }

    public override string ToString()
    {
        return _table.ToString();
    }
}