Synapse 4: Cancel Razer forcing their sound devices as default on startup

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.ServiceProcess;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using AudioSwitcher.AudioApi.CoreAudio;
// NuGet dependencies:
// AudioSwitcher.AudioApi              <-- [x] Include Prerelease > 4.0.0-alpha5.
// AudioSwitcher.AudioApi.CoreAudio    <-- [x] Include Prerelease > 4.0.0-alpha5.

// Version 28

// POSTED ONLINE: https://pastebin.com/NEbxVfnQ
//
// 11/14/2024 - Did Synapse 4 break? It no longer can set default playback devices for me even when i click the "SET AS DEFAULT" buttons in the GUI under "SOUND" and "MIC".
//              Added a configurable abort timer to handle these situations instead of waiting forever.
//
// 7/16/2025 - Implemented a wait for Windows audio services to start to see if that fixes the issue where this line [CoreAudioController coreAudioController = new CoreAudioController();] was causing this program to hang and leak memory.
//
// 7/25/2025 - Tested with the raw code of CoreAudio projects and noticed less issues. Now testing with pre-release alpha build NuGets.
//
// 10/6/2025 - Added razerkill argument. It doesn't kill the two services (UAC elevation needed) but it does enough good to free approximately a gigabyte of wasted ram and cpu usage.
//
// 8/12/2026 - AI Fixed WriteSameLine bug which was not writing to the same line and reduced memory usage in loops with using() instead of waiting for dispose to fire.

namespace Sound
{
    class Program
    {
        // Usage: $ Sound.exe [option[="value"]] ...
        //
        //     goodplayback - The desired playback device, e.g. 'CABLE Input (VB-Audio Virtual Cable)'.
        //     goodrecording - The desired recording device, e.g. 'Voicemeeter Out B1 (VB-Audio Voicemeeter VAIO)'.
        //     badplayback - The undesired playback device, e.g. 'Speakers (Razer Audio Controller - Game)'.
        //     badrecording - The undesired recording device, e.g. 'Headset Microphone (Razer Audio Controller - Chat)'.
        //     badprocess - The undesired process that changes sound settings, i.e. 'RazerAppEngine'.
        //     recheck - The number of checks to perform to ensure sound devices are configured properly. The default value is 5.
        //     delay - The delay used to reduce CPU usage spikes when performing repetitive tasks. The default value is 200.
        //     abort - The delay before giving up waiting for bad processes to alter sound devices. The default value is 30.
        //     devices - List playback and recording devices. The default value is False.
        //     killrazer - Kill Razer Synapse processes after configuring sound settings.
        //     nopause - Prevent this program from pausing before exit. The default value is False.
        //
        // Example: $ Sound.exe ^
        //                goodplayback="CABLE Input (VB-Audio Virtual Cable)" ^
        //                goodrecording="Voicemeeter Out B1 (VB-Audio Voicemeeter VAIO)" ^
        //                badplayback="Speakers (Razer Audio Controller - Game)" ^
        //                badrecording="Headset Microphone (Razer Audio Controller - Chat)" ^
        //                badprocess="RazerAppEngine" ^
        //                recheck="5" ^
        //                delay="200" ^
        //                abort="30" ^
        //                killrazer ^
        //                nopause
        //
        // Note: Use [$ Sound.exe devices] to get the device names to use with the arguments.
        // Note: If your device lacks a microphone, then don't use [goodrecording="..."] and [badrecording="..."] options.

        // How i use this program:
        //     I have a Start.bat file that runs on startup with $ reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run" /v "Start" /t REG_SZ /d \"%~dp0Start.bat\" /f
        //
        //     And one of its lines looks like this:
        //
        //     "Sound\Sound\bin\Debug\Sound.exe" ^
        //         goodplayback="CABLE Input (VB-Audio Virtual Cable)" ^
        //         goodrecording="Voicemeeter Out B1 (VB-Audio Voicemeeter VAIO)" ^
        //         badplayback="Speakers (Razer Audio Controller - Game)" ^
        //         badrecording="Headset Microphone (Razer Audio Controller - Chat)" ^
        //         badprocess="RazerAppEngine" ^
        //         recheck="4" ^
        //         delay="200" ^
        //         abort="10" ^
        //         killrazer ^
        //         nopause

        static async Task Main(string[] args)
        {
            Arguments arguments = new Arguments(args);

            #region Wait for Windows audio services to start

            {
                Output.WriteLine($" Waiting for Windows audio services to start . . .");

                CancellationTokenSource cts = (arguments.Abort > 0) ? new CancellationTokenSource(TimeSpan.FromSeconds(arguments.Abort)) : new CancellationTokenSource(); // Time delay abort or no time delay abort.

                try
                {
                    while (true)
                    {
                        if (Services.IsRunning("AudioEndpointBuilder") && Services.IsRunning("Audiosrv"))
                            break;

                        await Task.Delay(arguments.Delay, cts.Token).ConfigureAwait(false);
                    }
                }
                catch (OperationCanceledException)
                {
                    Output.WriteLine();
                    Output.WriteLine($" Stopped waiting after {arguments.Abort} seconds . . .");
                }
                finally
                {
                    cts.Dispose();
                }
            }

            #endregion Wait for Windows audio services to start

            #region Wait for Synapse to start and begin changing sound settings

            if (string.IsNullOrWhiteSpace(arguments.BadProcess) == false &&
                (arguments.GoodPlaybackDevice != null || arguments.GoodRecordingDevice != null))
            {
                Output.WriteLine();
                Output.WriteLine($" Waiting for {arguments.BadProcess} to start . . .");

                CancellationTokenSource cts = (arguments.Abort > 0) ? new CancellationTokenSource(TimeSpan.FromSeconds(arguments.Abort)) : new CancellationTokenSource(); // Time delay abort or no time delay abort.

                try
                {
                    while (Process.GetProcessesByName(arguments.BadProcess).Any() == false)
                        await Task.Delay(arguments.Delay, cts.Token).ConfigureAwait(false);

                    if (arguments.BadPlaybackDevice != null || arguments.BadRecordingDevice != null)
                    {
                        Output.WriteLine();
                        Output.WriteLine(" Waiting for bad sound devices to be set as default . . .");
                    }

                    while (true)
                    {
                        using (CoreAudioController coreAudioController = new CoreAudioController()) // CoreAudioController calls RefreshSystemDevices() in its constructor with no other way to refresh devices.
                        {
                            var defaultPlaybackDevice = coreAudioController.DefaultPlaybackDevice;
                            var defaultRecordingDevice = coreAudioController.DefaultCaptureDevice;

                            bool isBadPlaybackDeviceSet = arguments.BadPlaybackDevice == null ||
                                (defaultPlaybackDevice != null && defaultPlaybackDevice.FullName.Equals(arguments.BadPlaybackDevice, StringComparison.InvariantCultureIgnoreCase));

                            bool isBadRecordingDeviceSet = arguments.BadRecordingDevice == null ||
                                (defaultRecordingDevice != null && defaultRecordingDevice.FullName.Equals(arguments.BadRecordingDevice, StringComparison.InvariantCultureIgnoreCase));

                            if ((isBadPlaybackDeviceSet && isBadRecordingDeviceSet) ||
                                (arguments.GoodPlaybackDevice == null && isBadRecordingDeviceSet) ||
                                (isBadPlaybackDeviceSet && arguments.GoodRecordingDevice == null))
                                break;
                        }

                        await Task.Delay(arguments.Delay, cts.Token).ConfigureAwait(false);
                    }
                }
                catch (OperationCanceledException)
                {
                    Output.WriteLine();
                    Output.WriteLine($" Stopped waiting after {arguments.Abort} seconds . . .");
                }
                finally
                {
                    cts.Dispose();
                }
            }

            #endregion Wait for Synapse to start and begin changing sound settings

            #region Set desired sound devices

            bool forcePauseExit = false;

            if (arguments.GoodPlaybackDevice != null ||
                arguments.GoodRecordingDevice != null)
            {
                for (int check = 0, attempt = 0; check < arguments.ReCheck; check++)
                {
                    try
                    {
                        // TODO: After a recent Razer Synapse update (not 100% sure that's the cause of the problem) i find this program can hang indefinitely leading to a memory leak.
                        //       Attaching a debugger reveals this is the line that causes the hanging issue.
                        //       Testing code that waits for Windows audio services to start to see if that helps.
                        using (CoreAudioController coreAudioController = new CoreAudioController()) // CoreAudioController calls RefreshSystemDevices() in its constructor with no other way to refresh devices.
                        {
                            bool success = true;

                            // If default playback device does not match desired playback device.
                            if (arguments.GoodPlaybackDevice != null &&
                                coreAudioController.DefaultPlaybackDevice.FullName.Equals(arguments.GoodPlaybackDevice, StringComparison.InvariantCultureIgnoreCase) == false)
                            {
                                check = 0; // Restart loop.
                                Output.WriteLine();
                                Output.WriteLine($" ! Unwanted default playback device detected: {coreAudioController.DefaultPlaybackDevice.FullName}");
                                Output.WriteLine($"   Changing default playback device to: {arguments.GoodPlaybackDevice}");
                                success &= await coreAudioController.SetDefaultDeviceAsync(arguments.GoodPlaybackDevice).ConfigureAwait(false);
                            }

                            // If default recording device does not match desired recording device.
                            if (arguments.GoodRecordingDevice != null &&
                                coreAudioController.DefaultCaptureDevice.FullName.Equals(arguments.GoodRecordingDevice, StringComparison.InvariantCultureIgnoreCase) == false)
                            {
                                check = 0; // Restart loop.
                                Output.WriteLine();
                                Output.WriteLine($" ! Unwanted default recording device detected: {coreAudioController.DefaultCaptureDevice.FullName}");
                                Output.WriteLine($"   Changing default recording device to: {arguments.GoodRecordingDevice}");
                                success &= await coreAudioController.SetDefaultDeviceAsync(arguments.GoodRecordingDevice).ConfigureAwait(false);
                            }

                            if (success)
                            {
                                // If not asked to wait for a "bad" process to alter default sound devices, or to only perform one check.
                                if (arguments.BadProcess == null ||
                                    arguments.ReCheck == 1)
                                    break;

                                if (check == 0)
                                    Output.WriteLine(); // Add a blank line before write-same-line output.
                                Output.WriteSameLine($" + Checking default sound devices . . . {(check + 1) / (double)arguments.ReCheck:P0}");
                            }

                            else
                            {
                                check = 0; // Restart loop.
                                attempt++;
                                Output.WriteLine();
                                Output.WriteLine($" ! Retry attempt {attempt} of {MAX_RETRIES} due to device configuration failure.");

                                if (attempt >= MAX_RETRIES)
                                {
                                    arguments.NoPause.Value = false; // Disable no-pause because of setting-sound-device-as-default error.
                                    break;
                                }

                                forcePauseExit = true;
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Logger.TraceMessage(e.ToString());
                        forcePauseExit = true;
                    }

                    //await Task.Delay(arguments.Delay).ConfigureAwait(false);
                    //TODO: maybe 200 isn't enough of a delay
                    await Task.Delay(1000).ConfigureAwait(false);
                }
            }

            #endregion Set desired sound devices

            if (arguments.Devices)
            {
                using (var cac = new CoreAudioController())
                {
                    await cac.DisplaySoundDevicesAsync().ConfigureAwait(false); // CoreAudioController calls RefreshSystemDevices() in its constructor with no other way to refresh devices.
                }
            }

            if (arguments.KillRazer)
            {
                var razerProcessNames = new string[] {
                    // NOTE: These services require admin priviliges to kill.
                    "GameManagerService3",
                    "razer_elevation_service",

                    "RazerAppEngine",
                    "RzEngineMon",
                };

                Output.WriteLine();
                Output.WriteLine($" Checking for running Razer Synapse processes . . .");
                Output.WriteLine();

                foreach (var processName in razerProcessNames)
                {
                    try
                    {
                        var processes = Process.GetProcessesByName(processName);
                        if (processes.Length == 0)
                        {
                            //Output.WriteLine();
                            //Output.WriteLine($" Process not found: {processName}");
                            continue;
                        }

                        foreach (var process in processes)
                        {
                            using (process)
                            {
                                try
                                {
                                    process.Kill();
                                    Output.WriteLine($" Killed process: {process.ProcessName} (PID: {process.Id})");
                                }
                                catch (Exception e)
                                {
                                    Output.WriteLine($" Failed to kill process: {process.ProcessName} (PID: {process.Id}) {e.Message}");
                                    //forcePauseExit = true;
                                }
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Logger.TraceMessage(e.ToString());
                        forcePauseExit = true;
                    }
                }
            }

            if (arguments.NoPause == false || forcePauseExit)
                Output.Pause();
        }

        private const int MAX_RETRIES = 3;
    }

    public static class Logger
    {
        public static void TraceMessage(string message,
                                 [CallerMemberName] string memberName = "",
                                 [CallerFilePath] string sourceFilePath = "",
                                 [CallerLineNumber] int sourceLineNumber = 0)
        {
            Output.WriteLine();
            Output.WriteLine("-----");
            Output.WriteLine("message: " + message);
            Output.WriteLine("member name: " + memberName);
            Output.WriteLine("source file path: " + sourceFilePath);
            Output.WriteLine("source line number: " + sourceLineNumber);
            Output.WriteLine("-----");
        }
    }

    public static class Services
    {
        public static bool IsRunning(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
                throw new ArgumentException(nameof(name));

            try
            {
                using (var sc = new ServiceController(name))
                    return (sc.Status == ServiceControllerStatus.Running);
            }
            catch
            {
                return false;
            }
        }
    }

    public static class CoreAudioControllerExtensions
    {
        public static async Task<bool> SetDefaultDeviceAsync(this CoreAudioController coreAudioController, string deviceName)
        {
            if (coreAudioController == null)
                throw new ArgumentNullException(nameof(coreAudioController));

            if (string.IsNullOrEmpty(deviceName))
                throw new ArgumentNullException(nameof(deviceName));

            try
            {
                var devices = await coreAudioController.GetDevicesAsync().ConfigureAwait(false);

                foreach (CoreAudioDevice device in devices)
                {
                    if (device.FullName.Equals(deviceName, StringComparison.InvariantCultureIgnoreCase))
                    {
                        bool setAsDefault = await device.SetAsDefaultAsync().ConfigureAwait(false);
                        bool setAsDefaultCommunications = await device.SetAsDefaultCommunicationsAsync().ConfigureAwait(false);

                        if (setAsDefault == false ||
                            setAsDefaultCommunications == false)
                        {
                            Output.WriteLine();
                            Output.WriteLine($" Error: Failed to set device '{deviceName}' as default.");
                            return false;
                        }

                        return true; // Successfully set the device as default.
                    }
                }
            }
            catch (Exception ex)
            {
                Output.WriteLine();
                Output.WriteLine($" Error: Failed to set device '{deviceName}' as default - {ex.Message}");
                return false;
            }

            Output.WriteLine();
            Output.WriteLine($" Error: Could not find audio device: {deviceName}");
            return false;
        }

        public static async Task DisplaySoundDevicesAsync(this CoreAudioController coreAudioController)
        {
            if (coreAudioController == null)
                throw new ArgumentNullException(nameof(coreAudioController));

            CoreAudioDevice defaultPlaybackDevice = coreAudioController.DefaultPlaybackDevice;
            Output.WriteLine();
            Output.WriteLine(" Playback devices:");

            foreach (CoreAudioDevice device in await coreAudioController.GetPlaybackDevicesAsync().ConfigureAwait(false))
            {
                if (device == null)
                    continue;

                string isDefault = (defaultPlaybackDevice != null && device.Id == defaultPlaybackDevice.Id) ? "*" : " ";
                Output.WriteLine($"   {isDefault} {device.FullName}");
            }

            CoreAudioDevice defaultRecordingDevice = coreAudioController.DefaultCaptureDevice;
            Output.WriteLine();
            Output.WriteLine(" Recording devices:");

            foreach (CoreAudioDevice device in await coreAudioController.GetCaptureDevicesAsync().ConfigureAwait(false))
            {
                if (device == null)
                    continue;

                string isDefault = (defaultRecordingDevice != null && device.Id == defaultRecordingDevice.Id) ? "*" : " ";
                Output.WriteLine($"   {isDefault} {device.FullName}");
            }
        }
    }

    public class Arguments
    {
        public Argument<string> GoodPlaybackDevice { get; } = new Argument<string>("goodplayback", "The desired playback device, e.g. 'CABLE Input (VB-Audio Virtual Cable)'.");
        public Argument<string> GoodRecordingDevice { get; } = new Argument<string>("goodrecording", "The desired recording device, e.g. 'Voicemeeter Out B1 (VB-Audio Voicemeeter VAIO)'.");
        public Argument<string> BadPlaybackDevice { get; } = new Argument<string>("badplayback", "The undesired playback device, e.g. 'Speakers (Razer Audio Controller - Game)'.");
        public Argument<string> BadRecordingDevice { get; } = new Argument<string>("badrecording", "The undesired recording device, e.g. 'Headset Microphone (Razer Audio Controller - Chat)'.");
        public Argument<string> BadProcess { get; } = new Argument<string>("badprocess", "The undesired process that changes sound settings, i.e. 'RazerAppEngine'.");
        public Argument<int> ReCheck { get; } = new Argument<int>("recheck", "The number of checks to perform to ensure sound devices are configured properly.", 5);
        public Argument<int> Delay { get; } = new Argument<int>("delay", "The delay used to reduce CPU usage spikes when performing repetitive tasks.", 200);
        public Argument<int> Abort { get; } = new Argument<int>("abort", "The delay before giving up waiting for bad processes to alter sound devices.", 30);
        public Argument<bool> Devices { get; } = new Argument<bool>("devices", "List playback and recording devices.");
        public Argument<bool> KillRazer { get; } = new Argument<bool>("killrazer", "Kill Razer Synapse processes after configuring sound settings.");
        public Argument<bool> NoPause { get; } = new Argument<bool>("nopause", "Prevent this program from pausing before exit.");

        public Arguments(string[] args)
        {
            // Get all properties of type Argument<T>.
            _arguments = GetType()
                .GetProperties(BindingFlags.Public | BindingFlags.Instance)
                .Where(prop => prop.PropertyType.IsGenericType &&
                               prop.PropertyType.GetGenericTypeDefinition() == typeof(Argument<>));

            bool success = true;

            foreach (string arg in args)
            {
                bool argParsed = _arguments.Any(property =>
                {
                    dynamic argument = property.GetValue(this);
                    if (ReferenceEquals(argument, null) == false) // Null check without using the overloaded equality operator in Argument<T>.
                        return argument.TryParse(arg);
                    return false;
                });

                if (argParsed == false)
                {
                    success = false;
                    Output.WriteLine($" Error: Unparsed argument detected: {arg}");
                }
            }

            if (args.Length == 0 ||
                success == false)
            {
                DisplayUsage();
                Environment.Exit(1);
            }
        }

        public void DisplayUsage()
        {
            string programName = AppDomain.CurrentDomain.FriendlyName;

            StringBuilder sb = new StringBuilder();
            sb.AppendLine();
            sb.AppendLine($" Usage: $ {programName} [option[=\"value\"]] ...");
            sb.AppendLine();

            foreach (PropertyInfo property in _arguments)
            {
                dynamic argument = property.GetValue(this);
                if (ReferenceEquals(argument, null) == false) // Null check without using the overloaded equality operator in Argument<T>.
                {
                    string defaultValue = argument.DefaultValue != null ? $" The default value is {argument.DefaultValue}." : string.Empty;
                    sb.AppendLine($"     {argument.Name} - {argument.Description}{defaultValue}");
                }
            }

            sb.AppendLine();
            sb.AppendLine($" Example: $ {programName} ^");
            sb.AppendLine($"                {GoodPlaybackDevice.Name}=\"CABLE Input (VB-Audio Virtual Cable)\" ^");
            sb.AppendLine($"                {GoodRecordingDevice.Name}=\"Voicemeeter Out B1 (VB-Audio Voicemeeter VAIO)\" ^");
            sb.AppendLine($"                {BadPlaybackDevice.Name}=\"Speakers (Razer Audio Controller - Game)\" ^");
            sb.AppendLine($"                {BadRecordingDevice.Name}=\"Headset Microphone (Razer Audio Controller - Chat)\" ^");
            sb.AppendLine($"                {BadProcess.Name}=\"RazerAppEngine\" ^");
            sb.AppendLine($"                {ReCheck.Name}=\"{ReCheck.DefaultValue}\" ^");
            sb.AppendLine($"                {Delay.Name}=\"{Delay.DefaultValue}\" ^");
            sb.AppendLine($"                {Abort.Name}=\"{Abort.DefaultValue}\" ^");
            sb.AppendLine($"                {KillRazer.Name}=\"{KillRazer.DefaultValue}\" ^");
            sb.AppendLine($"                {NoPause.Name}");
            sb.AppendLine();
            sb.AppendLine($" Note: Use [$ {programName} {Devices.Name}] to get the device names to use with the arguments.");
            sb.Append($" Note: If your device lacks a microphone, then don't use [goodrecording=\"...\"] and [badrecording=\"...\"] options.");
            Output.WriteLine(sb.ToString());
            Output.Pause();
        }

        private IEnumerable<PropertyInfo> _arguments;
    }

    public class Argument<T>
    {
        public string Name { get; }
        public string Description { get; }
        public T DefaultValue { get; }
        public T Value { get; set; }

        public Argument(string name, string description, T defaultValue = default)
        {
            Name = name;
            Description = description;
            DefaultValue = defaultValue;
            Value = defaultValue;
        }

        public static implicit operator T(Argument<T> argument) => (argument is null) ? default : argument.Value;

        public static bool operator !=(Argument<T> left, Argument<T> right) => !(left == right);

        public static bool operator ==(Argument<T> left, Argument<T> right)
        {
            if (ReferenceEquals(left, right))
                return true;

            if ((ReferenceEquals(left.Value, null) && ReferenceEquals(right, null)) ||
                (ReferenceEquals(left, null)) && ReferenceEquals(right.Value, null))
                return true;

            if (ReferenceEquals(left, null) || ReferenceEquals(right, null))
                return false;

            return EqualityComparer<T>.Default.Equals(left.Value, right.Value);
        }

        public override bool Equals(object obj) => obj is Argument<T> other && this == other;

        public override int GetHashCode() => Value?.GetHashCode() ?? 0;

        public override string ToString() => Value?.ToString() ?? base.ToString();

        public bool TryParse(string arg)
        {
            // Split 'name=value' into 'name' and 'value' parts.
            string[] parts = arg.Split(new[] { '=' }, 2);
            string name = parts[0].Trim();

            if (name.Equals(Name, StringComparison.InvariantCultureIgnoreCase) == false)
                return false;

            if (parts.Length > 1)
            {
                string value = parts[1].Trim();
                try
                {
                    // Try to convert the value to the expected type.
                    Value = (T)Convert.ChangeType(value, typeof(T));
                    return true;
                }
                catch
                {
                    return false;
                }
            }

            if (typeof(T) == typeof(bool) &&
                parts.Length == 1)
            {
                // Treat [name] args as shorthand for "name=true".
                Value = (T)(object)true;
                return true;
            }

            return false;
        }
    }

    public static class Output
    {
        public static void Pause()
        {
            lock (_syncRoot)
            {
                EnsureNewLine();
                Console.WriteLine();
                Write(" Press any key to continue . . . ");
            }

            Console.ReadKey(); // Moved outside lock to avoid blocking other threads on input.
        }

        public static void WriteSameLine(string value)
        {
            lock (_syncRoot)
            {
                // Fall back to standard printing if the application is being redirected to avoid ArgumentOutOfRangeException's.
                // due to there not being an active console window to provide buffer dimensions.
                if (Console.IsOutputRedirected)
                {
                    Console.WriteLine(value);
                    _isSameLine = false;
                    return;
                }

                int currentTop = Console.CursorTop;

                // Move the cursor home.
                Console.SetCursorPosition(0, currentTop);

                // Clear the current line by overwriting it with spaces.
                Console.Write(new string(' ', Console.WindowWidth - 1));
                _isSameLine = true;

                // Move the cursor back to the originally captured row.
                Console.SetCursorPosition(0, currentTop);

                // Write the text.
                Write(value);
            }
        }

        #region WriteLine

        public static void WriteLine()
        {
            lock (_syncRoot)
            {
                EnsureNewLine();
                Console.WriteLine();
            }
        }

        public static void WriteLine(string value)
        {
            lock (_syncRoot)
            {
                EnsureNewLine();
                Console.WriteLine(value);
            }
        }

        public static void WriteLine(object value)
        {
            lock (_syncRoot)
            {
                EnsureNewLine();
                Console.WriteLine(value);
            }
        }

        #endregion WriteLine

        public static void Write(string value)
        {
            lock (_syncRoot)
            {
                Console.Write(value);
                _isSameLine = true;
            }
        }

        private static void EnsureNewLine()
        {
            if (_isSameLine)
            {
                // Add a new line to the console to get under the same-line writing that was last used.
                Console.WriteLine();
                _isSameLine = false;
            }
        }

        private static bool _isSameLine = false;
        private static readonly object _syncRoot = new object();
    }
}