Microsoft.AspNet.Server.Kestrel.KestrelEngine.CreateServer C# (CSharp) Method

        public IDisposable CreateServer(ServerAddress address, Func<IFeatureCollection, Task> application)
        {
            var listeners = new List<IDisposable>();

            var usingPipes = address.IsUnixPipe;

            try
            {
                var pipeName = (Libuv.IsWindows ? @"\\.\pipe\kestrel_" : "/tmp/kestrel_") + Guid.NewGuid().ToString("n");

                var single = Threads.Count == 1;
                var first = true;

                foreach (var thread in Threads)
                {
                    if (single)
                    {
                        var listener = usingPipes ?
                            (Listener) new PipeListener(this) :
                            new TcpListener(this);
                        listeners.Add(listener);
                        listener.StartAsync(address, thread, application).Wait();
                    }
                    else if (first)
                    {
                        var listener = usingPipes
                            ? (ListenerPrimary) new PipeListenerPrimary(this)
                            : new TcpListenerPrimary(this);

                        listeners.Add(listener);
                        listener.StartAsync(pipeName, address, thread, application).Wait();
                    }
                    else
                    {
                        var listener = usingPipes
                            ? (ListenerSecondary) new PipeListenerSecondary(this)
                            : new TcpListenerSecondary(this);
                        listeners.Add(listener);
                        listener.StartAsync(pipeName, address, thread, application).Wait();
                    }

                    first = false;
                }
                return new Disposable(() =>
                {
                    foreach (var listener in listeners)
                    {
                        listener.Dispose();
                    }
                });
            }
            catch
            {
                foreach (var listener in listeners)
                {
                    listener.Dispose();
                }

                throw;
            }
        }
    }

 public IDisposable Start(IServerInformation serverInformation, Func<IFeatureCollection, Task> application)
 {
     var disposables = new List<IDisposable>();
     var information = (ServerInformation)serverInformation;
     var engine = new KestrelEngine(_libraryManager, _appShutdownService);
     engine.Start(1);
     foreach (var address in information.Addresses)
     {
         disposables.Add(engine.CreateServer(
             address.Scheme,
             address.Host,
             address.Port,
             async frame =>
             {
                 var request = new ServerRequest(frame);
                 await application.Invoke(request.Features);
             }));
     }
     disposables.Add(engine);
     return new Disposable(() =>
     {
         foreach (var disposable in disposables)
         {
             disposable.Dispose();
         }
     });
 }