private void button1_Click(object sender, EventArgs e)
{
// the inputs
int x = 2;
// the "thread" or work to be "BeginInvoked"
var dlg = new Func<int, int>(
param =>
{
// put in a sleep just for fun...
System.Threading.Thread.Sleep(500);
// note that, while we COULD have referenced "x" here, we are NOT...
// pretend this lives somewhere else... or is even a web request or something.
return param * 2;
});
// "BeginInvoke" will spawn a new ThreadPool thread to do the work for us
var iar = dlg.BeginInvoke(
// this corresponds to the "param" in the delegate above
x,
// who gets called when the work is completed
Callback,
// "AsyncState" - used to pass additional information around
// By convention, the convention was to usually use an object array
// I'd recommend using a Tuple now for more "strong typed ness"
// - first parameter here is the actual delegate (lambda)
// - second parameter here is the input (why? you'll see in a little bit...)
// Alternatively, you can use a custom object here... depends on the consumer as far as which you'd want to use
new Tuple<Func<int, int>, int>(dlg, x));
}
/// <summary>
/// 校验http和本地数据库数据
/// </summary>
/// <param name="Lpn"></param>
/// <param name="Container"></param>
private void SelectLpnCon(string Lpn, string Container)
{
SetMessage_Action?.Invoke("SelectLpnCon[函数|Log|识别完成，数据开始处理]");
//优先置空车牌和箱号
NewLpn = string.Empty;
UpdateLpn = string.Empty;
Containernumber = string.Empty;
Calculation_In(); //统计入闸
if (Lpn != null || Container != null) //字段其中一个不为空就查询服务器
{
SetMessage_Action?.Invoke("SelectDataBase[函数|Log|开始查询本地数据库]");
string[] Head = { Lpn, Container }; //组合显示车牌和箱号
SelectDataBase?.BeginInvoke(Lpn, Container, "", One_SelectDataBaseCallBack, Head); //查询数据库
}
else//没有识别到数据
{
bool IsOpenDoor = false; //是否开闸
var LedShowDataResult = new string[] { "*", "*", "*", "*", "*", Working_NoOCRresult };
LedShow(LedShowDataResult, IsOpenDoor);
}
}
static void ScanDouble()
{
// Delegates anlegen
var dg1 = new Func<long, long, IEnumerable<long>>(mko.Algo.NumberTheory.PrimeFactors.scan);
var dg2 = new Func<long, long, IEnumerable<long>>(mko.Algo.NumberTheory.PrimeFactors.scan);
var dg3 = new Func<long, long, IEnumerable<long>>(mko.Algo.NumberTheory.PrimeFactors.scan);
var dg4 = new Func<long, long, IEnumerable<long>>(mko.Algo.NumberTheory.PrimeFactors.scan);
// Methoden asynchron mittels Delegates starten
var ares1= dg1.BeginInvoke(1, 2500000, null, null);
var ares2= dg2.BeginInvoke(2500001, 5000000, null, null);
var ares3 = dg3.BeginInvoke(5000001, 75000000, null, null);
var ares4 = dg4.BeginInvoke(7500001, 10000000, null, null);
while (!ares1.IsCompleted && !ares2.IsCompleted && !ares3.IsCompleted && !ares4.IsCompleted)
{
Debug.Write(".");
System.Threading.Thread.Sleep(200);
}
//ares1.AsyncWaitHandle.WaitOne();
var res1 = dg1.EndInvoke(ares1);
var res2 = dg2.EndInvoke(ares2);
}
// See also http://stackoverflow.com/questions/1047662/what-is-asynccallback for this ugly callback model.
static IAsyncResult beginSimulatedDatabaseRequest(AsyncCallback callback)
{
// simulate long running I/O here, e.g. a DB request
var func = new Func<int>(() => {
System.Threading.Thread.Sleep(3000);
return ++requestX; // not threadsafe, whatever
});
return func.BeginInvoke(callback, func); // which thread will this execute on? A threadpool?
}
static void Main(string[] args)
{
Func<int, int, int> additionDel = new Func<int, int, int>(Addition);
int ret = additionDel.Invoke(1, 2);
Console.WriteLine("From Sync invoke " + ret);
object state = new Object();
IAsyncResult _asyncresult = additionDel.BeginInvoke(1,2,null, null);
//calling thread blocks until endInvokecompletes
ret= additionDel.EndInvoke(_asyncresult);
Console.WriteLine("From Aynsc EndInvoke " + ret);
_asyncresult = additionDel.BeginInvoke(1, 2, new AsyncCallback(PrintCallBack), null);
// ret = additionDel.EndInvoke(_asyncresult);
// Console.WriteLine("From Aynsc EndInvoke On asyncCallback" + ret);
Thread.Sleep(5000);
}
/// AsynchronouseProngraingModel
void apm()
{
before_work();
var method = new Func<double>(() => { busy_work(); return 0; });
method.BeginInvoke(ar =>
{
var result = method.EndInvoke(ar);// get return value
this.BeginInvoke((Action)(() => { after_work(); }));
}, null);
}
public override void Run()
{
if (Enable && !connecting && !GlobalVariables.IsConnected() &&
Kernel.GetInstance().ActionControl.CanPerformAction(ActionControlType.LOGIN))
{
var func = new Func<String, String, String, bool>(Kernel.GetInstance().Client.Login.Login);
func.BeginInvoke(Account, Password, CharacterName, new AsyncCallback(LoginCallback), func);
connecting = true;
}
}
static void Main(string[] args)
{
var action = new Func <int>(CalculateSophisticNumber);
//action();
var result = action?.BeginInvoke(null, null);
Console.WriteLine(result);
Console.WriteLine("ГЛАВНЫЙ ПОТОК ЗАВЕРШИЛ РАБОТУ");
}
/// <summary>
/// Gets a basic representation of a user
/// </summary>
public MatrixUser GetPerson(string id)
{
if (_cp.Client == null)
{
return(null);
}
Func <string, MatrixUser> get = _cp.Client.GetUser;
var ar = get?.BeginInvoke(id, null, null);
return(get.EndInvoke(ar));
}
public void TimeoutTest()
{
// Arrange.
var func = new Func<ProcessExecutionResult>(() => ProcessRunner.RunProcess("cmd.exe", PauseArguments, Timeout));
// Act.
var result = func.BeginInvoke((a) => { }, null);
result.AsyncWaitHandle.WaitOne(Timeout + AdditionalTimeout);
// Assert.
if (result.IsCompleted)
{
func.EndInvoke(result);
}
}
IEnumerator<IAsyncCall> DatabaseTask()
{
button1.Enabled = false;
AsyncCall<int> call = new AsyncCall<int>();
Func slow = new Func(DarnSlowDatabaseCall);
yield return call.WaitOn(cb => slow.BeginInvoke(cb, null)) & slow.EndInvoke;
textBox1.Text = "db task returned " + call.Result + "\r\n";
button1.Enabled = true;
}
public MainWindow()
{
InitializeComponent();
worker.ConnectionStatus += status => this.GuiAsync(() => ConnectionStatus(status));
worker.Processed += (a, b) => this.GuiAsync(() => Worker_Processed(a, b));
Processed += (i) => this.GuiAsync(() => MainWindow_Processed(i));
Func<int> func = new Func<int>(GetAvailableWorkThreads);
IAsyncResult asyncResult;
asyncResult = func.BeginInvoke(null, null);
}
public void TimeoutKillTest()
{
// Arrange.
var func = new Func<ProcessExecutionResult>(() => ProcessRunner.RunProcess("cmd.exe", PauseArguments, Timeout));
// Act.
var result = func.BeginInvoke((a) => { }, null);
result.AsyncWaitHandle.WaitOne();
// Assert.
if (Process.GetCurrentProcess().GetChildProcesses().Any())
{
Assert.Fail();
}
Assert.Pass();
}
public IAsyncResult Execute <T1, T2>(Func <T1, T2> executeCode, T1 para, Action <T2> callback)
{
IAsyncResult result = executeCode?.BeginInvoke(para, delegate(IAsyncResult ar)
{
T2 ret = default(T2);
if (executeCode != null)
{
ret = executeCode.EndInvoke(ar);
}
Invoke <T2>(callback, ret);
}, null);
return(result);
}
/// <summary>
/// 校验http和本地数据库数据
/// </summary>
/// <param name="Lpn"></param>
/// <param name="Container"></param>
private void SelectLpnCon(string Lpn, string Container)
{
if (Lpn != null || Container != null) //字段其中一个不为空就查询服务器
{
string[] Head = { Lpn, Container }; //组合显示车牌和箱号
if (HttpSwitch) //是否查询远端服务器
{
HttpPostAction?.BeginInvoke(Passtime.ToString("yyyyMMddhhmmss"), Lpn, Container, SelectHttpCallBack, Head);
}
else
{
SelectDataBase?.BeginInvoke(Lpn, Container, "", this.SelectDataBaseCallBack, Head);//查询数据库
}
}
else//没有识别到数据
{
bool IsOpenDoor = false; //是否开闸
var LedShowDataResult = new string[] { "*", "*", "*", "*", "*", Working_NoOCRresult };
LedShow(LedShowDataResult, IsOpenDoor);
}
NewLpn = string.Empty;
UpdateLpn = string.Empty;
Containernumber = string.Empty;
}
/// <summary>
/// 查询远端服务器回调函数
/// </summary>
/// <param name="ar"></param>
private void SelectHttpCallBack(IAsyncResult ar)
{
var Head = (string[])ar.AsyncState;
var HttpResult = HttpPostAction.EndInvoke(ar);//回调返回数据
//HttpResult = @"{{""error_code"":""AE0000"",""error_desc"":""The request handled successful."",""result"":{{""resultList"":""Y"",""status"":"""",""visito"":"""",""ledgename"":"""",""platform"":"""",""truckNumber"":""粤B050CS"",""tranNo"":"""",""arrivedTime"":""2018 - 11 - 12 17:10:30""} } ";
if (HttpResult != null) //http请求数据回调函数
{
HttpJsonSplitAction?.BeginInvoke(HttpResult, HttpResultSplit, Head); //查询远端服务器
}
else
{
SelectDataBase?.BeginInvoke(Head[0], Head[1], "", this.SelectDataBaseCallBack, Head);//查询数据库
}
}
/// <summary>异步传参数
/// </summary>
/// <param name="age"></param>
public static void ybpara(int age)
{
//异步执行
Func<people, string> FuncAsy = new Func<people, string>((pp) =>
{
return pp.Name;
}
);
FuncAsy.BeginInvoke(new people("小李" + age, age), resual =>
{
//异步执行，从回调函数中获取返回结果
Console.WriteLine(">>>>:{0}", FuncAsy.EndInvoke(resual));
Console.WriteLine(">>>>:{0} end", age);
}, null);
}
private void FormPaintBoard_Load(object sender, EventArgs e)
{
check = "否";
this.tableHandler += new ReadDataTableHandler(getData);
this.chartHandler += new DrawChartUiHandler(drawUi);
Func <string> funStr = getDataView;
IAsyncResult result = funStr.BeginInvoke(new AsyncCallback(other), null);
timeChange = 1;
System.Timers.Timer t = new System.Timers.Timer(1000 * 60 * timeChange);
t.Elapsed += new System.Timers.ElapsedEventHandler(refreData);
t.AutoReset = true;
t.Enabled = true;
}
/// <summary>
/// Asynchronous delegate
/// </summary>
internal static void Prog11()
{
Func <string, int> deleg = new Func <string, int>((string input) =>
{
return(input.Length);
});
AsyncCallback action = (IAsyncResult input) =>
{
Func <string, int> target = (Func <string, int>)input.AsyncState;
int result = target.EndInvoke(input);
Console.WriteLine(result);
}; // BeginInvoke -> elindítja a szál aszinkron futását, megadható egy callback, amit a futás végén meghív
IAsyncResult resuilt = deleg.BeginInvoke("input", action, deleg); // EndInvoke -> bevárja a resultot (ha még nincs kész), megkapja a resultot
}
static void Main(string[] args)
{
Func <int, int, int> sum = (m, n) =>
{
Console.WriteLine("Sum Invoked on thread: " + Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(10000);
return(m + n);
};
IAsyncResult r = sum.BeginInvoke(10, 18, Completed, "Thanks Boss");
while (!IsDone)
{
Console.WriteLine("Working on Main(), Thread Id: " + Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(1000);
}
}
ToTask <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(
this Func <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> @this,
T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16,
AsyncCallback asyncCallback = null,
object state = null,
TaskCreationOptions taskCreationOptions = default(TaskCreationOptions),
TaskScheduler taskScheduler = null)
{
return(await Task <TResult> .Factory.FromAsync(
@this.BeginInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, asyncCallback, state),
@this.EndInvoke,
taskCreationOptions,
taskScheduler ?? TaskScheduler.Current ?? TaskScheduler.Default)
.ConfigureAwait(false));
}
ToTask <T1, T2, T3, T4, T5, TResult>(
this Func <T1, T2, T3, T4, T5, TResult> @this,
T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
AsyncCallback asyncCallback = null,
object state = null,
TaskCreationOptions taskCreationOptions = default(TaskCreationOptions),
TaskScheduler taskScheduler = null)
{
return(await Task <TResult> .Factory.FromAsync(
@this.BeginInvoke(arg1, arg2, arg3, arg4, arg5, asyncCallback, state),
@this.EndInvoke,
taskCreationOptions,
taskScheduler ?? TaskScheduler.Current ?? TaskScheduler.Default)
.ConfigureAwait(false));
}
protected override IAsyncResult BeginExecute(
AsyncCodeActivityContext context,
AsyncCallback callback, object state)
{
CalcShippingAsyncArgs parameters = new CalcShippingAsyncArgs
{
Weight = Weight.Get(context),
OrderTotal = OrderTotal.Get(context),
ShipVia = ShipVia.Get(context),
};
Func <CalcShippingAsyncArgs, Decimal> asyncWork = a => Calculate(a);
context.UserState = asyncWork;
return(asyncWork.BeginInvoke(parameters, callback, state));
}
private void btnAsyncDelegate2_Click(object sender, EventArgs e)
{
//
//非阻塞的方式执行异步委托
//
//定义一个委托
Func <string, int> method = Work;
IAsyncResult cookie = method.BeginInvoke("test", Done, method);
Console.ReadLine();
//你也可以在调用BeginInvoke的时候指定一个回调方法，
//这个方法会在异步委托结束的时候自动调用。
//这样异步委托就像是一个后台线程一样自动执行，不需要主线程等待。
//只需要在BeginInvoke的时候做一些额外的操作即可实现这种操作。
}
/// <summary>异步
/// </summary>
/// <param name="age"></param>
public static void yb(int age)
{
//异步执行
Func<string> FuncAsy = new Func<string>(() =>
{
people tPeo = new people("异步小李", age);
return tPeo.ToString();
}
);
FuncAsy.BeginInvoke(resual =>
{
//异步执行，从回调函数中获取返回结果
Console.WriteLine(">>>>:{0}", FuncAsy.EndInvoke(resual));
Console.WriteLine(">>>>:{0} end", age);
}, null);
}
public void FromAsyncBeginMethod_DirectResult()
{
bool result = false;
bool continuationTest = false;
Func <int, int> func = (i) => { result = true; return(i + 3); };
Task <int> task = factory.FromAsync <int> (func.BeginInvoke(1, delegate { }, null), func.EndInvoke);
var cont = task.ContinueWith(_ => continuationTest = true, TaskContinuationOptions.ExecuteSynchronously);
task.Wait();
cont.Wait();
Assert.IsTrue(result);
Assert.IsTrue(continuationTest);
Assert.AreEqual(4, task.Result);
}
public Future(Func <TValue> function, Action <TValue> callback = null)
{
this._getter = this._WaitForValueCreation;
function.BeginInvoke(asyncResult => {
try {
this._value = function.EndInvoke(asyncResult);
callback?.Invoke(this._value);
Interlocked.Exchange(ref this._getter, this._GetRawValue);
} catch (Exception exception) {
this._exception = exception;
Interlocked.Exchange(ref this._getter, this._ThrowException);
} finally {
((ManualResetEventSlim)asyncResult.AsyncState).Set();
}
}, this._HasValueAlready);
}
static void Main(string[] args)
{
Console.WriteLine("主1====" + DateTime.Now.ToString() + "================" + Thread.CurrentThread.ManagedThreadId);
Func <string> func = new Func <string>(DoTestFun);
Console.WriteLine("func.Method---" + func.Method);
var ar = func.BeginInvoke(null, null);
Console.WriteLine("主2====" + DateTime.Now.ToString() + "================" + Thread.CurrentThread.ManagedThreadId);
var result = func.EndInvoke(ar);
Console.WriteLine("主3====" + DateTime.Now.ToString() + "================" + Thread.CurrentThread.ManagedThreadId);
Console.WriteLine("result:" + result);
Console.ReadKey();
}
/// <summary>
/// </summary>
/// <param name="update"></param>
public static void CloseApplication(bool update = false)
{
Application.Current.MainWindow.WindowState = WindowState.Normal;
SettingsHelper.Save(update);
foreach (PluginInstance pluginInstance in App.Plugins.Loaded.Cast <PluginInstance>().Where(pluginInstance => pluginInstance.Loaded))
{
pluginInstance.Instance.Dispose(update);
}
Func <bool> export = () => SavedlLogsHelper.SaveCurrentLog(false);
export.BeginInvoke(
delegate {
CloseDelegate(update);
}, export);
}
private void ServiceConnector(object source, Service.Connector.ServiceConnectorArgs e)
{
if (e == null)
{
return;
}
IRunDevice runDevice = this.DeviceManager.GetDeviceFromCode(e.ServiceToDevice.DeviceCode);
if (runDevice != null)
{
Func <IFromService, IServiceToDevice, object> serviceConnctor = runDevice.RunServiceConnector;
ServiceConnectorToken token = new ServiceConnectorToken(e.FromService.ServiceKey, serviceConnctor);
serviceConnctor.BeginInvoke(e.FromService, e.ServiceToDevice, new AsyncCallback(ServiceConnectorCallback), token);
}
}
public static void DoAsync <TInput, TResult>(this Func <TInput, TResult> f, TInput arg, Action <TResult> callback)
{
//f.BeginInvoke(arg, x => callback(f.EndInvoke(x)), null);
f.BeginInvoke(arg, x =>
{
if (callback != null)
{
callback(f.EndInvoke(x));
}
else
{
f.EndInvoke(x);
}
}
, null);
}
private void DeviceConnector(object source, Device.Connector.DeviceConnectorArgs e)
{
if (e == null)
{
return;
}
IRunDevice runDevice = this.DeviceManager.GetDeviceFromCode(e.DeviceToDevice.DeviceCode);
if (runDevice != null)
{
Func <IFromDevice, IDeviceToDevice, object> deviceConnctor = runDevice.RunDeviceConnector;
DeviceConnectorToken token = new DeviceConnectorToken(e.FromDevice.DeviceID, deviceConnctor);
deviceConnctor.BeginInvoke(e.FromDevice, e.DeviceToDevice, new AsyncCallback(DeviceConnectorCallback), token);
}
}
static void Main()
{
var myDelegate = new Func <int, int, int>(Add);
// Так как класс делегата сообщается с методами, которые принимают два целочисленных параметра, метод BeginInvoke также
// начинает принимать два дополнительных параметра, кроме двух последних постоянных аргументов.
IAsyncResult asyncResult = myDelegate.BeginInvoke(1, 2, null, null);
// Ожидание завершения асинхронной операции и получение результата работы метода.
int result = myDelegate.EndInvoke(asyncResult);
Console.WriteLine("Результат = " + result);
// Delay.
Console.ReadKey();
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
var pushNotification = PushNotification.Get(context);
var contentListPath = ContentListPath.Get(context);
if (string.IsNullOrEmpty(contentListPath))
{
SnLog.WriteError("ExchangePoller activity: ContentList path is empty.", categories: ExchangeHelper.ExchangeLogCategory);
return(null);
}
var GetMessageInfosDelegate = new Func <bool, string, EmailMessage[]>(GetMessageInfos);
context.UserState = GetMessageInfosDelegate;
return(GetMessageInfosDelegate.BeginInvoke(pushNotification, contentListPath, callback, state));
}
public static void LoadAsync(string filename, Action<IStorableContent, Exception> loadingCompletedCallback) {
if (instance == null) throw new InvalidOperationException("ContentManager is not initialized.");
var func = new Func<string, IStorableContent>(instance.LoadContent);
func.BeginInvoke(filename, delegate(IAsyncResult result) {
Exception error = null;
IStorableContent content = null;
try {
content = func.EndInvoke(result);
content.Filename = filename;
}
catch (Exception ex) {
error = ex;
}
loadingCompletedCallback(content, error);
}, null);
}
/// <summary>
/// </summary>
/// <param name="pSignatures"> </param>
/// <param name="scanAllMemoryRegions"></param>
public void LoadOffsets(IEnumerable <Signature> pSignatures, bool scanAllMemoryRegions = false)
{
IsScanning = true;
Func <bool> scanningFunc = delegate
{
var sw = new Stopwatch();
sw.Start();
if (MemoryHandler.Instance.ProcessModel?.Process == null)
{
return(false);
}
var signatures = new List <Signature>(pSignatures);
if (scanAllMemoryRegions)
{
LoadRegions();
}
if (signatures.Any())
{
foreach (var signature in signatures)
{
if (signature.Value == string.Empty)
{
// doesn't need a signature scan
Locations[signature.Key] = signature;
continue;
}
signature.Value = signature.Value.Replace("*", "?"); // allows either ? or * to be used as wildcard
}
signatures.RemoveAll(a => Locations.ContainsKey(a.Key));
FindExtendedSignatures(signatures, scanAllMemoryRegions);
}
sw.Stop();
MemoryHandler.Instance.RaiseSignaturesFound(Logger, Locations, sw.ElapsedMilliseconds);
IsScanning = false;
return(true);
};
scanningFunc.BeginInvoke(null, null);
}
private void ProcessSample()
{
var openFileDialog = new OpenFileDialog
{
InitialDirectory = Path.Combine(Common.Constants.CachePath, "Logs"),
Multiselect = false,
Filter = "XML Files (*.xml)|*.xml"
};
openFileDialog.FileOk += delegate
{
var count = 0;
var sampleXml = XDocument.Load(openFileDialog.FileName);
var items = new Dictionary <int, string[]>();
foreach (var xElement in sampleXml.Descendants()
.Elements("Entry"))
{
var xKey = (string)xElement.Attribute("Key");
var xBytes = (string)xElement.Element("Bytes");
var xLine = (string)xElement.Element("Line");
var xTimeStamp = (string)xElement.Element("TimeStamp");
if (String.IsNullOrWhiteSpace(xKey) || String.IsNullOrWhiteSpace(xLine))
{
continue;
}
items.Add(count, new[]
{
xKey, xLine, xTimeStamp, xBytes
});
++count;
}
Func <bool> func = delegate
{
foreach (var chatLogEntry in items.Select(item => new ChatLogEntry
{
Code = item.Value[0],
Line = item.Value[1].Replace(" ", " ")
}))
{
EventParser.Instance.ParseAndPublish(chatLogEntry);
}
return(true);
};
func.BeginInvoke(null, null);
};
openFileDialog.ShowDialog();
}
static void Main(string[] args)
{
Console.WriteLine("Before call");
Action o = display;
o();
Console.WriteLine("After call");
Console.WriteLine("Before call");
Action o = display;
o.BeginInvoke(null, null);
Console.WriteLine("After call");
Console.WriteLine("Before call");
Action <string> o2 = display;
o2.BeginInvoke("Vipul", null, null);
Console.WriteLine("After call");
Console.WriteLine("Before");
Func <string, string> o1 = display;
demo d = new demo();
o1.BeginInvoke("vipul zope", delegate(IAsyncResult ar)
{
Console.WriteLine("This is callback function");
string name = o1.EndInvoke(ar);
Console.WriteLine("name is " + name);
}, null);
demo d = new demo();
Console.WriteLine("Before addition");
Func <int, int, int> fobj = display;
fobj.BeginInvoke(10, 20, new AsyncCallback(delegate(IAsyncResult ar)
{
Console.WriteLine("This is callback function");
int a = fobj.EndInvoke(ar);
Console.WriteLine(a);
}), null);
Console.WriteLine("After addition");
Console.ReadLine();
}
/// <summary>
/// </summary>
public static void CacheSoundFiles()
{
try {
if (!Directory.Exists(Constants.SoundsPath))
{
Directory.CreateDirectory(Constants.SoundsPath);
}
List <FileInfo> soundFiles = new List <FileInfo>();
List <string> filters = new List <string> {
"*.wav",
"*.mp3",
};
foreach (var filter in filters)
{
IEnumerable <FileInfo> files = Directory.GetFiles(Constants.SoundsPath, filter, SearchOption.AllDirectories).Select(file => new FileInfo(file));
soundFiles.AddRange(files);
}
Func <bool> cacheSounds = delegate {
foreach (FileInfo soundFile in soundFiles)
{
if (soundFile.DirectoryName == null)
{
continue;
}
var baseKey = soundFile.DirectoryName.Replace(Constants.SoundsPath, string.Empty);
var key = string.IsNullOrWhiteSpace(baseKey)
? soundFile.Name
: $"{baseKey.Substring(1)}\\{soundFile.Name}";
if (SoundFileKeys(false).Contains(key))
{
continue;
}
TryGetSetSoundFile(key);
}
return(true);
};
cacheSounds.BeginInvoke(delegate { }, cacheSounds);
}
catch (Exception ex) {
Logging.Log(Logger, new LogItem(ex, true));
}
}
public void yibu()
{
Func <string, int> func = (s) =>
{
Thread.Sleep(3000);
return(s.Length);
};
func.BeginInvoke("123", (res) =>
{
while (!res.IsCompleted)
{
Thread.Sleep(100);
}
var len = func.EndInvoke(res);
}, null);
}
public string GetReverseDNS(string ip, int timeout)
{
try
{
Func <IPAddress, IPHostEntry> callback = s => Dns.GetHostEntry(s);
var result = callback.BeginInvoke(IPAddress.Parse(ip), null, null);
if (!result.AsyncWaitHandle.WaitOne(timeout, false))
{
return("");
}
return(callback.EndInvoke(result).HostName);
}
catch (Exception)
{
return("");
}
}
public static ConsoleKeyInfo?ReadKey(TimeSpan timeout)
{
Func <ConsoleKeyInfo> readKey = System_Console.ReadKey;
var result = readKey.BeginInvoke(null, null);
result.AsyncWaitHandle.WaitOne(timeout);
if (!result.IsCompleted)
{
return(null);
}
var keyRead = readKey.EndInvoke(result);
return(keyRead);
}
static void Main(string[] args)
{
Func <int, int, int> myDelegate = new Func <int, int, int>(Sum);
IAsyncResult asyncResult = myDelegate.BeginInvoke(1, 2, null, null);
Console.WriteLine("Асинхронный метод запущен. Метод Main продолжает работать");
while (!asyncResult.IsCompleted)
{
Thread.Sleep(100);
Console.Write(".");
}
int result = myDelegate.EndInvoke(asyncResult);
Console.WriteLine("Результат " + result);
Console.ReadKey();
}
static void Main(string[] args)
{
Func<string, string> cmdPrint = null;
cmdPrint = new Func<string, string>(
x=> { Thread.Sleep(10000); return "Hola " + x;}
);
var cb = new AsyncCallback(delegate(IAsyncResult result) {
var del = result.AsyncState as Func<string, string>;
var men = del.EndInvoke(result);
Console.WriteLine(men);
});
cmdPrint.BeginInvoke("Juan", cb, cmdPrint);
Otra();
Console.ReadLine();
}
public static void Execute(Action<bool> isBusy, Func<AsyncCallResult> operation, Action<AsyncCallResult> resultHandler)
{
if (isBusy == null)
throw new ArgumentNullException("isBusy");
if (operation == null)
throw new ArgumentNullException("operation");
if (resultHandler == null)
throw new ArgumentNullException("resultHandler");
// Get current thread dispatcher
Dispatcher dispatcher = Dispatcher.CurrentDispatcher;
// Set the busy indicator
isBusy.Invoke(true);
// Crate an async operation delegate instance.
Func<Action<bool>, AsyncCallResult> asyncOperation = new Func<Action<bool>, AsyncCallResult>((a) => { return operation.Invoke(); });
// Start async operation.
var operationHandler = asyncOperation.BeginInvoke(isBusy, (ar) =>
{
// Retrieve the delegate instance.
var dlgt = (Func<Action<bool>, AsyncCallResult>)ar.AsyncState;
// Call EndInvoke to retrieve the results.
var ret = dlgt.EndInvoke(ar);
// Refresh UI through dispatcher
dispatcher.BeginInvoke(DispatcherPriority.Send, (SendOrPostCallback)delegate
{
try
{
resultHandler.Invoke(ret);
}
finally
{
isBusy.Invoke(false);
}
}, null);
}, asyncOperation);
}
/**
* Begin asynchronous execution of a query.
* @param query The query to execute. Can be one of the following:
* <ul>
* <li><b>randomize</b> Randomizes a pseudonym. parameters[0] must be the pseudonym to randomize.
* <li><b>getEP</b> Returns an encrypted pseudonym. parameters[0] must be the User ID, parameters[0] the SP ID.
* <li><b>getEP</b> Returns a polymorphic pseudonym. parameters[0] must be the User ID.
* </ul>
* @param parameters The parameters for the query.
* @param callback The delegate to call when execution is finished.
* @param state Not used.
* @return IAsyncResult for the asynchronous execution.
*/
public IAsyncResult BeginExecuteQuery(string query, string[] parameters, AsyncCallback callback, object state)
{
PolyPseudWorker worker = new PolyPseudWorker(parameters, config["y_k"], config["connectionString"], config["pseudonymProviderUrl"]);
switch(query)
{
case "randomize":
func = new Func<string[][]>(worker.Randomize);
return func.BeginInvoke(callback, state);
case "getEP":
func = new Func<string[][]>(worker.GetEP);
return func.BeginInvoke(callback, state);
case "getPP":
func = new Func<string[][]>(worker.GetPP);
return func.BeginInvoke(callback, state);
default:
throw new ArgumentException(String.Format("The query '{0}' is not recognized.", query));
}
}
static void Main(string[] args)
{
Func<int, int, string> del = new Func<int, int, string>((a, b) =>
{
Thread.Sleep(1111);
Console.WriteLine("该委托调用的线程Id是" + Thread.CurrentThread.ManagedThreadId);
return (a + b).ToString();
//打印当前线程Id
});
#region 无回调函数的委托异步调用
////该BeginInvoke是vs反编译出来的
////传入参数: 方法传入参数若干,回调函数,回调函数参数
////返回值:IAsyncResult表示异步状态的接口
//IAsyncResult result = del.BeginInvoke(3, 4, null, null);
////内部原理:用线程池中的一个线程调用该方法
////EndInvoke 方法检索异步调用的结果。 在调用 BeginInvoke 之后随时可以调用该方法。 如果异步调用尚未完成，则 EndInvoke 会一直阻止调用线程，直到异步调用完成。
//string resultValue = del.EndInvoke(result);
//Console.WriteLine("委托结果是{0},当前线程是{1}", resultValue, Thread.CurrentThread.ManagedThreadId);
#endregion
#region 有回调函数的委托异步调用
#region 第一种调用法
////回调函数的执行线程与异步委托的执行线程一样
//del.BeginInvoke(3, 4, MyAsyncCallback, "我是回调函数传入参数");
#endregion
#region 第二中调用法
//把异步执行的委托作为回调函数参数
del.BeginInvoke(3, 4, MyAsyncCallback, del);
#endregion
#endregion
Console.ReadKey();
}
public NugetConverterService(string[] args)
{
InitializeComponent();
_eventLog = new EventLog();
if (!EventLog.SourceExists("NugetConverterService"))
{
EventLog.CreateEventSource("NugetConverterService", "Application");
}
_eventLog.Source = "NugetConverterService";
_eventLog.Log = "Application";
runService = () =>
{
Trace.TraceInformation("Nuget Converter Starting...");
_eventLog.WriteEntry("Nuget Converter Starting...");
var error = Ullink.NugetConverter.Program.Run(args);
if (error != null)
Trace.TraceError(error);
return error;
};
runService.BeginInvoke(Callback, null);
}
private void button1_Click(object sender, EventArgs e)
{
// the inputs
int inputToLongRunningOp = 2;
// the "thread" or work to be "BeginInvoked"
var dlg = new Func<int, int>(LongRunningOperation);
// "BeginInvoke" will spawn a new ThreadPool thread to do the work for us
var iar = dlg.BeginInvoke(
// this corresponds to the "param" in the delegate above
inputToLongRunningOp,
// who gets called when the work is completed
Callback,
// "AsyncState" - used to pass additional information around
// By convention, the convention was to usually use an object array
// I'd recommend using a Tuple now for more "strong typed ness"
// - first parameter here is the actual delegate (lambda)
// - second parameter here is the input (why? you'll see in a little bit...)
// Alternatively, you can use a custom object here... depends on the consumer as far as which you'd want to use
new Tuple<Func<int, int>, int>(dlg, inputToLongRunningOp));
}
/// <summary>
/// Asynchronously Load all Files, find shortest paths and put the result into ResultItems
/// </summary>
/// <param name="files"></param>
/// <param name="uiBeforeCallback"></param>
/// <param name="uiAfterCallback"></param>
/// <returns>IAsyncResult</returns>
public IAsyncResult LoadFilesAsync( IEnumerable<string> files,
Action<object> uiBeforeCallback = null,
Action<object> uiAfterCallback = null)
{
ResultItems.Clear();
// Create Delegate to LoadFiles function
Func<IEnumerable<string>, Action<object>, Action<object>, IEnumerable<ResultItem>> loadFunc =
new Func<IEnumerable<string>, Action<object>, Action<object>, IEnumerable<ResultItem>>(LoadFiles);
// Asnchronously invoke the delegate
return loadFunc.BeginInvoke(files, uiBeforeCallback, uiAfterCallback, new AsyncCallback(LoadFilesCallback), loadFunc);
}
/// <summary>
/// Starts the task, optionally in a background thread, and waits until the task completes.
/// </summary>
/// <remarks>
/// If the task is started in a background thread, the task will be terminated in the
/// calling thread terminates. Otherwise, the calling thread will not terminate until
/// the task completes.
/// </remarks>
/// <param name="p_booRunInBackground">Whether the task should be run in a background thread.</param>
/// <param name="p_objArgs">Arguments to pass to the task execution method.</param>
/// <returns>The return value of the task.</returns>
/// <seealso cref="StartWait(object[])"/>
/// <seealso cref="Start(object[])"/>
/// <seealso cref="Start(bool, object[])"/>
protected object StartWait(bool p_booRunInBackground, params object[] p_objArgs)
{
//see Start() for discussion on BeginInvoke/EndInvoke versus
// threads
//
//in this method, it appears we should be using BeginInvoke/EndInvoke,
// unlike in the Start() method. this is because it makes the most
// sense for an exception thrown during the execution of the task to
// bubble up the the caller of this method, which EndInvoke allows.
// this is important for things like transactions: letting the exception
// bubble up allows the transaction to roll back when an unhandled
// exception is thrown in the task's code
// with threading, this doesn't happen - at least not unless we make it.
Func<object, object> dlg = new Func<object, object>(RunThreadedWork);
IAsyncResult ar = dlg.BeginInvoke(p_objArgs, null, p_objArgs);
m_objReturnValue = dlg.EndInvoke(ar);
ar.AsyncWaitHandle.Close();
/*
m_areTaskEnded.Reset();
Start(p_booRunInBackground, p_objArgs);
m_areTaskEnded.WaitOne();*/
return m_objReturnValue;
}
private void postSelected(object sender, SelectionChangedEventArgs e)
{
Mouse.OverrideCursor = Cursors.Wait;
if (e.AddedItems != null && e.AddedItems.Count == 1)
{
var selectedPost = (SyndicationItem)e.AddedItems[0];
var asyncGetPostContents = new Func<SyndicationItem, String>((item) => GetPostContents(item));
asyncGetPostContents.BeginInvoke(selectedPost, EndGetPostContents, asyncGetPostContents);
}
}
private void btnBurnClick(object sender, RoutedEventArgs e)
{
var asyncBurn = new Func<IEnumerable<String>, IEnumerable<SyndicationItem>>((feeds) => Burn(feeds));
asyncBurn.BeginInvoke(new[] { Common.Feeds.Digg, Common.Feeds.Meneame }, BurnEnd, asyncBurn);
}
public void StartSearch()
{
_guiStateArgs.MenuEnabled = false;
GuiStateUpdate(this, _guiStateArgs);
SearchParams searchParams = _parentLogTabWin.SearchParams;
if ((searchParams.isForward || searchParams.isFindNext) && !searchParams.isShiftF3Pressed)
{
searchParams.currentLine = dataGridView.CurrentCellAddress.Y + 1;
}
else
{
searchParams.currentLine = dataGridView.CurrentCellAddress.Y - 1;
}
_currentSearchParams = searchParams; // remember for async "not found" messages
_isSearching = true;
_shouldCancel = false;
StartProgressBar(dataGridView.RowCount, "Searching... Press ESC to cancel.");
Func<SearchParams, int> searchFx = new Func<SearchParams, int>(Search);
searchFx.BeginInvoke(searchParams, SearchComplete, null);
RemoveAllSearchHighlightEntries();
AddSearchHitHighlightEntry(searchParams);
}
public override IAsyncResult BeginGetResponse(AsyncCallback callback, object state)
{
var function = new Func<object>(() => { return null; });
return function.BeginInvoke(callback, state);
}
public IAsyncResult BeginNegation(float operand, AsyncCallback computeCallback, object state)
{
Func<float, float> negation = new Func<float, float>(this.Negative);
AsyncState asyncState = new AsyncState("Negation", negation, state);
return negation.BeginInvoke(operand,computeCallback, asyncState);
}
public IAsyncResult BeginDivision(float right, float left, AsyncCallback computeCallBack, object state)
{
Func<float, float, float> division = new Func<float, float, float>(this.Division);
AsyncState asyncState = new AsyncState("Divison", division, state);
return division.BeginInvoke(right, left, computeCallBack, asyncState);
}
public IAsyncResult BeginMultiplication(float right, float left, AsyncCallback computeCallBack, object state)
{
Func<float, float, float> multiplication = new Func<float, float, float>(this.Multiply);
AsyncState asyncState = new AsyncState("Multiplication", multiplication, state);
return multiplication.BeginInvoke(right, left, computeCallBack, asyncState);
}
public IAsyncResult BeginSubtraction(float right, float left, AsyncCallback computeCallBack, object state)
{
Func<float, float, float> subtraction = new Func<float, float, float>(this.Subtract);
AsyncState asyncState = new AsyncState("Subtraction",subtraction, state);
return subtraction.BeginInvoke(right, left, computeCallBack, asyncState);
}
//public delegate float Func<float,float,float>(float right, float left);
//public delegate float Func<float,float>(float operand);
public IAsyncResult BeginAdditon(float right, float left, AsyncCallback computeCallBack, object state)
{
Func<float,float,float> addition = new Func<float,float,float>(this.Add);
AsyncState asyncState = new AsyncState("Addition", addition, state);
return addition.BeginInvoke(right, left, computeCallBack, asyncState);
}
