danielmarbach

using System.Collections.Generic;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Jobs;

using BenchmarkDotNet.Extensions;

namespace MicroBenchmarks.Hashing;

[Config(typeof(Config))]

danielmarbach

pactl list | grep -A2 'Source #' | grep 'Name: ' | cut -d" " -f2

nano ~/.config/pipewire/pipewire.conf.d/echo-cancel.conf

 context.modules = [
  {   name = libpipewire-module-echo-cancel
      args = {
          library.name  = aec/libspa-aec-webrtc
          monitor.mode = true
          aec.args = {

danielmarbach

open System
let petrolOfCar = 100
type Destination = Home | Office | Stadium | GasStation

let driveTo destination currentPetrol =
    let remainingPetrol =
        match destination with
        | Home -> currentPetrol - 25
        | Office -> currentPetrol - 50
        | Stadium -> currentPetrol - 25

danielmarbach

Stuff passed via settings

Things that transport used to require that are passed via settings, not via seam:

Settings.Set("Endpoint.SendOnly", sendOnly);
Settings.Set("TypesToScan", new Type[0]);
Settings.Set("NServiceBus.Routing.EndpointName", endpointName);
Settings.Set<Conventions>(new Conventions()); //Hack for ASB
Settings.Set(new StartupDiagnosticEntries());

danielmarbach

public static class TimeboxExtensions
{
    public static async Task Timebox(this IEnumerable<Task> tasks, TimeSpan timeoutAfter, string messageWhenTimeboxReached)
    {
        using (var tokenSource = new CancellationTokenSource())
        {
            var delayTask = Task.Delay(Debugger.IsAttached ? TimeSpan.MaxValue : timeoutAfter, tokenSource.Token);
            var allTasks = Task.WhenAll(tasks);

            var returnedTask = await Task.WhenAny(delayTask, allTasks).ConfigureAwait(false);

danielmarbach

using NUnit.Framework;

namespace AllTests
{
   [TestFixture]
   public class Tests 
   {
      [Test]
      public void Success()
      {

danielmarbach

using System;
using System.Threading;
using System.Threading.Tasks;

namespace test
{
    class Program
    {
        static async Task Main(string[] args)
        {

danielmarbach

using System;
using System.Diagnostics;
using System.Threading.Tasks;

namespace AsyncSandbox
{
    class Program
    {
        static async Task Main(string[] args)
        {

danielmarbach

class Program
    {
        private static int numberOfMessages;

        static void Main(string[] args)
        {
            File.Delete("./sync.txt");
            File.Delete("./async.txt");

            numberOfMessages = 1000;

danielmarbach

public static class TaskExtensions
    {
        public static Task<TResult> WaitWithCancellation<TResult>(this Task<TResult> task, CancellationToken token = default(CancellationToken))
        {
            var tcs = new TaskCompletionSource<TResult>();
            var registration = token.Register(s =>
            {
                var source = (TaskCompletionSource<TResult>) s;
                source.TrySetCanceled();
            }, tcs);