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)); }