private static string result;
static void Main()
{
SaySomething();
Console.WriteLine(result);
}
static async Task<int> SaySomething()
{
await Task.Delay(10);
result = "Hello!";
return 1;
}
private static string result;
static void Main()
{
SaySomething();
Console.WriteLine(result);
}
static async Task<int> SaySomething()
{
await Task.Delay(10);
result = "Hello!";
return 1;
}
private static string result;
static void Main()
{
SaySomething();
Console.WriteLine(result);
}
static async Task<int> SaySomething()
{
Thread.Sleep(10);
result = "Hello!";
return 1;
}
static void Main(string[] args)
{
int a = 11;
int b = 22;
int c = 33;
int d = 44;
int f = 55;
a = a + b;
b = c + d;
c = a + b;
d = f + d;
f = a + b + c + d / 4;
}
IL_0000: nop
IL_0001: ldc.i4.s 11
IL_0003: stloc.0
IL_0004: ldc.i4.s 22
IL_0006: stloc.1
IL_0007: ldc.i4.s 33
IL_0009: stloc.2
IL_000a: ldc.i4.s 44
IL_000c: stloc.3
IL_000d: ldc.i4.s 55
IL_000f: stloc.s 4
IL_0011: ldloc.0
IL_0012: ldloc.1
IL_0013: add
IL_0014: stloc.0
IL_0015: ldloc.2
IL_0016: ldloc.3
IL_0017: add
IL_0018: stloc.1
IL_0019: ldloc.0
IL_001a: ldloc.1
IL_001b: add
IL_001c: stloc.2
IL_001d: ldloc.s 4
IL_001f: ldloc.3
IL_0020: add
IL_0021: stloc.3
IL_0022: ldloc.0
IL_0023: ldloc.1
IL_0024: add
IL_0025: ldloc.2
IL_0026: add
IL_0027: ldloc.3
IL_0028: ldc.i4.4
IL_0029: div
IL_002a: add
IL_002b: stloc.s 4
IL_002d: ret
Process p = Process.GetCurrentProcess();
p.PriorityClass = ProcessPriorityClass.High;
Thread t = Thread.CurrentThread;
t.Priority = ThreadPriority.Normal;
static void Main(string[] args)
{
Thread thread = new Thread(new ThreadStart(Do));
thread.IsBackground = true;
thread.Start();
thread.Join();
}
public static void Do()
{}
static void Main(string[] args)
{
Thread thread2 = new Thread(new ParameterizedThreadStart(Do2));
thread2.IsBackground = true;
thread2.Start("parametr");
thread2.Join();
}
public static void Do2(object par)
{}
static void Main(string[] args)
{
Thread thread = new Thread(new ThreadStart(DoEx));
thread.IsBackground = true;
thread.Start();
thread.Join();
}
public static void DoEx()
{
throw new Exception();
}
int workerThreadsMin; int IOCPThreadMin;
ThreadPool.GetMinThreads(out workerThreadsMin,
out IOCPThreadMin);
int workerThreadsMax; int IOCPThreadMax;
ThreadPool.GetMaxThreads(out workerThreadsMax,
out IOCPThreadMax);
ThreadPool.SetMaxThreads(1000, 32767);
ThreadPool.SetMinThreads(8, 8);
Action a = (state) => { };
ThreadPool.
QueueUserWorkItem(a, "StanOk", true);
static void Main(string[] args)
{
ThreadPool.QueueUserWorkItem(Do);
}
public static void Do(object? state)
{}
static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException
+= OnUnhandleException;
ThreadPool.QueueUserWorkItem(Do);
}
private static void OnUnhandleException(object sender, UnhandledExceptionEventArgs e)
{
Console.WriteLine("Terminacja? : " + e.IsTerminating);
Console.WriteLine("Przyczyna : " + e.ExceptionObject);
}
public static void Do(object? state)
{
throw new Exception();
}
static void Main(string[] args)
{
Func method =
(int a) => { return a; };
IAsyncResult handle =
method.BeginInvoke(100,
new AsyncCallback(WhenDone),
new object());
}
private static void WhenDone(IAsyncResult ar)
{
var target = (Func)ar.AsyncState;
int result = target.EndInvoke(ar);
Console.WriteLine(result);
}
static void Main(string[] args)
{
var worker = new BackgroundWorker();
worker.DoWork += WorkerDoSomething;
worker.ProgressChanged += Worker_ProgressChanged;
worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
worker.RunWorkerAsync(worker);
}
private static void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{}
private static void WorkerDoSomething(object sender, DoWorkEventArgs e)
{}
private static void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{}
static void Main()
{
Task
.Factory
.StartNew(
() => Console.WriteLine
(Thread.CurrentThread.IsBackground))
.Wait();
}
static void Main()
{
Task
.Factory
.StartNew(
() => Console.WriteLine
(Thread.CurrentThread.IsBackground))
.Wait();
}
static void Main(string[] args)
{
var d = DateTime.Now;
Console.WriteLine(d.Minute + ":" + d.Second);
Task.Delay(7000);
var d2 = DateTime.Now;
Console.WriteLine(d2.Minute + ":" + d2.Second);
}
static void Main(string[] args)
{
var d = DateTime.Now;
Console.WriteLine(d.Minute + ":" + d.Second);
Task.Delay(7000);
var d2 = DateTime.Now;
Console.WriteLine(d2.Minute + ":" + d2.Second);
}
static void Main(string[] args)
{
var d = DateTime.Now;
Console.WriteLine(d.Minute + ":" + d.Second);
Task t = Task.Delay(7000);
t.Wait();
var d2 = DateTime.Now;
Console.WriteLine(d2.Minute + ":" + d2.Second);
}
static void Main(string[] args)
{
var d = DateTime.Now;
Console.WriteLine(d.Minute + ":" + d.Second);
Task t = Task.Delay(7000);
t.Wait();
var d2 = DateTime.Now;
Console.WriteLine(d2.Minute + ":" + d2.Second);
}
static async Task Main(string[] args)
{
var d = DateTime.Now;
Console.WriteLine(d.Minute + ":" + d.Second);
await Task.Delay(7000);
var d2 = DateTime.Now;
Console.WriteLine(d2.Minute + ":" + d2.Second);
}
static void Main()
{
var t = What();
Console.WriteLine(t.Status);
}
static Task What()
{
return new Task(
() => Console.WriteLine("1"));
}
static void Main()
{
var t = What();
Console.WriteLine(t.Status);
}
static Task What()
{
return new Task(
() => Console.WriteLine("1"));
}
static void Main(string[] args)
{
Task task = new Task(Do);
task.Start();
}
private static void Do(){}
static void Main(string[] args)
{
Task task = Task.Factory.StartNew(Do);
}
private static void Do(){}
static void Main(string[] args)
{
Task task = Task.Run(Do);
}
private static void Do(){}
static void Main(string[] args)
{
Task task = Task.Run(Do);
task.Wait();
Task<int> task2 = Task.Run(Do2);
var r = task2.Result;
}
private static void Do() { }
private static int Do2() { return 1; }
var parent = Task.Factory.StartNew(() =>
{
Console.WriteLine("Parent Start");
var child = Task.Factory.StartNew(() =>
{
Console.WriteLine("ChildTask Start");
Thread.Sleep(4000);
Console.WriteLine("ChildTask End");
}, TaskCreationOptions.AttachedToParent);
Console.WriteLine("Parent END");
});
parent.Wait();
Console.WriteLine("DEMO END");
var parent = Task.Factory.StartNew(() =>
{
Console.WriteLine("Parent Start");
var child = Task.Factory.StartNew(() =>
{
Console.WriteLine("ChildTask Start");
Thread.Sleep(4000);
Console.WriteLine("ChildTask End");
}, TaskCreationOptions.AttachedToParent);
Console.WriteLine("Parent END");
});
parent.Wait();
Console.WriteLine("DEMO END");
var parent = Task.Factory.StartNew(() =>
{
Console.WriteLine("Parent Start");
var child = Task.Factory.StartNew(() =>
{
Console.WriteLine("ChildTask Start");
Thread.Sleep(4000);
Console.WriteLine("ChildTask End");
}, TaskCreationOptions.DenyChildAttach);
Console.WriteLine("Parent END");
});
parent.Wait();
Console.WriteLine("DEMO END");
Task<int> task = Task.Run(() =>
{
throw new AccessViolationException();
return -1;
});
Console.ReadKey();
try
{
_ = task.Result;
}
catch (AggregateException ex)
{
if (ex.InnerExceptions is
AccessViolationException)
{
Console.WriteLine(ex.Message)
}
}
static void Main(string[] args)
{
TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
var task = Task.Run(() => { throw new Exception(); });
}
private static void TaskScheduler_UnobservedTaskException(object sender,
UnobservedTaskExceptionEventArgs e)
{
Console.WriteLine("Przegapi艂e艣 :" + e.Exception);
e.SetObserved();
}
Task<int> t = Task.Run(() =>
{
return 44;
});
Task<int> t2 = t.ContinueWith(a =>
{
return t.Result + 66;
});
Console.WriteLine(t2.Result);
Console.Read();
Task<int>t = Task.Run(() =>
{
return 44;
});
Task<int> t2 = t.ContinueWith(a =>
{
return t.Result + 66;
},
TaskContinuationOptions.OnlyOnRanToCompletion);
Task t3 = t.ContinueWith(a =>
{
Console.WriteLine("Error");
}, TaskContinuationOptions.OnlyOnFaulted);
var tokenSource2 = new CancellationTokenSource();
CancellationToken ct = tokenSource2.Token;
var t = Task.Run(() =>
{
ct.ThrowIfCancellationRequested();
});
try
{
t.Wait();
}
catch (OperationCanceledException e)
{
Console.WriteLine($"{nameof(OperationCanceledException)} thrown with message: {e.Message}");
}
finally
{
tokenSource2.Dispose();
}
var tokenSource2 = new CancellationTokenSource();
CancellationToken ct = tokenSource2.Token;
tokenSource2.Cancel();
var t = Task.Run(() =>
{
}, ct);
try
{
t.Wait();
}
catch (AggregateException e)
{
Console.WriteLine(e.InnerException);
}
finally
{
tokenSource2.Dispose();
}
Task t1 = Task.Delay(2000);
Task t2 = Task.Delay(4000);
Task t3 = Task.Delay(6000);
Task.WaitAll(t1, t2, t3);
Task.WaitAny(t1, t2, t3);
Task<Task<Task<int>>> t =
Task.Factory.StartNew
(() =>
{
return Task.Factory.StartNew(
() =>
Task.Run(() => { return 1; }));
});
var result = t.Result.Result.Result;
Task<Task<Task<int>>> t =
Task.Factory.StartNew
(() =>
{
return Task.Factory.StartNew(
() =>
Task.Run(() => { return 1; }));
});
var unwrap = t.Unwrap();
var unwrap2 = unwrap.Unwrap();
var result = unwrap2.Result;
public int GiveNumber()
{
return -1;
}
public async Task<int> GiveNumberAsync()
{
return -1;
}
public async Task<int> GiveMeRandomNumberAsync()
{
var i = await GiveAnotherNumberAsync();
return await GiveNumberAsync();
}
public async Task<int> GiveNumberAsync()
{
return 1;
}
public async Task<int> GiveAnotherNumberAsync()
{
return 2;
}
static async Task Main()
{
var numbers =
await File.ReadAllTextAsync(@"D:\numbers.txt");
Task<string> t = File.ReadAllTextAsync(@"D:\numbers2.txt");
await t;
}
static async Task Main()
{
WriteThread("Begin Main");
var a = await M1Async();
WriteThread("Middle Main");
var b = await M1Async();
Console.WriteLine(a + b);
WriteThread("End Main");
Console.ReadKey();
}
public static async Task<int> M1Async()
{
WriteThread("Begin M1Async");
var i = await M2Async();
WriteThread("End M1Async");
return i + 1;
}
public static async Task<int> M2Async()
{
WriteThread("At M2Async");
return -1;
}
public static void WriteThread(string helpfultoken)
{
Console.WriteLine(helpfultoken
+ " : " + Thread.CurrentThread.ManagedThreadId);
}
static async Task Main()
{
WriteThread("Begin Main");
var a = await M1Async();
WriteThread("Middle Main");
var b = await M1Async();
Console.WriteLine(a + b);
WriteThread("End Main");
Console.ReadKey();
}
public static async Task<int> M1Async()
{
WriteThread("Begin M1Async");
var i = await M2Async();
WriteThread("End M1Async");
return i + 1;
}
public static async Task<int> M2Async()
{
WriteThread("At M2Async");
return -1;
}
public static void WriteThread(string helpfultoken)
{
Console.WriteLine(helpfultoken
+ " : " + Thread.CurrentThread.ManagedThreadId);
}
static async Task Main()
{
WriteThread("Begin Main");
var a = await M1Async();
WriteThread("Middle Main");
var b = await M1Async();
Console.WriteLine(a + b);
WriteThread("End Main");
Console.ReadKey();
}
public static async Task<int> M1Async()
{
WriteThread("Begin M1Async");
await Task.Delay(2000);
WriteThread("End M1Async");
return 0;
}
public static void WriteThread(string helpfultoken)
{
Console.WriteLine(helpfultoken
+ " : " + Thread.CurrentThread.ManagedThreadId);
}
static async Task Main()
{
Task<string> t =
File.ReadAllTextAsync(@"D:\numbers2.txt");
await t;
await t;
await t;
await t;
}
static Task<int> M1()
{
return Task.FromResult(1);
}
static async Task<int> M2()
{
return await M1();
}
public async Task<string> GetWithKeywordsAsync(string url)
{
using (var client = new HttpClient())
return await client.GetStringAsync(url);
}
public Task<string> GetElidingKeywordsAsync(string url)
{
using (var client = new HttpClient())
return client.GetStringAsync(url);
}
static async Task Main()
{
var task = M2();
if (task.IsFaulted)
Console.WriteLine("Error");
}
static Task<int> M1()
{
throw new Exception();
}
static async Task<int> M2()
{
return await M1();
}
static async Task Main()
{
CancellationTokenSource tokenSource = new CancellationTokenSource();
CancellationToken token = tokenSource.Token;
tokenSource.Cancel();
var task = await ReadFile(token);
}
static async Task<string> ReadFile(CancellationToken cancellation = default)
{
var t = await File.ReadAllTextAsync(@"D:\numbers2.txt", token);
return t;
}
static ValueTask<double> Do(int divideArg)
{
if (divideArg == 0)
return new ValueTask<double>(0);
return new ValueTask<double>
(Divide(divideArg));
}
static Task<double> Divide(int divideArg)
{
double a = 1 / divideArg;
return Task.FromResult(a);
}
static async Task Main()
{
await What();
}
static Task What()
{
return new Task(
() => Console.WriteLine("1"));
}
static async Task Main()
{
Task t = What();
await t;
var s = t.Status;
}
static Task What()
{
return new Task(
() => Console.WriteLine("1"));
}
await Task.Run
(
() => DoExpensiveOperation(someParameter)
);