//***** Несколько параметров суммирования /// <summary> /// Вычисление суммы /// </summary> /// <typeparam name="TValue">Тип данных суммируемого поля</typeparam> /// <param name="fieldName">Имя поля</param> /// <returns></returns> private TOut Sum <TValue, TOut>(Func <object[], TOut> expr, params string[] fieldNames) where TValue : struct where TOut : class { var list = Compile(currentSession); //Компилируем критерий //object[] sum = null; if (list != null) //Создан ли запрос? { //Да, выполняем его //var fields = new List<global::NHibernate.Criterion.IProjection>(); foreach (var fieldName in fieldNames) { QueryProjection.Add(global::NHibernate.Criterion.Projections.Sum(fieldName)); } //list.SetProjection(fields.ToArray()); //sum = (object[])list.List()[0]; return((TOut)expr.DynamicInvoke(ToList(x => x)[0])); } return(null); }
protected static T AssertInvokeThrows <T>(Func <Page> func) where T : Exception { var x = Assert.Throws <TargetInvocationException>(() => func.DynamicInvoke()); Assert.That(x.InnerException, Is.AssignableTo(typeof(PageObjectException))); return((T)x.InnerException); }
/// <summary> /// Создание анонимных объектов /// </summary> /// <typeparam name="TResult">Тип анаимных объектов (Указывать НЕ НАДО!)</typeparam> /// <param name="expr">Лямбда выражения приведения object[] к анонимному объекту</param> /// <returns></returns> public IList <TResult> ToList <TResult>(Func <object[], TResult> expr) { IList <TResult> result = new List <TResult>(); IList list; var crit = Compile(currentSession); if (crit != null) { list = crit.List(); } else { list = new List <TResult>(); } object[] args = new object[1]; foreach (var value in list) { args[0] = value; var exprValue = expr.DynamicInvoke(args); result.Add((TResult)exprValue); } return(result); }
public MvcHtmlString Header(Func<dynamic, Object> markup) { var output = "<div class=\"panel-heading\">"; output += markup.DynamicInvoke(ViewContext); output += "</div>"; return MvcHtmlString.Create(output); }
public static List <T8> DynamicInvoke <T, T2, T3, T4, T5, T6, T7, T8>(this Func <T, T2, T3, T4, T5, T6, T7, T8> self, List <object[]> args) { List <T8> ret_list = new List <T8>(); args.ForEach((object[] o) => ret_list.Add((T8)self.DynamicInvoke(o))); return(ret_list); }
public override void Run() { // Func 委托 Func <int, RunModel[]> createDelegate = this.CreateCollection; RunModel[] models = null; /* .Net Core 3.0 pre 暂不支持此操作 * BeginInvoke: * 在新线程异步执行委托,不会阻塞当前线程; * 可以传入 AsyncCallback 在调用结束后执行回调; * 可以使用 IAsyncResult.AsyncWaitHandle.WaitOne() 和 EndInvoke() 阻塞当前线程并等待异步委托调用结束; * 需要使用 EndInvoke() 获取 Func<> 委托的返回结果; */ Helper.PrintLine("BeginInvoke"); /* * IAsyncResult result = createDelegate.BeginInvoke(3, new AsyncCallback(r => this.PrintIAsyncResult(r)), "BeginInvoke"); * this.PrintIAsyncResult(result); * Helper.PrintLine("EndInvoke"); * models = createDelegate.EndInvoke(result); * Helper.PrintLine($"结果:{string.Join("、", models.Select(m => m.Name))}"); */ /* Invoke: * 使用 Invoke 使委托在 UI 主线程调用 */ Helper.PrintLine("Invoke"); models = createDelegate.Invoke(6); Helper.PrintLine($"结果:{string.Join("、", models.Select(m => m.Name))}"); Helper.PrintLine("DynamicInvoke"); models = createDelegate.DynamicInvoke(6) as RunModel[]; Helper.PrintLine($"结果:{string.Join("、", models.Select(m => m.Name))}"); }
public void DynamicInvoke() { Func <int, int> adder = x => x + 1; var result = adder.DynamicInvoke(1); AssertEquals(result, 2); }
public void SubscribeArray <T, TH>(Func <TH> handler, string topicName, int maxConcurrent = 1) where T : Event where TH : IArrayEventHandler <T> { new Thread(async() => { try { string subscription = _busSettings.SubscriptionName.ToLower() + "-" + topicName.ToLower(); SubscriberClient subscriber; CreateSubscription(topicName, subscription); // Pull messages from the subscription using SimpleSubscriber. SubscriptionName subscriptionName = new SubscriptionName(_busSettings.ProjectId, subscription); subscriber = await SubscriberClient.CreateAsync( subscriptionName, null, new SubscriberClient.Settings { FlowControlSettings = new Google.Api.Gax.FlowControlSettings(maxConcurrent, null) } ); await subscriber.StartAsync(async(PubsubMessage message, CancellationToken token) => { T[] events; if ((_busSettings.Token != null && _busSettings.Token != "") && (!message.Attributes.ContainsKey("token") || message.Attributes["token"] != _busSettings.Token)) { return(SubscriberClient.Reply.Ack); } try{ events = JsonConvert.DeserializeObject <T[]>(message.Data.ToStringUtf8()); }catch (JsonException ex) { Console.WriteLine(ex.Message); return(SubscriberClient.Reply.Ack); } for (int i = 0; i < events.Length; i++) { events[i].EventId = message.MessageId; events[i].Timestamp = message.PublishTime.Seconds * 1000; } var invoke = handler.DynamicInvoke(); var concreteType = typeof(IArrayEventHandler <>).MakeGenericType(typeof(T)); EventResult result = await(Task <EventResult>) concreteType.GetMethod("Handle").Invoke(invoke, new object[] { events, null }); if (result == EventResult.Success) { return(SubscriberClient.Reply.Ack); } else { return(SubscriberClient.Reply.Nack); } }); new Thread(() => SubscribeArray <T, TH>(handler, topicName, maxConcurrent)).Start(); } // Restart when connection fail catch (RpcException ex) { Console.WriteLine(ex.Message); new Thread(() => SubscribeArray <T, TH>(handler, topicName, maxConcurrent)).Start(); return; } }).Start(); }
/// <summary> Executes the given delegate on the session thread, then calls back to the main thread for error or completion. </summary> public static void Invoke <T>(Func <T> delegateValue, ErrorHandler onError, System.Action <T> onCompletion, params object[] arguments) { Dispatcher dispatcher = CheckedDispatcher; QueueSessionAction ( () => { try { var result = (T)delegateValue.DynamicInvoke(arguments); if (onCompletion != null) { dispatcher.BeginInvoke(onCompletion, result); } } catch (Exception exception) { if (onError != null) { dispatcher.BeginInvoke(onError, exception is TargetInvocationException ? ((TargetInvocationException)exception).InnerException : exception); } else { System.Diagnostics.Debug.WriteLine("Unhandled exception: ", exception); } } } ); }
protected TResult useDbContext <TResult>(Func <BdcContext, TResult> action) { using (var __dbcontext = new BdcContext()) { return((TResult)action.DynamicInvoke(__dbcontext)); } }
public void DynamicInvoke() { Func <int, int> adder = x => x + 1; var result = adder.DynamicInvoke(1); QUnit.AreEqual(result, 2); }
public void Subscribe <T, TH>(Func <TH> handler, string topicName, int maxConcurrent = 1) where T : Event where TH : IEventHandler <T> { if (!_conn.IsConnected) { _conn = ConnectionMultiplexer.Connect(_conn.Configuration); } _conn.PreserveAsyncOrder = true; var subscriber = _conn.GetSubscriber(); subscriber.Subscribe(topicName, (channel, message) => { T eventMessage = null; try{ eventMessage = JsonConvert.DeserializeObject <T>(message); }catch (JsonException ex) { Console.WriteLine(ex.Message); return; } var invoke = handler.DynamicInvoke(); var concreteType = typeof(IEventHandler <>).MakeGenericType(typeof(T)); var task = (Task <EventResult>)concreteType.GetMethod("Handle").Invoke(invoke, new object[] { eventMessage, null }); task.GetAwaiter(); }); }
public static T Execute <TClient, T>(this TClient client, Func <TClient, T> execution) where TClient : IBaseService { var channel = (IChannel)client; T result; try { channel.Open(); result = (T)execution.DynamicInvoke(client); } catch (Exception ex) { var exception = HandleException(ex); if (exception != null) { throw exception; } throw; } finally { CloseChannel(channel); } return(result); }
public static List <T3> DynamicInvoke <T, T2, T3>(this Func <T, T2, T3> self, List <object[]> args) { List <T3> ret_list = new List <T3>(); args.ForEach((object[] o) => ret_list.Add((T3)self.DynamicInvoke(o))); return(ret_list); }
public void DynamicInvoke_InvalidArguments () { Delegate d = new Func<int, int> (TestMethod); try { d.DynamicInvoke (null); Assert.Fail ("#1"); } catch (TargetParameterCountException) { } try { d.DynamicInvoke (new object [0]); Assert.Fail ("#2"); } catch (TargetParameterCountException) { } }
public static void ExecuteScheduler(string tableName, string action_type, JsonValue whereKV, JsonValue schedule, JsonValue setDict, Func <string, bool> action, Action notify) { string statusUpdate = string.Empty; var switchMode = "stop"; if (action_type == "schedule") { var start = DateTime.Parse(schedule["start"].ReadAs <string>()).TimeOfDay; var end = DateTime.Parse(schedule["end"].ReadAs <string>()).TimeOfDay; //MON,TUE,WED,THU,FRI,SAT,SUN var weekDays = new List <string>(); schedule["weekdays"].ToList().ForEach(a => weekDays.Add(a.Value.ReadAs <string>())); var interval = int.Parse(schedule["interval"].ReadAs <string>()); while (true) { var nowWeekDay = DateTime.Now.DayOfWeek.ToString().Substring(0, 3).ToUpper(); var nowTime = DateTime.Now.TimeOfDay; if (weekDays.Contains(nowWeekDay) && nowTime > start && nowTime < end) { action.DynamicInvoke(switchMode); switchMode = "play"; } else { if (switchMode != "wait") { setDict["status"] = "wait"; statusUpdate = MariaQueryBuilder.UpdateQuery(tableName, whereKV, setDict); MariaDBConnector.Instance.SetQuery("DynamicQueryExecuter", statusUpdate); notify.DynamicInvoke(); } switchMode = "wait"; } Thread.Sleep(interval); } } else { action.DynamicInvoke(switchMode); setDict["status"] = "stop"; statusUpdate = MariaQueryBuilder.UpdateQuery(tableName, whereKV, setDict); MariaDBConnector.Instance.SetQuery("DynamicQueryExecuter", statusUpdate); notify.DynamicInvoke(); } }
public static MvcHtmlString CssMinify(this HtmlHelper helper, Func <object, object> markup) { string notMinifiedCss = (markup.DynamicInvoke(helper.ViewContext) ?? "").ToString(); var minifier = new Minifier(); var minifiedJs = minifier.MinifyStyleSheet(notMinifiedCss); return(new MvcHtmlString(minifiedJs)); }
public TResult DoWithPleaseWait <TResult>(Func <TResult> func) { pleaseWaitForm.Show(); TResult result = (TResult)func.DynamicInvoke(); pleaseWaitForm.Hide(); return(result); }
public static T Measure<T>(Func<T> func, params object[] args) { float TicksPerMillisecond = Stopwatch.Frequency / 1000.0f; Stopwatch sw = Stopwatch.StartNew(); T output = (T)func.DynamicInvoke(args); UnityEngine.Debug.Log($"{func.Method.Name} took {sw.ElapsedTicks / TicksPerMillisecond}ms"); return output; }
public static int timesRepeat <T> (this int x, Func <T> method) { for (int i = x; i > 0; i--) { method.DynamicInvoke(); } return(x); }
public static void RegisterModuleDependency <TModule, TService>(this TModule module, Func <TModule, TService> implementationFactory) where TModule : class, IFilePartyModule, new() where TService : class { EnsureKeyExists <TModule>(); ModuleDependencies[typeof(TModule)] .Add(new ServiceDescriptor(typeof(TService), x => (TService)implementationFactory.DynamicInvoke(module), ServiceLifetime.Scoped)); }
static public void Test <T>(T a) { Func <T> func = () => a; //MethodInfo mi = func.Method; //Console.WriteLine (mi.ToString ()); func.DynamicInvoke(); }
private void Run() { while (running) { Thread.Sleep(1000 / Fps); Callback.DynamicInvoke(); } }
///-------------------------------------------------------------------------------------------------------- /// static public async Task ForeachAsync(Func <long, Task> processor) { foreach (var userId in userIdList) { Task task = processor.DynamicInvoke(userId) as Task; await task; } }
public static T Indent <T>(Func <T> function, int indent = 16) { EditorGUILayout.BeginHorizontal(); GUILayout.Space(indent); var ret = (T)function.DynamicInvoke(); EditorGUILayout.EndHorizontal(); return(ret); }
static void Main(string[] args) { Func <double> func = new Func <double>(() => { return(Math.PI); }); Task <double> result; result = Task.Run <double>(() => { return((double)func.DynamicInvoke()); }); Console.WriteLine($"PI = {result.Result}"); }
/// <summary> /// Extracts data from Task method /// </summary> /// <typeparam name="TEntry"></typeparam> /// <param name="entryFunc"></param> /// <returns></returns> private object?GetFromMethod <TEntry>(Func <Task <TEntry> > entryFunc) { if (entryFunc.Method.ReturnType.IsSubclassOf(typeof(Task))) { if (entryFunc.Method.ReturnType.IsConstructedGenericType) { dynamic?tmp = entryFunc.DynamicInvoke(); return(tmp?.GetAwaiter().GetResult()); } (entryFunc.DynamicInvoke() as Task)?.GetAwaiter().GetResult(); } else { return(entryFunc.DynamicInvoke()); } return(null); }
private object DeserializeInternal(BinaryReader br) { int ndx = 0; object obj = null; try { obj = constructor.DynamicInvoke(); for (int i = 0; i < persistables.Length; i++) { ndx = i; persistables[i].Deserialize(br, obj); } return(obj); } catch (Exception exception) { throw new SerializationException("Failed to deserialize object, corrupt stream. (" + exception != null && obj != null ? exception.Message + " Type: " + obj.GetType().Name + " Attribute: " + persistables[ndx].MemberInfo.Name : "", exception); } }
public static TRetorno ObterAtualizarItemCache <TRetorno, TParam1, TParam2>( int regiaoId, Func <TParam1, TParam2, TRetorno> metodo, params object[] parametros) { var chave = GerarChave(metodo.Method.Name, regiaoId, parametros.ToList()); return(ObterAtualizarItemCache(chave, () => { return (TRetorno)metodo.DynamicInvoke(parametros); }, politicaItemCachePadrao)); }
public static T ifTrueifFalse <T>(this Boolean aBoolean, Func <T> methodA, Func <T> methodB) { if (aBoolean) { return((T)methodA.DynamicInvoke()); } else { return((T)methodB.DynamicInvoke()); } }
public static IHtmlString JsMinify(this HtmlHelper helper, Func<object, object> markup) { if (helper == null || markup == null) { return MvcHtmlString.Empty; } string sourceJs = (markup.DynamicInvoke(helper.ViewContext) ?? String.Empty).ToString(); return !BundleTable.EnableOptimizations ? new MvcHtmlString(sourceJs) : new MvcHtmlString(SpaApp.MinifyJavaScript(sourceJs)); }
public static T ifTrue <T>(this bool aBoolean, Func <T> method) { if (aBoolean) { return((T)method.DynamicInvoke()); } else { return(default(T)); } }
/// <summary> /// De-serializes and runs a compiled linq func expression. /// </summary> /// <param name="function">The function.</param> /// <param name="receivedMessage">The received message.</param> /// <param name="workerNotification">The worker notification.</param> private void HandleFunction(Func<IReceivedMessage<MessageExpression>, IWorkerNotification, object> function, IReceivedMessage<MessageExpression> receivedMessage, IWorkerNotification workerNotification) { var result = function.DynamicInvoke(receivedMessage, workerNotification); if (result == null) return; //if we have a connection, this is an rpc request var connection = receivedMessage.GetHeader(workerNotification.HeaderNames.StandardHeaders.RpcConnectionInfo); //if no connection, then this was not RPC if (connection == null) return; var timeOut = receivedMessage.GetHeader(workerNotification.HeaderNames.StandardHeaders.RpcTimeout).Timeout; //if we don't have an RPC queue for this queue, create one CreateRpcModuleIfNeeded(connection); //send the response var response = _rpcQueues[connection].Send( result, _rpcQueues[connection].CreateResponse(receivedMessage.MessageId, timeOut)); if (response.HasError) { _log.ErrorException("Failed to send a response for message {0}", response.SendingException, receivedMessage.MessageId.Id.Value); } }
/// <summary> /// Jses the minify. /// </summary> /// <param name="helper">The helper.</param> /// <param name="markup">The markup.</param> /// <returns></returns> public static MvcHtmlString JsMinify(this HtmlHelper helper, Func<object, object> markup) { if (helper == null || markup == null) { return MvcHtmlString.Empty; } var sourceJs = (markup.DynamicInvoke(helper.ViewContext) ?? String.Empty).ToString(); if (!IsJsMinify) { return new MvcHtmlString(sourceJs); } var minifier = new Minifier(); var minifiedJs = minifier.MinifyJavaScript(sourceJs, new CodeSettings { EvalTreatment = EvalTreatment.MakeImmediateSafe, PreserveImportantComments = false }); return new MvcHtmlString(minifiedJs); }
/// <summary> /// CSSs the minify. /// </summary> /// <param name="helper">The helper.</param> /// <param name="markup">The markup.</param> /// <returns></returns> public static MvcHtmlString CssMinify(this HtmlHelper helper, Func<object, object> markup) { if (helper == null || markup == null) { return MvcHtmlString.Empty; } var sourceCss = (markup.DynamicInvoke(helper.ViewContext) ?? String.Empty).ToString(); if (!IsJsMinify) { return new MvcHtmlString(sourceCss); } var minifier = new Minifier(); var minifiedCss = minifier.MinifyStyleSheet(sourceCss, new CssSettings { CommentMode = CssComment.None }); return new MvcHtmlString(minifiedCss); }
// Usage: parseData("{x:10,y:20}", MethodName); public static void parseData(string data, Func<Dictionary<string, string>, bool> func) { string[] d = data.Trim().Replace("\r", "").Replace("}", "\n}").Replace("{", "{\n").Replace("\n", "\n\n").Split('\n'); var vals = new Dictionary<string, string>(); for (int row = 0; row < d.Length; row++) { var line = d[row].Trim(); if (line.Length == 0) continue; if (line.Substring(0, 1) == "}") { func.DynamicInvoke(vals); vals = new Dictionary<string, string>(); } else { var keyval = line.Split(new char[] { ':' }, 2); string key = keyval[0].Trim().ToLower(); if (keyval.Length == 2 && !vals.ContainsKey(key)) vals.Add(key, keyval[1].Trim()); } } }