static void Main(string[] args)
{
if (args.Length > 1)
{
Environment.CurrentDirectory = args[1];
}
else
Environment.CurrentDirectory = args[0].Substring(0, args[0].Length - Path.GetFileName(args[0]).Length);
if (!File.Exists(args[0]))
throw new FileNotFoundException(args[0]);
if (!Path.IsPathRooted(args[0]))
args[0] = Path.Combine(Environment.CurrentDirectory, args[0]);
Assembly assembly = Assembly.LoadFile(args[0]);
Model model = new Model();
ModelMetaDataVisitor visitor = new ModelMetaDataVisitor(model);
foreach (IMetaData metadata in MetaDataFactory.FromAssembly(assembly, args.Length > 2 ? args[2] : null))
metadata.Accept(visitor);
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = assembly.GetName().Name + ".Proxies";
// Create a new assembly with one module
AssemblyBuilder newAssembly = Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave, Environment.CurrentDirectory);
newAssembly.SetCustomAttribute(new CustomAttributeBuilder(typeof(ProxyAssemblyAttribute).GetConstructor(Type.EmptyTypes), new object[0]));
ModuleBuilder moduleBuilder = newAssembly.DefineDynamicModule(assemblyName.Name, assemblyName.Name + ".dll", true);
EntityResolver resolver = new EntityResolver();
foreach (Entity e in model.Entities.Values)
{
Type t = assembly.GetType(e.Type);
if (t.IsInterface || t.IsAbstract)
continue;
resolver.GenerateType(t, moduleBuilder, model).CreateType();
}
newAssembly.Save(assemblyName.Name + ".dll");
}
public virtual Task <TableQuerySegment <TResult> > ExecuteQuerySegmentedAsync <TElement, TResult>(TableQuery <TElement> query, EntityResolver <TResult> resolver, TableContinuationToken token, TableRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken) where TElement : ITableEntity, new()
{
CommonUtility.AssertNotNull("query", query);
CommonUtility.AssertNotNull("resolver", resolver);
if (query.Provider != null)
{
return(query.Resolve(resolver).ExecuteSegmentedAsync(token, requestOptions, operationContext, cancellationToken));
}
return(query.ExecuteQuerySegmentedInternalAsync(token, ServiceClient, this, resolver, requestOptions, operationContext, cancellationToken));
}
public virtual Task <TableQuerySegment <TResult> > ExecuteQuerySegmentedAsync <TElement, TResult>(TableQuery <TElement> query, EntityResolver <TResult> resolver, TableContinuationToken token, TableRequestOptions requestOptions, OperationContext operationContext) where TElement : ITableEntity, new()
{
return(ExecuteQuerySegmentedAsync(query, resolver, token, requestOptions, operationContext, CancellationToken.None));
}
private static List <TResult> ExecuteQuery <T, TResult>(CloudTable table, TableQuery <T> query, EntityResolver <TResult> resolver, TableRequestOptions options) where T : ITableEntity, new()
{
List <TResult> retList = new List <TResult>();
TableQuerySegment <TResult> currSeg = null;
while (currSeg == null || currSeg.ContinuationToken != null)
{
Task <TableQuerySegment <TResult> > task = Task.Run(() => table.ExecuteQuerySegmentedAsync(query, resolver, currSeg != null ? currSeg.ContinuationToken : null, options, null));
task.Wait();
currSeg = task.Result;
retList.AddRange(currSeg.Results);
}
return(retList);
}
/**
* Register the entity resolver.
*
* @param resolver The new resolver.
* @see org.xml.sax.Parser#setEntityResolver
*/
public void setEntityResolver(EntityResolver resolver)
{
xmlReader.setEntityResolver(resolver);
}
public void setEntityResolver(EntityResolver resolver)
{
throw new NotImplementedException();
}
public virtual IEnumerable <TResult> ExecuteQuery <TResult>(TableQuery query, EntityResolver <TResult> resolver, TableRequestOptions requestOptions = null, OperationContext operationContext = null)
{
CommonUtility.AssertNotNull("query", query);
CommonUtility.AssertNotNull("resolver", resolver);
return(query.Execute(ServiceClient, this, resolver, requestOptions, operationContext));
}
internal ICancellableAsyncResult BeginExecuteQuerySegmentedInternal <TResult>(TableContinuationToken token, CloudTableClient client, string tableName, EntityResolver <TResult> resolver, TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
{
CommonUtility.AssertNotNullOrEmpty("tableName", tableName);
CommonUtility.AssertNotNull("resolver", resolver);
TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client);
operationContext = operationContext ?? new OperationContext();
return(Executor.BeginExecuteAsync(
QueryImpl(this, token, client, tableName, resolver, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
callback,
state));
}
internal IEnumerable <TResult> Execute <TResult>(CloudTableClient client, CloudTable table, EntityResolver <TResult> resolver, TableRequestOptions requestOptions, OperationContext operationContext)
{
CommonUtility.AssertNotNullOrEmpty("tableName", table.Name);
TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client);
operationContext = operationContext ?? new OperationContext();
IEnumerable <TResult> enumerable = CommonUtility.LazyEnumerable <TResult>(
(continuationToken) =>
{
TableQuerySegment <TResult> seg = this.ExecuteQuerySegmented((TableContinuationToken)continuationToken, client, table, resolver, modifiedOptions, operationContext);
return(new ResultSegment <TResult>(seg.Results)
{
ContinuationToken = seg.ContinuationToken
});
},
this.takeCount.HasValue ? this.takeCount.Value : long.MaxValue);
return(enumerable);
}
public static TableOperation Retrieve <TResult>(string partitionKey, string rowkey, EntityResolver <TResult> resolver)
{
CommonUtility.AssertNotNull("partitionKey", partitionKey);
CommonUtility.AssertNotNull("rowkey", rowkey);
// Create and return the table operation.
return(new TableOperation(null /* entity */, TableOperationType.Retrieve)
{
RetrievePartitionKey = partitionKey, RetrieveRowKey = rowkey, RetrieveResolver = (pk, rk, ts, prop, etag) => resolver(pk, rk, ts, prop, etag)
});
}
private static RESTCommand <TableQuerySegment <RESULT_TYPE> > QueryImpl <RESULT_TYPE>(TableQuery query, TableContinuationToken token, CloudTableClient client, CloudTable table, EntityResolver <RESULT_TYPE> resolver, TableRequestOptions requestOptions)
{
UriQueryBuilder builder = query.GenerateQueryBuilder(requestOptions.ProjectSystemProperties);
if (token != null)
{
token.ApplyToUriQueryBuilder(builder);
}
StorageUri tempUri = NavigationHelper.AppendPathToUri(client.StorageUri, table.Name);
RESTCommand <TableQuerySegment <RESULT_TYPE> > queryCmd = new RESTCommand <TableQuerySegment <RESULT_TYPE> >(client.Credentials, tempUri);
requestOptions.ApplyToStorageCommand(queryCmd);
queryCmd.CommandLocationMode = CommonUtility.GetListingLocationMode(token);
queryCmd.RetrieveResponseStream = true;
queryCmd.SignRequest = client.AuthenticationHandler.SignRequest;
queryCmd.Builder = builder;
queryCmd.ParseError = StorageExtendedErrorInformation.ReadFromStreamUsingODataLib;
queryCmd.BuildRequestDelegate = (uri, queryBuilder, timeout, useVersionHeader, ctx) => TableOperationHttpWebRequestFactory.BuildRequestForTableQuery(uri, queryBuilder, timeout, useVersionHeader, ctx, requestOptions.PayloadFormat.Value);
queryCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp != null ? resp.StatusCode : HttpStatusCode.Unused, null /* retVal */, cmd, ex);
queryCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
ResultSegment <RESULT_TYPE> resSeg = TableOperationHttpResponseParsers.TableQueryPostProcessGeneric <RESULT_TYPE, DynamicTableEntity>(cmd.ResponseStream, resolver.Invoke, resp, requestOptions, ctx, client.AccountName);
if (resSeg.ContinuationToken != null)
{
resSeg.ContinuationToken.TargetLocation = cmd.CurrentResult.TargetLocation;
}
return(new TableQuerySegment <RESULT_TYPE>(resSeg));
};
return(queryCmd);
}
/// <summary>
/// Executes a query asynchronously in segmented mode, using the specified <see cref="TableQuery{T}"/> query, <see cref="TableContinuationToken"/> continuation token, <see cref="TableRequestOptions"/> options, and <see cref="OperationContext"/> context, and applies the <see cref="EntityResolver"/> to the result.
/// </summary>
/// <typeparam name="T">The entity type of the query.</typeparam>
/// <typeparam name="R">The type into which the <see cref="EntityResolver"/> will project the query results.</typeparam>
/// <param name="table">The input <see cref="CloudTable"/>, which acts as the <c>this</c> instance for the extension method.</param>
/// <param name="query">A <see cref="TableQuery{T}"/> representing the query to execute.</param>
/// <param name="resolver">An <see cref="EntityResolver{R}"/> instance which creates a projection of the table query result entities into the specified type <c>R</c>.</param>
/// <param name="token">A <see cref="TableContinuationToken"/> object representing a continuation token from the server when the operation returns a partial result.</param>
/// <param name="requestOptions">A <see cref="TableRequestOptions"/> object that specifies execution options, such as retry policy and timeout settings, for the operation.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
/// <returns>A <see cref="TableQuerySegment{R}"/> containing the projection into type <c>R</c> of the results of executing the query.</returns>
public static IAsyncOperation <TableQuerySegment <R> > ExecuteQuerySegmentedAsync <T, R>(this CloudTable table, TableQuery <T> query, EntityResolver <R> resolver, TableContinuationToken token, TableRequestOptions requestOptions, OperationContext operationContext) where T : ITableEntity, new()
{
CommonUtils.AssertNotNull("query", query);
CommonUtils.AssertNotNull("resolver", resolver);
return(query.ExecuteQuerySegmentedAsync(token, table.ServiceClient, table.Name, resolver, requestOptions, operationContext));
}
/// <summary>
/// Executes a query asynchronously in segmented mode, using the specified <see cref="TableQuery{T}"/> query and <see cref="TableContinuationToken"/> continuation token, and applies the <see cref="EntityResolver"/> to the result.
/// </summary>
/// <typeparam name="T">The entity type of the query.</typeparam>
/// <typeparam name="R">The type into which the <see cref="EntityResolver"/> will project the query results.</typeparam>
/// <param name="table">The input <see cref="CloudTable"/>, which acts as the <c>this</c> instance for the extension method.</param>
/// <param name="query">A <see cref="TableQuery{T}"/> representing the query to execute.</param>
/// <param name="resolver">An <see cref="EntityResolver{R}"/> instance which creates a projection of the table query result entities into the specified type <c>R</c>.</param>
/// <param name="token">A <see cref="TableContinuationToken"/> object representing a continuation token from the server when the operation returns a partial result.</param>
/// <returns>A <see cref="TableQuerySegment{R}"/> containing the projection into type <c>R</c> of the results of executing the query.</returns>
public static IAsyncOperation <TableQuerySegment <R> > ExecuteQuerySegmentedAsync <T, R>(this CloudTable table, TableQuery <T> query, EntityResolver <R> resolver, TableContinuationToken token) where T : ITableEntity, new()
{
return(table.ExecuteQuerySegmentedAsync <T, R>(query, resolver, token, null /* requestOptions */, null /* operationContext */));
}
internal IEnumerable <TResult> ExecuteInternal <TResult>(CloudTableClient client, string tableName, EntityResolver <TResult> resolver, TableRequestOptions requestOptions, OperationContext operationContext)
{
CommonUtility.AssertNotNullOrEmpty("tableName", tableName);
CommonUtility.AssertNotNull("resolver", resolver);
TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client);
operationContext = operationContext ?? new OperationContext();
IEnumerable <TResult> enumerable = CommonUtility.LazyEnumerable <TResult>(
(continuationToken) =>
{
TableQuerySegment <TResult> seg =
#if SYNC
this.ExecuteQuerySegmentedInternal((TableContinuationToken)continuationToken, client, tableName, resolver, modifiedOptions, operationContext);
#else
this.EndExecuteQuerySegmentedInternal <TResult>(this.BeginExecuteQuerySegmentedInternal((TableContinuationToken)continuationToken, client, tableName, resolver, modifiedOptions, operationContext, null /* callback */, null /* state */));
#endif
return(new ResultSegment <TResult>(seg.Results)
{
ContinuationToken = seg.ContinuationToken
});
},
this.takeCount.HasValue ? this.takeCount.Value : long.MaxValue);
return(enumerable);
}
public virtual TableQuerySegment <TResult> ExecuteQuerySegmented <TResult>(TableQuery query, EntityResolver <TResult> resolver, TableContinuationToken token, TableRequestOptions requestOptions = null, OperationContext operationContext = null)
{
CommonUtility.AssertNotNull("query", query);
return(query.ExecuteQuerySegmented(token, ServiceClient, this, resolver, requestOptions, operationContext));
}
internal TableQuerySegment <TResult> ExecuteQuerySegmentedInternal <TResult>(TableContinuationToken token, CloudTableClient client, string tableName, EntityResolver <TResult> resolver, TableRequestOptions requestOptions, OperationContext operationContext)
{
CommonUtility.AssertNotNullOrEmpty("tableName", tableName);
CommonUtility.AssertNotNull("resolver", resolver);
TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client);
operationContext = operationContext ?? new OperationContext();
RESTCommand <TableQuerySegment <TResult> > cmdToExecute = QueryImpl(this, token, client, tableName, resolver, modifiedOptions);
return(Executor.ExecuteSync(cmdToExecute, modifiedOptions.RetryPolicy, operationContext));
}
public virtual Task <TableQuerySegment <TResult> > ExecuteQuerySegmentedAsync <TResult>(TableQuery query, EntityResolver <TResult> resolver, TableContinuationToken token)
{
return(ExecuteQuerySegmentedAsync(query, resolver, token, CancellationToken.None));
}
private static RESTCommand <TableQuerySegment <RESULT_TYPE> > QueryImpl <T, RESULT_TYPE>(TableQuery <T> query, TableContinuationToken token, CloudTableClient client, string tableName, EntityResolver <RESULT_TYPE> resolver, TableRequestOptions requestOptions)
{
Uri tempUri = NavigationHelper.AppendPathToUri(client.BaseUri, tableName);
UriQueryBuilder builder = query.GenerateQueryBuilder();
if (token != null)
{
token.ApplyToUriQueryBuilder(builder);
}
Uri reqUri = builder.AddToUri(tempUri);
RESTCommand <TableQuerySegment <RESULT_TYPE> > queryCmd = new RESTCommand <TableQuerySegment <RESULT_TYPE> >(client.Credentials, reqUri);
queryCmd.ApplyRequestOptions(requestOptions);
queryCmd.RetrieveResponseStream = true;
queryCmd.SignRequest = client.AuthenticationHandler.SignRequest;
queryCmd.BuildRequestDelegate = TableOperationHttpWebRequestFactory.BuildRequestForTableQuery;
queryCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp != null ? resp.StatusCode : HttpStatusCode.Unused, null /* retVal */, cmd, ex);
queryCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
ResultSegment <RESULT_TYPE> resSeg = TableOperationHttpResponseParsers.TableQueryPostProcessGeneric <RESULT_TYPE>(cmd.ResponseStream, resolver.Invoke, resp);
return(new TableQuerySegment <RESULT_TYPE>(resSeg));
};
return(queryCmd);
}
public virtual Task <TableQuerySegment <TResult> > ExecuteQuerySegmentedAsync <TResult>(TableQuery query, EntityResolver <TResult> resolver, TableContinuationToken token, TableRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
{
CommonUtility.AssertNotNull("query", query);
CommonUtility.AssertNotNull("resolver", resolver);
return(query.ExecuteQuerySegmentedAsync(token, ServiceClient, this, resolver, requestOptions, operationContext, cancellationToken));
}
/// <summary> /// Specify the <A HREF="../../../org/xml/sax/EntityResolver.html" title="interface in org.xml.sax"><CODE>EntityResolver</CODE></A> to be used to resolve /// entities present in the XML document to be parsed. /// </summary> abstract public void setEntityResolver(EntityResolver @er);
public virtual IEnumerable <TResult> ExecuteQuery <TElement, TResult>(TableQuery <TElement> query, EntityResolver <TResult> resolver, TableRequestOptions requestOptions = null, OperationContext operationContext = null) where TElement : ITableEntity, new()
{
CommonUtility.AssertNotNull("query", query);
CommonUtility.AssertNotNull("resolver", resolver);
if (query.Provider != null)
{
return(query.Resolve(resolver).Execute(requestOptions, operationContext));
}
return(query.ExecuteInternal(ServiceClient, this, resolver, requestOptions, operationContext));
}
/**
* Specify the {@link EntityResolver} to be used to resolve
* entities present in the XML document to be parsed. Setting
* this to <code>null</code> will result in the underlying
* implementation using it's own default implementation and
* behavior.
*
* @param er The <code>EntityResolver</code> to be used to resolve entities
* present in the XML document to be parsed.
*/
public abstract void setEntityResolver(EntityResolver er);
public virtual Task <TableQuerySegment <TResult> > ExecuteQuerySegmentedAsync <TElement, TResult>(TableQuery <TElement> query, EntityResolver <TResult> resolver, TableContinuationToken token, CancellationToken cancellationToken) where TElement : ITableEntity, new()
{
return(ExecuteQuerySegmentedAsync(query, resolver, token, null, null, cancellationToken));
}
/**
* Set the entity resolver.
*
* @param resolver The new entity resolver.
* @see org.xml.sax.XMLReader#setEntityResolver
*/
public void setEntityResolver(EntityResolver resolver)
{
entityResolver = resolver;
}
public override async Task <TableQuerySegment <TResult> > ExecuteQuerySegmentedAsync <TElement, TResult>(TableQuery <TElement> query, EntityResolver <TResult> resolver, TableContinuationToken token, TableRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
{
using (azure_storage_table_request.WithLabels(nameof(ExecuteQuerySegmentedAsync), this.Name).NewTimer())
return(await base.ExecuteQuerySegmentedAsync(query, resolver, token, requestOptions, operationContext, cancellationToken));
}
