//***** Несколько параметров суммирования
/// <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());
}
}
}
