C#

Is it possible to detect the encoding of each txt file what you import into textBox1.
For example:
If you import a txt file in textBox1 ... 
label1.Text = "Windows 1250 - ANSI"; or label1.Text = "Windows 1251 - ANSI" or label1.Text = "UTF-8" ...
If it is possible how to do it, and if it is not possible I apologize. Thank you.

[DllImport("user32.dll", EntryPoint = "FindWindow", SetLastError = true)]
        static extern IntPtr FindWindowByCaption(IntPtr ZeroOnly, string lpWindowName);

        //include FindWindowEx
        [DllImport("user32.dll")]
        public static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);

        //include SendMessage
        [DllImport("user32.dll")]
        public static extern int SendMessage(IntPtr hWnd, uint uMsg, IntPtr wParam, string lParam);

        //this is a constant indicating the window that we want to send a text message
        const int WM_SETTEXT = 0X000C;

  private void button1_Click(object sender, EventArgs e)
        {
           
            Process p = Process.Start("SomeApp.exe");
            IntPtr AppTextBox = IntPtr.Zero;
            int i = 0;

            do
            {
                AppTextBox = FindWindowByCaption(IntPtr.Zero, "SomeApp");
                i++;
            } while (AppTextBox.ToInt32() == 0);

          
            // I DONT WANT TO USE SLEEP METHOD HERE
            Thread.Sleep(4000);
        
            AppTextBox = FindWindowEx(p.MainWindowHandle, IntPtr.Zero, "Edit", null);

          
            SendMessage(AppTextBox, WM_SETTEXT, IntPtr.Zero , "Success!");
            
        }

public static class HASPClass
      {


          static readonly object m_locker = new object();
          private static SerialPort m_port;
          private static string m_portName;
          private static bool m_isOpen = false;

          private static int m_baudRate;
          private static Parity m_parity;
          private static int m_dataBits;
          private static StopBits m_stopBits;
          private static bool m_xonxoff;
          private static bool m_dtr;
          private static bool m_rts;

          // ................................

          // Some constants
          public static uint m_WR_ERROR = 0;
          public static uint m_IO_ERROR = 0;
          public static uint m_IO_ERROR1 = 0;
          public static uint m_IO_ERROR2 = 0;
          public static uint m_IO_ERROR3 = 0;


          // Open port.
          public static void OpenPort(string portName,
                                      int baudRate,
                                      Parity parity,
                                      int dataBits,
                                      StopBits stopBits,
                                      bool dtr,
                                      bool rts,
                                      bool xonxoff = false)
          {

           lock(m_locker){
              if(m_isOpen) return;
              // Create new Serial Port object
              m_port = new SerialPort(portName, baudRate, parity, dataBits, stopBits);

              // .........................................
              // Set class member variables.

              m_portName = portName;
              m_baudRate = baudRate;
              m_parity = parity;
              m_dataBits = dataBits;
              m_stopBits = stopBits;
              m_xonxoff = xonxoff;
              m_dtr = dtr;
              m_rts = rts;

              // ............................................
              // Initialize some port object properties

              // XOnXOff - parameter
              if (xonxoff)
                  m_port.Handshake = Handshake.XOnXOff;

              // Set DTR/RTS
              m_port.DtrEnable = dtr;
              m_port.RtsEnable = rts;

              // Set
              m_port.ReadTimeout = 500;
              m_port.WriteTimeout = 500;

              // ..............................................
              // Some final steps.

              // Open the port for communications
              m_port.Open();

              // If we get this far, mark port as opened.
              m_isOpen = true;
           }
          }

          public static void Close()
          {
                lock(m_locker){
                    if(m_isOpen) m_port.Close();
                }
          }

          /// <summary>
          /// Just makes sure to read the specified number of bytes from the serial port.
          /// Typical reads may return fewer bytes then told to read. This method is used
          /// to avoid this problem.
          /// Based on a similar function from Jon Skeet: http://jonskeet.uk/csharp/readbinary.html
          /// </summary>
          /// <param name="data"> [OUT] Data read should be stored here</param>
          /// <param name="length"> [IN] How much data to read exactly </param>
          /// <param name="count"> [IN] Some kind of retry count parameter.</param>
          private static void ReadAll(byte[] data, uint length, int retryCount)
          {

              // Check data length parameter.
              if (length > data.Length)
              {
                  throw new Exception("Wrong data length in ReadAll");
              }

              int offset = 0;
              int i = 0;
              int remaining = checked((int)length); // NOTE: Will throw OverflowException if length > Int32.MaxValue due to checked keyword.

              // Start reading.
              while (remaining > 0)
              {
                  // Just a retry count check
                  if (i >= retryCount)
                  {
                      throw new Exception("Exceeded retry count parameter during reading in ReadAll");
                  }

                  // Read Certain amount of bytes
                  int read = m_port.Read(data, offset, remaining);

                  // Was there error?
                  if (read <= 0)
                  {
                      throw new EndOfStreamException(String.Format("ReadAll(OldHaspCommunication) - End of data reached with {0} bytes left to read", remaining));
                  }

                  // Advance offset, and decrease remaining count.
                  remaining -= read;
                  offset += read;

                  i++;

              }


          }

          /// <summary>
          /// Write specified number of bytes to the serial port
          /// </summary>
          /// <param name="data"> [IN] Buffer from which to write data</param>
          /// <param name="length"> [IN] How many bytes to write</param>
          private static void WriteAll(byte[] data, uint length)
          {
              // TODO: Maybe we should add a retry count as in C++

              int len = checked((int)length); // NOTE: Will throw OverflowException if length > Int32.MaxValue due to checked keyword.

              // We can't write more data to serial port than available in the array.
              if (len > data.Length)
              {
                  throw new Exception("Wrong data length in WriteAll");
              }

              // Do the write.
              m_port.Write(data, 0, len);
          }

          public void Query(..)
          {
            lock(m_locker){
             // Protocol to talk to HASP
             WriteAll(..);
             ReadAll(..);
             WriteAll(..);
             ReadAll(..);
             }
          }

  }

class Tester
  {

   static readonly object m_otherlockA= new object();
   public static void function1()
   {
     lock(m_otherlockA)
     {
        HASPCLass.Query(..);
        HASPCLass.Query(..);
      }
   }

   public static void start()
   {
      HASPCLass.OpenPort(...)
   }

   public static void End()
   {
      HASPCLass.Close(...)
   }

   public static void function2()
   {
     lock(m_otherlockA)
     {
        HASPCLass.Query(..);
        HASPCLass.Query(..);
      }
   }
  }