public IQueryable <TEntity> QueryableQuery(QueryDelegate query = null, LoadOptionsDelegate options = null, TDataContext dataContext = null)
{
FailIf(dataContext == null, "Parameter (dataContext) cannot be null");
var queryable = Queryable(options, dataContext);
return(query != null?query(queryable) : queryable);
}
public QueryExecutor(
ISchema schema,
IServiceProvider applicationServices,
QueryDelegate queryDelegate,
FieldMiddleware fieldMiddleware)
{
Schema = schema
?? throw new ArgumentNullException(nameof(schema));
_applicationServices = applicationServices
?? throw new ArgumentNullException(nameof(applicationServices));
_queryDelegate = queryDelegate
?? throw new ArgumentNullException(nameof(queryDelegate));
if (Schema.Services != null)
{
IEnumerable <IDiagnosticObserver> observers = Schema.Services
.GetService <IEnumerable <IDiagnosticObserver> >();
if (observers != null)
{
QueryExecutionDiagnostics diagnosticEvents = _applicationServices
.GetService <QueryExecutionDiagnostics>();
diagnosticEvents.Subscribe(observers);
}
}
_fieldMiddlewareCompiler = new FieldMiddlewareCompiler(
schema, fieldMiddleware);
}
public static void RunQuery(string queryName, QueryDelegate query, PrintCopyDelegate printCopy, Library library)
{
Console.WriteLine("Executing {0} query ...", queryName);
var swQuery = Stopwatch.StartNew();
var result = query(library);
swQuery.Stop();
Console.WriteLine("Printing query results ...");
var parts = queryName.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var fileName = new System.Text.StringBuilder("Result");
Array.ForEach(parts, p => {
fileName.Append(char.ToUpperInvariant(p[0]));
fileName.Append(p.Substring(1).ToLowerInvariant());
});
fileName.Append(".txt");
Stopwatch swPrint = null;
using (var writer = new System.IO.StreamWriter(fileName.ToString())) {
swPrint = Stopwatch.StartNew();
foreach (var c in result)
{
printCopy(writer, c);
}
swPrint.Stop();
}
Console.WriteLine("Query time: {0} s", swQuery.Elapsed.TotalSeconds);
Console.WriteLine("Print time: {0} s", swPrint.Elapsed.TotalSeconds);
Console.WriteLine();
}
internal static QueryDelegate CreateDelegate <TMiddleware>(
Func <IServiceProvider, QueryDelegate, TMiddleware> factory,
QueryDelegate next)
where TMiddleware : class
{
object sync = new object();
TMiddleware middleware = null;
var compiled = MiddlewareActivator
.CompileMiddleware <TMiddleware, IQueryContext>();
return(context =>
{
if (middleware == null)
{
lock (sync)
{
if (middleware == null)
{
middleware = factory(context.Services, next);
}
}
}
return compiled(context, context.Services, middleware);
});
}
public InstrumentationMiddleware(
QueryDelegate next,
QueryExecutionDiagnostics diagnosticEvents)
{
_next = next ?? throw new ArgumentNullException(nameof(next));
_diagnosticEvents = diagnosticEvents
?? throw new ArgumentNullException(nameof(diagnosticEvents));
}
public RequestTimeoutMiddleware(
QueryDelegate next,
IRequestTimeoutOptionsAccessor options)
{
_next = next
?? throw new ArgumentNullException(nameof(next));
_options = options ??
throw new ArgumentNullException(nameof(options));
}
public ExceptionMiddleware(
QueryDelegate next,
IErrorHandler errorHandler)
{
_next = next
?? throw new ArgumentNullException(nameof(next));
_errorHandler = errorHandler
?? throw new ArgumentNullException(nameof(errorHandler));
}
public ResolveOperationMiddleware(
QueryDelegate next,
Cache <OperationDefinitionNode> queryCache)
{
_next = next
?? throw new ArgumentNullException(nameof(next));
_queryCache = queryCache
?? new Cache <OperationDefinitionNode>(Defaults.CacheSize);
}
public QueryExecutor(
ISchema schema,
IServiceProvider applicationServices,
QueryDelegate queryDelegate,
FieldMiddleware fieldMiddleware)
: this(schema, queryDelegate, fieldMiddleware)
{
_applicationServices = applicationServices
?? throw new ArgumentNullException(nameof(applicationServices));
}
private static bool ExecuteQuery(QueryDelegate query, Object data)
{
lock (LOCK)
{
XmlDocument doc = new XmlDocument();
doc.Load(FullPath);
return(query(doc, data));
}
}
public MaxComplexityMiddleware(
QueryDelegate next,
IValidateQueryOptionsAccessor options,
ComplexityCalculation complexityCalculation)
{
_next = next
?? throw new ArgumentNullException(nameof(next));
_options = options
?? throw new ArgumentNullException(nameof(options));
_calculation = complexityCalculation ?? DefaultComplexity;
}
private QueryDelegate Compile(IEnumerable <QueryMiddleware> components)
{
QueryDelegate current = context => Task.CompletedTask;
foreach (QueryMiddleware component in components.Reverse())
{
current = component(current);
}
return(current);
}
public LocateImagesResult LocateImages(LocateImagesRequest request)
{
QueryDelegate <ImageIdentifier> query = (criteria, studyRootQuery) => studyRootQuery.ImageQuery(criteria);
LocateFailureInfo[] failures;
var results = new GenericQuery <ImageIdentifier>(query, true).Query(request.Criteria, out failures);
return(new LocateImagesResult {
Images = results, Failures = failures
});
}
public QueryExecuter(
ISchema schema,
IServiceProvider applicationServices,
QueryDelegate queryDelegate)
{
Schema = schema
?? throw new ArgumentNullException(nameof(schema));
_applicationServices = applicationServices
?? throw new ArgumentNullException(nameof(applicationServices));
_queryDelegate = queryDelegate
?? throw new ArgumentNullException(nameof(queryDelegate));
}
public ValidateQueryMiddleware(
QueryDelegate next,
IQueryValidator validator,
Cache <QueryValidationResult> validatorCache)
{
_next = next ??
throw new ArgumentNullException(nameof(next));
_validator = validator ??
throw new ArgumentNullException(nameof(validator));
_validatorCache = validatorCache ??
new Cache <QueryValidationResult>(Defaults.CacheSize);
}
private static QueryDelegate Compile(
IReadOnlyList <QueryMiddleware> components)
{
QueryDelegate next = context => Task.CompletedTask;
for (var i = components.Count - 1; i >= 0; i--)
{
next = components[i].Invoke(next);
}
return(next);
}
public Form1()
{
InitializeComponent();
_corpus = Corpus.init();
var crawler = new Crawler(_corpus);
_querier = new Querier(_corpus);
_suggestMethod = new Func <string, CancellationTokenSource, HashSet <string> >(_querier.AutoCompleteWord);
_queryMethod = new QueryDelegate(_querier.Query);
}
public ExecuteOperationMiddleware(
QueryDelegate next,
IExecutionStrategyResolver strategyResolver,
Cache <DirectiveLookup> directiveCache)
{
_next = next
?? throw new ArgumentNullException(nameof(next));
_strategyResolver = strategyResolver
?? throw new ArgumentNullException(nameof(strategyResolver));
_directiveCache = directiveCache
?? throw new ArgumentNullException(nameof(directiveCache));
}
public RemoteQueryMiddleware(QueryDelegate next, string schemaName)
{
if (string.IsNullOrEmpty(schemaName))
{
throw new ArgumentException(
StitchingResources.SchemaName_EmptyOrNull,
nameof(schemaName));
}
_next = next ?? throw new ArgumentNullException(nameof(next));
_schemaName = schemaName;
}
public ParseQueryMiddleware(
QueryDelegate next,
IQueryParser parser,
Cache <DocumentNode> queryCache)
{
_next = next
?? throw new ArgumentNullException(nameof(next));
_parser = parser
?? throw new ArgumentNullException(nameof(parser));
_queryCache = queryCache
?? throw new ArgumentNullException(nameof(queryCache));
}
private static void ExecQuery(string sql, QueryDelegate qd)
{
SqlCommand query = conn.CreateCommand();
query.CommandText = sql;
SqlDataReader reader = query.ExecuteReader();
while (reader.Read())
{
qd(reader);
}
reader.Close();
}
public QueryExecutor(
ISchema schema,
QueryDelegate queryDelegate,
FieldMiddleware fieldMiddleware)
{
Schema = schema
?? throw new ArgumentNullException(nameof(schema));
_queryDelegate = queryDelegate
?? throw new ArgumentNullException(nameof(queryDelegate));
_fieldMiddlewareCompiler = new FieldMiddlewareCompiler(
schema, fieldMiddleware);
}
public ReadPersistedQueryMiddleware(
QueryDelegate next,
Cache <ICachedQuery> queryCache,
IReadStoredQueries readStoredQueries,
IErrorHandler errorHandler)
{
_next = next
?? throw new ArgumentNullException(nameof(next));
_queryCache = queryCache
?? throw new ArgumentNullException(nameof(queryCache));
_readStoredQueries = readStoredQueries
?? throw new ArgumentNullException(nameof(readStoredQueries));
_errorHandler = errorHandler
?? throw new ArgumentNullException(nameof(errorHandler));
}
public ParseQueryMiddleware(
QueryDelegate next,
IQueryParser parser,
Cache <ICachedQuery> queryCache,
QueryExecutionDiagnostics diagnosticEvents)
{
_next = next
?? throw new ArgumentNullException(nameof(next));
_parser = parser
?? throw new ArgumentNullException(nameof(parser));
_queryCache = queryCache
?? throw new ArgumentNullException(nameof(queryCache));
_diagnosticEvents = diagnosticEvents
?? throw new ArgumentNullException(nameof(diagnosticEvents));
}
public IQueryExecuter Build(ISchema schema)
{
if (schema == null)
{
throw new ArgumentNullException(nameof(schema));
}
IServiceProvider services = CopyServiceCollection()
.AddSingleton <ISchema>(schema)
.BuildServiceProvider();
QueryDelegate middleware = Compile(_middlewareComponents);
return(new QueryExecuter(schema, services, middleware));
}
public ExecuteOperationMiddleware(
QueryDelegate next,
IExecutionStrategyResolver strategyResolver,
Cache <DirectiveMiddlewareCompiler> directiveCache,
QueryExecutionDiagnostics diagnosticEvents)
{
_next = next ??
throw new ArgumentNullException(nameof(next));
_strategyResolver = strategyResolver ??
throw new ArgumentNullException(nameof(strategyResolver));
_cache = directiveCache ??
throw new ArgumentNullException(nameof(directiveCache));
_diagnosticEvents = diagnosticEvents ??
throw new ArgumentNullException(nameof(diagnosticEvents));
}
public QueryExecutor(
ISchema schema,
IServiceProvider applicationServices,
QueryDelegate queryDelegate,
FieldMiddleware fieldMiddleware)
{
Schema = schema
?? throw new ArgumentNullException(nameof(schema));
_applicationServices = applicationServices
?? throw new ArgumentNullException(nameof(applicationServices));
_queryDelegate = queryDelegate
?? throw new ArgumentNullException(nameof(queryDelegate));
_fieldMiddlewareCompiler = new FieldMiddlewareCompiler(
schema, fieldMiddleware);
}
public void UnsubscribeFromVote <T, C>(string queryName, QueryDelegate <Vote <T>, C> answer)
{
QueryKey key = new QueryKey(queryName, typeof(T));
if (!voteListeners.ContainsKey(key))
{
voteListeners.Add(key, new Dictionary <int, VoteQueryDelegateWrapper>());
}
int answerHash = answer.GetHashCode();
if (voteListeners[key].ContainsKey(answerHash))
{
voteListeners[key].Remove(answerHash);
}
}
public WritePersistedQueryMiddleware(
QueryDelegate next,
IWriteStoredQueries writeStoredQueries,
IDocumentHashProvider documentHashProvider)
{
if (documentHashProvider is null)
{
throw new ArgumentNullException(nameof(documentHashProvider));
}
_next = next
?? throw new ArgumentNullException(nameof(next));
_writeStoredQueries = writeStoredQueries
?? throw new ArgumentNullException(nameof(writeStoredQueries));
_hashName = documentHashProvider.Name;
}
public void UnsubscribeFromBool <C>(string queryName, QueryDelegate <BoolResult, C> answer)
{
QueryKey key = new QueryKey(queryName, typeof(BoolResult));
if (!boolListeners.ContainsKey(key))
{
boolListeners.Add(key, new Dictionary <int, QueryDelegateWrapper>());
}
int answerHash = answer.GetHashCode();
if (boolListeners[key].ContainsKey(answerHash))
{
boolListeners[key].Remove(answerHash);
}
}
/// <summary>
/// Query a whois server specifying the specified domain to query asynchronously. In this case, it uses the default whois servers.
/// </summary>
/// <param name="domainToQuery">Domain to query.</param>
/// <param name="callBack">Callback function.</param>
/// <returns>IAsyncResult object that represents the result of the QueryAsync operation.</returns>
/// <example>
/// <code>
/// [C#]
///
/// WhoIs whoIs = new WhoIs();
/// IAsyncResult state = whoIs.QueryAsync("activeup.com",new AsyncCallback(MyCallbackWhoIs));
///
/// public void MyCallbackWhoIs(IAsyncResult state)
/// {
/// try
/// {
/// string result = whoIs.QueryAsyncResult(state);
/// Console.WriteLine(result);
/// }
///
/// catch(WhoisException we)
/// {
/// Console.WriteLine("WhoisException : " + we.Message);
/// }
///
/// catch(Exception ex)
/// {
/// Console.WriteLine("An unhandled exception was thrown : " + ex.Message);
/// }
/// }
///
/// [VB.NET]
///
/// Private whoIs As whoIs = New whoIs()
/// Dim state As IAsyncResult = whoIs.QueryAsync("activeup.com", New AsyncCallback(AddressOf MyCallbackWhoIs))
///
/// Public Sub MyCallbackWhoIs(ByVal state As IAsyncResult)
///
/// Try
///
/// Dim result As String = whoIs.QueryAsyncResult(state)
/// Console.WriteLine(result)
///
/// Catch we As WhoisException
/// Console.WriteLine("WhoisException : " + we.Message)
///
/// Catch ex As Exception
/// Console.WriteLine("An unhandled exception was thrown : " + ex.Message)
///
/// End Try
///
/// End Sub
/// </code>
/// </example>
public IAsyncResult QueryAsync(string domainToQuery,AsyncCallback callBack)
{
_queryDelegate = new QueryDelegate(_Query);
return _queryDelegate.BeginInvoke(null,domainToQuery,false,callBack,null);
}
public StartupsController()
{
QueryAll = Regiztry.GetQueryDelegate<IList<Startup>>();
WorkOnStartup = Regiztry.GetGenericWorkOnDelegate<Startup>();
}
/// <summary>
/// Query a whois server specifying the specified ServerCollection object and domain to query asynchronously.
/// </summary>
/// <param name="servers">Collection contening a list of whois server.</param>
/// <param name="domainToQuery">Domain to query.</param>
/// <param name="callBack">Callback function</param>
/// <returns>IAsyncResult object that represents the result of the QueryAsync operation.</returns>
/// <example>
/// <code>
/// [C#]
///
/// ServerCollection servers = new ServerCollection();
///
/// Server server1 = new Server();
/// server1.Host = "whois.networksolutions.com";
/// server1.Port = 43;
/// server1.Domain = ".com";
/// servers.Add(server1);
///
/// Server server2 = new Server();
/// server2.Host = "whois.nic.co.uk";
/// server2.Port = 43;
/// server2.Domain = ".co.uk";
/// servers.Add(server2);
///
/// WhoIs whoIs = new WhoIs();
/// IAsyncResult state = whoIs.QueryAsync(servers,"activeup.com",new AsyncCallback(MyCallbackWhoIs));
///
/// public void MyCallbackWhoIs(IAsyncResult state)
/// {
/// try
/// {
/// string result = whoIs.QueryAsyncResult(state);
/// Console.WriteLine(result);
/// }
///
/// catch(WhoisException we)
/// {
/// Console.WriteLine("WhoisException : " + we.Message);
/// }
///
/// catch(Exception ex)
/// {
/// Console.WriteLine("An unhandled exception was thrown : " + ex.Message);
/// }
/// }
///
/// [VB.NET]
///
/// Private whoIs As whoIs = New whoIs()
///
/// Dim servers As New ServerCollection()
///
/// Dim server1 As New Server()
/// server1.Host = "whois.networksolutions.com"
/// server1.Port = 43
/// server1.Domain = ".com"
/// servers.Add(server1)
///
/// Dim server2 As New Server()
/// server2.Host = "whois.nic.co.uk"
/// server2.Port = 43
/// server2.Domain = ".co.uk"
/// servers.Add(server2)
/// Dim state As IAsyncResult = whoIs.QueryAsync(servers, New AsyncCallback(AddressOf MyCallbackWhoIs))
///
/// Public Sub MyCallbackWhoIs(ByVal state As IAsyncResult)
///
/// Try
///
/// Dim result As String = whoIs.QueryAsyncResult(state)
/// Console.WriteLine(result)
///
/// Catch we As WhoisException
/// Console.WriteLine("WhoisException : " + we.Message)
///
/// Catch ex As Exception
/// Console.WriteLine("An unhandled exception was thrown : " + ex.Message)
///
/// End Try
///
/// End Sub
/// </code>
/// </example>
public IAsyncResult QueryAsync(ServerCollection servers, string domainToQuery,AsyncCallback callBack)
{
_queryDelegate = new QueryDelegate(_Query);
return _queryDelegate.BeginInvoke(servers,domainToQuery,false,callBack,null);
}
/// <summary>
/// Query a whois server specifying the specified host, port and domain to query asynchronously.
/// </summary>
/// <param name="host">Host of the whois server.</param>
/// <param name="port">Port of the whois server.</param>
/// <param name="domainToQuery">Domain to query.</param>
/// <param name="callBack">Callback function.</param>
/// <returns>IAsyncResult object that represents the result of the QueryAsync operation.</returns>
/// <example>
/// <code>
/// [C#]
///
/// WhoIs whoIs = new WhoIs();
/// IAsyncResult state = whoIs.QueryAsync("whois.networksolutions.com",43,"activeup.com",new AsyncCallback(MyCallbackWhoIs));
///
/// public void MyCallbackWhoIs(IAsyncResult state)
/// {
/// try
/// {
/// string result = whoIs.QueryAsyncResult(state);
/// Console.WriteLine(result);
/// }
///
/// catch(WhoisException we)
/// {
/// Console.WriteLine("WhoisException : " + we.Message);
/// }
///
/// catch(Exception ex)
/// {
/// Console.WriteLine("An unhandled exception was thrown : " + ex.Message);
/// }
/// }
///
/// [VB.NET]
///
/// Private whoIs As whoIs = New whoIs()
/// Dim state As IAsyncResult = whoIs.QueryAsync("whois.networksolutions.com",43,"activeup.com", New AsyncCallback(AddressOf MyCallbackWhoIs))
///
/// Public Sub MyCallbackWhoIs(ByVal state As IAsyncResult)
///
/// Try
///
/// Dim result As String = whoIs.QueryAsyncResult(state)
/// Console.WriteLine(result)
///
/// Catch we As WhoisException
/// Console.WriteLine("WhoisException : " + we.Message)
///
/// Catch ex As Exception
/// Console.WriteLine("An unhandled exception was thrown : " + ex.Message)
///
/// End Try
///
/// End Sub
/// </code>
/// </example>
public IAsyncResult QueryAsync(string host, int port, string domainToQuery,AsyncCallback callBack)
{
ServerCollection servers = new ServerCollection();
servers.Add(new Server(host,port));
_queryDelegate = new QueryDelegate(_Query);
return _queryDelegate.BeginInvoke(servers,domainToQuery,false,callBack,null);
}
public object ExecuteDelegate(QueryDelegate d)
{
return d();
}
private static bool ExecuteQuery(QueryDelegate query, Object data)
{
lock (LOCK)
{
XmlDocument doc = new XmlDocument();
doc.Load(FullPath);
return query(doc, data);
}
}
public MerchandiseController()
{
QueryAll = RegiztryQuery.GetQueryDelegate<IList<Merchandise>>();
QueryById = RegiztryQuery.GetQueryDelegate<Merchandise>();
}
public HomeController()
{
queryAll = RegiztryQuery.GetQueryDelegate<IList<ContactMessage>>();
}
public StartupsController()
{
QueryAll = RegiztryQuery.GetQueryDelegate<IList<Startup>>();
}
