CanerPatir

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;

namespace TDFDemo
{
    class Program
    {

CanerPatir

@FunctionalInterface
public interface PipelineStep<I, O, Ctx> {
    static <I, O, Ctx> PipelineStep<I, O, Ctx> of(PipelineStep<I, O, Ctx> source) {
        return source;
    }

    O execute(I value, Ctx context) throws Exception;

    default <R> PipelineStep<I, R, Ctx> pipe(PipelineStep<O, R, Ctx> next) {

CanerPatir

public class MyTask : ScheduleTask
{
        public MyTask(IServiceScopeFactory serviceScopeFactory) : base(serviceScopeFactory)
        {
        }
 
        protected override string CronExpression => "*/10 * * * *";

        public override Task Execute(IServiceProvider serviceProvider)
        {

CanerPatir

#!/bin/zsh

for i in */.git; 
do ( echo $i; cd $i/..; git pull; git fetch -p && for branch in `git branch -vv | grep ': gone]' | awk '{print $1}'`; do git branch -D $branch; done );
done

CanerPatir

suspend fun someSuspendableOperation(): String {
    delay(1000L) // representation of IO operation like going to DB
    return "hello"
}

CanerPatir

suspend fun doOperation1() {
    delay(1000L)
}

suspend fun getSomeResult(): String { 
    delay(2000L)
    return "hello"
}

fun main(){

CanerPatir

fun main() { 
  runBlocking {
    val deferred1 = async { operation1() }
    val deferred2 = async { operation2() }
    println("[${(SimpleDateFormat("hh:mm:ss")).format(Date())}] Awaiting computations...")
    val result = deferred1.await() + deferred2.await()
    println("[${(SimpleDateFormat("hh:mm:ss")).format(Date())}] The result is $result")
  }
}

CanerPatir

fun main() { 
  runBlocking {
    val deferred1 = async { operation1() }
    val deferred2 = async { operation2() }
    println("[${(SimpleDateFormat("hh:mm:ss")).format(Date())}] Awaiting computations...")
    val result = deferred1.await() + deferred2.await()
    println("[${(SimpleDateFormat("hh:mm:ss")).format(Date())}] The result is $result")
  }
}

CanerPatir

fun main() = runBlocking {
    GlobalScope.launch { 
      delay(1000L)
      print("World!")
    }
    print("Hello")
}

CanerPatir

   fun concurrencyTest(){
        val time1 = measureTimeMillis {
            runBlocking {
                val listOfDeferred: List<Deferred<Int>> = (1..50).map { i ->
                    async {
                        delay(100)
                        Int.MIN_VALUE
                    }
                }
            }