Получить язык ввода для текущего потока

namespace ConsoleApp1
{
    internal class Program
    {
        
        static void Main(string[] args)
        {
            
            InputLanguage myCurrentLanguage = InputLanguage.CurrentInputLanguage;
            while (true)
            {
                Thread.Sleep(100);
                if (myCurrentLanguage != null)
                {
                    Console.WriteLine(myCurrentLanguage.LayoutName);
                    myCurrentLanguage = null;
                }
                
            }
        }
        
    }
}

namespace ConsoleApp1
{
    internal class Program
    {
        static void mythread()
        {
            InputLanguage myCurrentLanguage = InputLanguage.CurrentInputLanguage;
            if (myCurrentLanguage != null)
            {
                Console.WriteLine(myCurrentLanguage.LayoutName);
                myCurrentLanguage = null;
            }
            Thread.Sleep(100);
            Thread thread = new Thread(mythread);
            thread.Start();
        }
        static void Main(string[] args)
        {
            mythread();
        }
        
    }
}

using System;
using System.Globalization;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Timers;
using Timer = System.Timers.Timer;
 
namespace ConsoleApp4
{
    class Program
    {
        private static Timer tm;
        static void Main(string[] args)
        {
            tm = new Timer();
            tm.Interval = 100;
            tm.Elapsed += Tm_Elapsed;
            tm.Start();
            Console.ReadLine();
            tm.Stop();
            tm.Dispose();
        }
 
        private static void Tm_Elapsed(object sender, ElapsedEventArgs e)
        {
            Console.WriteLine(KeyboardLayouts.GetThreadKeyboardLayout().LanguageName);
        }
 
        public class KeyboardLayout
        {
            public uint Id { get; }
 
            public ushort LanguageId { get; }
            public ushort KeyboardId { get; }
 
            public string LanguageName { get; }
            public string KeyboardName { get; }
 
            internal KeyboardLayout(uint id, ushort languageId, ushort keyboardId, string languageName, string keyboardName)
            {
                Id = id;
                LanguageId = languageId;
                KeyboardId = keyboardId;
                LanguageName = languageName;
                KeyboardName = keyboardName;
            }
        }
 
        public static class KeyboardLayouts
        {
            public static KeyboardLayout GetThreadKeyboardLayout(int threadId = 0)
            {
                uint keyboardLayoutId = (uint)GetKeyboardLayout((uint)threadId);
 
                return CreateKeyboardLayout(keyboardLayoutId);
            }
 
            public static KeyboardLayout GetProcessKeyboardLayout(int processId = 0)
            {
                int threadId = GetProcessMainThreadId(processId);
                return GetThreadKeyboardLayout(threadId);
            }
 
            private static Int32 GetProcessMainThreadId(int processId = 0)
            {
                Process process = 0 == processId ? Process.GetCurrentProcess() : Process.GetProcessById(processId);
                return process.Threads[0].Id;
            }
 
            private static KeyboardLayout CreateKeyboardLayout(UInt32 keyboardLayoutId)
            {
                var languageId = (UInt16)(keyboardLayoutId & 0xFFFF);
                var keyboardId = (UInt16)(keyboardLayoutId >> 16);
 
                return new KeyboardLayout(keyboardLayoutId, languageId, keyboardId, GetCultureInfoName(languageId), GetCultureInfoName(keyboardId));
 
                String GetCultureInfoName(UInt16 cultureId)
                {
                    return CultureInfo.GetCultureInfo(cultureId).DisplayName;
                }
            }
 
            [DllImport("user32.dll")]
            private static extern IntPtr GetKeyboardLayout(uint idThread);
        }
    }
}

public void mythread()
        {
            GC.Collect(2, GCCollectionMode.Forced);
            InputLanguage myCurrentLanguage = InputLanguage.CurrentInputLanguage;
            if (myCurrentLanguage.LayoutName != str)
            {
                str =myCurrentLanguage.LayoutName;
                Console.WriteLine(myCurrentLanguage.LayoutName);
                myCurrentLanguage = null;
            }
            Thread.Sleep(10);
            Thread thread = new Thread(mythread);
            thread.Start();
            
 
        }

using System;
using System.Globalization;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleAppForTests
{
    public delegate void KeyboardLayoutHandler(object obj, IntPtr keyboardLayout);
 
    public sealed class KeyboardLayout
    {
        #region Native win32 API
 
        [System.Runtime.InteropServices.DllImport("user32.dll")]
        static extern IntPtr GetKeyboardLayout(uint idThread);
 
        [System.Runtime.InteropServices.DllImport("user32.dll")]
        private static extern IntPtr GetForegroundWindow();
 
        [System.Runtime.InteropServices.DllImport("user32.dll")]
        static extern uint GetWindowThreadProcessId(IntPtr hWnd, IntPtr processId);
 
        #endregion
 
        public KeyboardLayout()
        {
            GetHandlerKeyboardLayout();
        }
 
        private IntPtr currentKeyboardLayout = IntPtr.Zero;
 
        public IntPtr CurrentKeyboardLayout
        {
            get => currentKeyboardLayout;
            set
            {
                currentKeyboardLayout = value;
                KeyboardLayoutChanged?.Invoke(this, value);
            }
        }
 
        public event KeyboardLayoutHandler KeyboardLayoutChanged;
 
        private void GetHandlerKeyboardLayout()
        {
            Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    IntPtr keyboardlayout = GetKeyboardLayout();
 
                    if (CurrentKeyboardLayout != keyboardlayout)
                    {
                        CurrentKeyboardLayout = keyboardlayout;
                    }
 
                    Thread.Sleep(500);
                }
            });
        }
 
        public static IntPtr GetKeyboardLayout()
        {
            IntPtr hWnd = GetForegroundWindow();
            IntPtr processId = IntPtr.Zero;
            uint idThread = GetWindowThreadProcessId(hWnd, processId);
 
            return GetKeyboardLayout(idThread);
        }
 
        public static CultureInfo GetCultureInfo(IntPtr keyboardLayout)
        {
            return new CultureInfo((short)keyboardLayout.ToInt64());
        }
    }
}

using System;
 
namespace ConsoleAppForTests
{
    internal class Program
    {
        static void Main(string[] args)
        {
            var keyboardLayout = new KeyboardLayout();
            keyboardLayout.KeyboardLayoutChanged += OnKeyboardLayoutChanged;
 
            while (true) { }
        }
 
        private static void OnKeyboardLayoutChanged(object sender, IntPtr hKbdL)
        {
            int keyboardLayoutId = KeyboardLayout.GetCultureInfo(hKbdL).KeyboardLayoutId;
 
            Console.WriteLine($"{keyboardLayoutId}. {KeyboardLayout.GetCultureInfo(hKbdL).DisplayName}");
        }
    }
}