private async void Knopf_Click(object sender, RoutedEventArgs e)
        {
            var id = "BluetoothLE#BluetoothLE12:34:56:78:90:12-12:34:56:78:90:12";
            var dev = await BluetoothLEDevice.FromIdAsync(id);                      // funktioniert
            //var dev = Creator.GetDevice(id, Application.Current.Dispatcher.Invoke); // funktioniert nicht
            Text.Text = dev.DeviceId;
        }

        public static BluetoothLEDevice GetDevice(string deviceId, Func<Func<Task>,Task> invoke)
        {
            BluetoothLEDevice ret = null;
            invoke(async () => {
                ret = await BluetoothLEDevice.FromIdAsync(deviceId);
            });
            return ret;
        }

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
using Serilog;

namespace Tests.SerilogWeb
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder => {
                    webBuilder.UseStartup<Startup>();
                })
                .UseSerilog(new LoggerConfiguration() // Logger instanziern
                    .MinimumLevel.Debug()
                    .Enrich.WithClientIp()
                    .WriteTo.Console()
                    .CreateLogger()
                );
    }
}

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.OpenApi.Models;
using Serilog;

namespace Tests.SerilogWeb
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo { Title = "Tests.SerilogWeb", Version = "v1" });
            });
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment()) {
                app
                    .UseDeveloperExceptionPage()
                    .UseSwagger()
                    .UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "Tests.SerilogWeb v1"));
            }
            app
                .UseSerilogRequestLogging() // <- Hinzugefügt
                .UseHttpsRedirection()
                .UseRouting()
                .UseAuthorization()
                .UseEndpoints(endpoints => {
                    endpoints.MapControllers();
                });
        }
    }
}

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;

namespace Tests.SerilogWeb.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private static readonly string[] Summaries = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        private readonly ILogger<WeatherForecastController> _logger;

        public WeatherForecastController(ILogger<WeatherForecastController> logger)
        {
            _logger = logger;
        }

        [HttpGet]
        public IEnumerable<WeatherForecast> Get()
        {
            _logger.LogInformation("Hier sollte die ClientIp stehen: ->{ClientIp}<-");
            var rng = new Random();
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = rng.Next(-20, 55),
                Summary = Summaries[rng.Next(Summaries.Length)]
            })
            .ToArray();
        }
    }
}

        static void Main(string[] args)
        {
            Console.WriteLine("Discovering...");
            var devices = InTheHand.Bluetooth.Bluetooth.ScanForDevicesAsync().Result;
            Console.WriteLine("Listing...");
            foreach (var device in devices) {
                Console.WriteLine($"\t{device.Name}");
            }
            Console.WriteLine("Finished.");
            Console.ReadKey();
        }

using InTheHand.Net.Sockets;
using System.Windows;

namespace BTTests.ThirtyTwoFeetNET
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            using (var client = new BluetoothClient()) {
                foreach (var device in client.DiscoverDevicesInRange()) {
                    MessageBox.Show(device.DeviceName);
                }
            }
        }
    }
}

using System.Windows;
using Windows.Devices.Enumeration;

namespace BTTests.MWSC
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            var picker = new DevicePicker();
            picker.Show(new Windows.Foundation.Rect(Left, Top, Width, Height));
        }
    }
}

                MetadataReference.CreateFromFile(Assembly.Load("netstandard").Location),
                MetadataReference.CreateFromFile(Assembly.Load("System.Runtime").Location)

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Emit;
using DFM = Dapper.FluentMap.Mapping;

namespace Fips.ORM.Dapper
{
    public class MappersCreator
    {
        private Type CreateType(Type type, string name, Dictionary<string,string> mappings)
        {
            var assemblyName = type.Assembly.FullName;
            var nspace = type.Namespace;
            var sb = new StringBuilder();
            foreach (var kv in mappings) {
                sb.Append($"            Map(m => m.{kv.Key}).ToColumn(\"{kv.Value}\");\n");
            }
            var code = $@"using Dapper.FluentMap.Mapping;

namespace {nspace}
{{
    public class {name}Mapper : EntityMap<{name}>
    {{
        public {name}Mapper()
        {{
{sb.ToString()}
        }}
    }}
}}";
            SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(code);
            CSharpCompilation compilation = CSharpCompilation.Create(
                assemblyName,
                new[] { syntaxTree },
                new MetadataReference[] {
                    MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
                    MetadataReference.CreateFromFile(type.Assembly.Location),
                    MetadataReference.CreateFromFile(typeof(DFM.EntityMap<Type>).Assembly.Location),
                    MetadataReference.CreateFromFile(typeof(Expression<Type>).Assembly.Location),
                    MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location),
                },
                new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
            );
            using (var memoryStream = new MemoryStream()) {
                EmitResult result = compilation.Emit(memoryStream);
                if (result.Success) {
                    memoryStream.Seek(0, SeekOrigin.Begin);
                    Assembly assembly = Assembly.Load(memoryStream.ToArray());
                    Type ret = assembly.GetType($"{nspace}.{name}");
                    return ret;
                } else {
                    foreach (var diagnostic in result.Diagnostics) {
                        Console.WriteLine(diagnostic);
                    }
                    return null;
                }
            }
        }
    }
}

using System;
using System.DirectoryServices;

namespace Tests.LDAP {
    class Program {
        static void Main(string[] args) {
            var server = "dc.domain.example.com";
            var port = 636;
            var container = "CN=Users,DC=domain,DC=example,DC=com";
            var path = $"LDAP://{server}:{port}/{{0}}{container}";
            var user = "Administrator@domain.example.com";
            var password = "s0m3p4ssw0rd";
            var de = new DirectoryEntry(string.Format(path, "CN=User Name,"), user, password, AuthenticationTypes.SecureSocketsLayer);
            var prop = de.Properties["cn"]; // <-- Hier wird die Exception geworfen
            Console.WriteLine($"cn: {prop}");
            Console.ReadKey();
        }
    }
}

Unhandled Exception: System.Runtime.InteropServices.COMException: The server is not operational.
   at System.DirectoryServices.DirectoryEntry.Bind(Boolean throwIfFail)
   at System.DirectoryServices.DirectoryEntry.Bind()
   at System.DirectoryServices.DirectoryEntry.get_AdsObject()
   at System.DirectoryServices.PropertyValueCollection.PopulateList()
   at System.DirectoryServices.PropertyValueCollection..ctor(DirectoryEntry entry, String propertyName)
   at System.DirectoryServices.PropertyCollection.get_Item(String propertyName)
   at Tests.LDAP.Program.Main(String[] args) in C:\source\Tests\Tests.LDAP\Program.cs:line 17