Initialize

.vs/VSWorkspaceState.json

@@ -0,0 +1,6 @@
+{
+  "ExpandedNodes": [
+    ""
+  ],
+  "PreviewInSolutionExplorer": false
+}

FormLanguageSwitch/AssemblyInfo.cs

@@ -0,0 +1,58 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+//
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+//
+[assembly: AssemblyTitle("Form Language Switch")]
+[assembly: AssemblyDescription("Utility to instantly change localized language in .NET Windows form")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Form Language Switch")]
+[assembly: AssemblyCopyright("Copyright © 2020 by Eugen Höglinger")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]		
+
+//
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+
+[assembly: AssemblyVersion("1.2.*")]
+
+//
+// In order to sign your assembly you must specify a key to use. Refer to the 
+// Microsoft .NET Framework documentation for more information on assembly signing.
+//
+// Use the attributes below to control which key is used for signing. 
+//
+// Notes: 
+//   (*) If no key is specified, the assembly is not signed.
+//   (*) KeyName refers to a key that has been installed in the Crypto Service
+//       Provider (CSP) on your machine. KeyFile refers to a file which contains
+//       a key.
+//   (*) If the KeyFile and the KeyName values are both specified, the 
+//       following processing occurs:
+//       (1) If the KeyName can be found in the CSP, that key is used.
+//       (2) If the KeyName does not exist and the KeyFile does exist, the key 
+//           in the KeyFile is installed into the CSP and used.
+//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
+//       When specifying the KeyFile, the location of the KeyFile should be
+//       relative to the project output directory which is
+//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is
+//       located in the project directory, you would specify the AssemblyKeyFile 
+//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
+//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
+//       documentation for more information on this.
+//
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("")]
+[assembly: AssemblyKeyName("")]

FormLanguageSwitch/FormLanguageSwitch.cs

@@ -0,0 +1,708 @@
+using System;
+using System.Collections;
+using System.Diagnostics;
+using System.Drawing;
+using System.IO;
+using System.Reflection;
+using System.Threading;
+using System.Windows.Forms;
+
+namespace System.Globalization
+{
+
+    public class FormLanguageSwitchSingleton
+    {
+        #region Version und Copyright
+        // Version und Copyright
+        string dllName = Path.GetFileNameWithoutExtension(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase); //Den Programmnamen auslesen
+        string dllVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
+        static object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false);
+        string copyright = GenerateCopyright();
+        string icon = Application.StartupPath + "\\Info.bmp";
+        //Assembly Datum und Zeit
+        static DateTime value = AssemblyDateTime();
+        string date = value.ToShortDateString();
+        string time = value.ToLongTimeString();
+        private static DateTime AssemblyDateTime()
+        {
+            var version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
+            var buildDateTime = new DateTime(2000, 1, 1).Add(new TimeSpan(TimeSpan.TicksPerDay * version.Build + TimeSpan.TicksPerSecond * 2 * version.Revision));
+            //Tage seit dem 1. Januar 2000 und Sekunden seit Mitternacht, (multiplizier mit 2 ergibt das Original)
+            return buildDateTime;
+        }
+
+        private static string CurrentYear()
+        {
+            DateTime dtn = DateTime.Now;
+            return dtn.Year.ToString();
+        }
+
+        private static string StartYear()
+        {
+            string startYear = "";
+            if (((AssemblyCopyrightAttribute)attributes[0]).Copyright.Contains("Copyright © "))
+            {
+                startYear = ((AssemblyCopyrightAttribute)attributes[0]).Copyright.Replace("Copyright © ", "");
+                while (startYear.StartsWith(" "))
+                {
+                    startYear = startYear.Remove(0, 1);
+                }
+                startYear = startYear.Remove(startYear.IndexOf(" "));
+                return startYear;
+            }
+            else
+            {
+                DateTime dtn = DateTime.Now;
+                return dtn.Year.ToString();
+            }
+        }
+
+        private static string GenerateCopyright()
+        {
+            string startYear = StartYear();
+            string currentYear = CurrentYear();
+
+            if (startYear == currentYear)
+            {
+                return ((AssemblyCopyrightAttribute)attributes[0]).Copyright;
+            }
+            else
+            {
+                return ((AssemblyCopyrightAttribute)attributes[0]).Copyright.Replace(startYear, String.Concat(startYear, "-", currentYear));
+            }
+        }
+        #endregion
+        
+        #region DLL-Info
+        /// <summary>
+        /// Contains the name of the program file
+        /// </summary>
+        public static string DllName { set; get; }
+
+        /// <summary>
+        /// Contains the version of the program file
+        /// </summary>
+        public static string DllVersion { set; get; }
+
+        /// <summary>
+        /// Contains the copyright notice
+        /// </summary>
+        public static string Copyright { set; get; }
+
+        private void SetDllInfo()
+        {
+            //Name, Version und Copyright setzen
+            DllName = dllName;
+            DllVersion = dllVersion;
+            Copyright = copyright;
+        }
+        #endregion
+
+        /// <summary>
+        /// Static read-only instance.
+        /// </summary>
+        protected static readonly FormLanguageSwitchSingleton m_instance = new FormLanguageSwitchSingleton();
+        
+        /// <summary>
+        /// Hidden constructor called during static member <c>m_instance initialization.</c>
+        /// </summary>
+        protected FormLanguageSwitchSingleton()
+        {
+            SetDllInfo();
+        }
+
+        /// <summary>
+        /// Gets the only instance of the object.
+        /// </summary>
+        public static FormLanguageSwitchSingleton Instance
+        {
+            get { return m_instance; }
+        }
+
+        /// <summary>
+        /// Changes the current culture used by the Resource Manager to look up culture-specific resources at run time.
+        /// </summary>
+        /// <param name="cultureInfoIdentifier">
+        /// A <c>CultureInfo</c> object that will be applied to the application thread.
+        /// </param>
+        public void ChangeCurrentThreadUICulture(System.Globalization.CultureInfo cultureInfo)
+        {
+            Thread.CurrentThread.CurrentUICulture = cultureInfo;
+        }
+
+        /// <summary>
+        /// Changes the language of the <c>Form</c> object provided to the currently selected language.
+        /// </summary>
+        /// <param name="form">
+        /// <c>Form</c> object to apply changes to.
+        /// </param>
+        public void ChangeLanguage(System.Windows.Forms.Form form)
+        {
+            ChangeLanguage(form, Thread.CurrentThread.CurrentUICulture);
+        }
+
+        /// <summary>
+        /// Changes the language of the <c>Form</c> object provided and all its MDI
+        /// children (in the case of MDI UI) to the currently selected language.
+        /// </summary>
+        /// <param name="form">
+        /// <c>Form</c> object to apply changes to.
+        /// </param>
+        /// <param name="cultureInfo">
+        /// <c>CultureInfo</c> to which language has to be changed.
+        /// </param>
+        public void ChangeLanguage(System.Windows.Forms.Form form, System.Globalization.CultureInfo cultureInfo)
+        {
+            m_cultureInfo = cultureInfo;
+            ChangeFormLanguage(form);
+            foreach (System.Windows.Forms.Form childForm in form.MdiChildren)
+            {
+                ChangeFormLanguage(childForm);
+            }
+        }
+
+        /// <summary>
+        /// Changes <c>Text</c> properties associated with following 
+        /// controls: <c>AxHost</c>, <c>ButtonBase</c>, <c>GroupBox</c>, 
+        /// <c>Label</c>, <c>ScrollableControl</c>, <c>StatusBar</c>, 
+        /// <c>TabControl</c>, <c>ToolBar</c>. Method is made virtual so it 
+        /// can be overriden in derived class to redefine types.
+        /// </summary>
+        /// <param name="parent">
+        /// <c>Control</c> object.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> object.
+        /// </param>
+        protected virtual void ReloadTextForSelectedControls(System.Windows.Forms.Control control, System.Resources.ResourceManager resources)
+        {
+            if (control is System.Windows.Forms.AxHost ||
+                control is System.Windows.Forms.ButtonBase ||
+                control is System.Windows.Forms.GroupBox ||
+                control is System.Windows.Forms.Label ||
+                control is System.Windows.Forms.ScrollableControl ||
+                control is System.Windows.Forms.StatusBar ||
+                control is System.Windows.Forms.TabControl ||
+                control is System.Windows.Forms.ToolBar) {
+                control.Text = (string)GetSafeValue(resources, control.Name + ".Text", control.Text);
+            }
+        }
+
+        /// <summary>
+        /// Reloads properties common to all controls (except the <c>Text</c> property).
+        /// </summary>
+        /// <param name="control">
+        /// <c>Control</c> object for which resources should be reloaded.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> object.
+        /// </param>
+        protected virtual void ReloadControlCommonProperties(System.Windows.Forms.Control control, System.Resources.ResourceManager resources)
+        {
+            SetProperty(control, "AccessibleDescription", resources);
+            SetProperty(control, "AccessibleName", resources);
+            SetProperty(control, "BackgroundImage", resources);
+            SetProperty(control, "Font", resources);
+            SetProperty(control, "ImeMode", resources);
+            SetProperty(control, "RightToLeft", resources);
+            SetProperty(control, "Size", resources);
+            // following properties are not changed for the form
+            if (!(control is System.Windows.Forms.Form))
+            {
+                SetProperty(control, "Anchor", resources);
+                SetProperty(control, "Dock", resources);
+                SetProperty(control, "Enabled", resources);
+                SetProperty(control, "Location", resources);
+                SetProperty(control, "TabIndex", resources);
+                SetProperty(control, "Visible", resources);
+            }
+            if (control is System.Windows.Forms.ScrollableControl)
+            {
+                ReloadScrollableControlProperties((System.Windows.Forms.ScrollableControl)control, resources);
+                if (control is System.Windows.Forms.Form)
+                {
+                    ReloadFormProperties((System.Windows.Forms.Form)control, resources);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Reloads properties specific to some controls.
+        /// </summary>
+        /// <param name="control">
+        /// <c>Control</c> object for which resources should be reloaded.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> object.
+        /// </param>
+        protected virtual void ReloadControlSpecificProperties(System.Windows.Forms.Control control, System.Resources.ResourceManager resources)
+        {
+            // ImageIndex property for ButtonBase, Label, TabPage, ToolBarButton, TreeNode, TreeView
+            SetProperty(control, "ImageIndex", resources);
+            // ToolTipText property for StatusBar, TabPage, ToolBarButton
+            SetProperty(control, "ToolTipText", resources);
+            // IntegralHeight property for ComboBox, ListBox
+            SetProperty(control, "IntegralHeight", resources);
+            // ItemHeight property for ListBox, ComboBox, TreeView
+            SetProperty(control, "ItemHeight", resources);
+            // MaxDropDownItems property for ComboBox
+            SetProperty(control, "MaxDropDownItems", resources);
+            // MaxLength property for ComboBox, RichTextBox, TextBoxBase
+            SetProperty(control, "MaxLength", resources);
+            // Appearance property for CheckBox, RadioButton, TabControl, ToolBar
+            SetProperty(control, "Appearance", resources);
+            // CheckAlign property for CheckBox and RadioBox
+            SetProperty(control, "CheckAlign", resources);
+            // FlatStyle property for ButtonBase, GroupBox and Label
+            SetProperty(control, "FlatStyle", resources);
+            // ImageAlign property for ButtonBase, Image and Label
+            SetProperty(control, "ImageAlign", resources);
+            // Indent property for TreeView
+            SetProperty(control, "Indent", resources);
+            // Multiline property for RichTextBox, TabControl, TextBoxBase
+            SetProperty(control, "Multiline", resources);
+            // BulletIndent property for RichTextBox
+            SetProperty(control, "BulletIndent", resources);
+            // RightMargin property for RichTextBox
+            SetProperty(control, "RightMargin", resources);
+            // ScrollBars property for RichTextBox, TextBox
+            SetProperty(control, "ScrollBars", resources);
+            // WordWrap property for TextBoxBase
+            SetProperty(control, "WordWrap", resources);
+            // ZoomFactor property for RichTextBox
+            SetProperty(control, "ZoomFactor", resources);
+            // ButtonSize property for ToolBar
+            SetProperty(control, "ButtonSize", resources);
+            // ButtonSize property for ToolBar
+            SetProperty(control, "DropDownArrows", resources);
+            // ShowToolTips property for TabControl, ToolBar
+            SetProperty(control, "ShowToolTips", resources);
+            // Wrappable property for ToolBar
+            SetProperty(control, "Wrappable", resources);
+            // AutoSize property for Label, RichTextBox, ToolBar, TrackBar
+            SetProperty(control, "AutoSize", resources);
+        }
+
+        /// <summary>
+        /// Scans controls that are not contained by <c>Controls</c> collection,
+        /// like <c>MenuItem</c>s, <c>StatusBarPanel</c>s and <c>ColumnHeader</c>s.
+        /// </summary>
+        /// <param name="form">
+        /// <c>ContainerControl</c> object to scan.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> used to get localized resources.
+        /// </param>
+        protected virtual void ScanNonControls(System.Windows.Forms.ContainerControl containerControl, System.Resources.ResourceManager resources)
+        {
+            FieldInfo[] fieldInfo = containerControl.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public);
+            for (int i = 0; i < fieldInfo.Length; i++)
+            {
+                object obj = fieldInfo[i].GetValue(containerControl);
+                string fieldName = fieldInfo[i].Name;
+                if (obj is System.Windows.Forms.MenuItem)
+                {
+                    System.Windows.Forms.MenuItem menuItem = (System.Windows.Forms.MenuItem)obj;
+                    menuItem.Enabled        = (bool)(GetSafeValue(resources, fieldName + ".Enabled", menuItem.Enabled));
+                    menuItem.Shortcut       = (System.Windows.Forms.Shortcut)(GetSafeValue(resources, fieldName + ".Shortcut", menuItem.Shortcut));
+                    menuItem.ShowShortcut   = (bool)(GetSafeValue(resources, fieldName + ".ShowShortcut", menuItem.ShowShortcut));
+                    menuItem.Text           = (string)GetSafeValue(resources, fieldName + ".Text", menuItem.Text);
+                    menuItem.Visible        = (bool)(GetSafeValue(resources, fieldName + ".Visible", menuItem.Visible));
+                }
+                if (obj is System.Windows.Forms.ToolStripMenuItem)
+                {
+                    System.Windows.Forms.ToolStripMenuItem menuItem = (System.Windows.Forms.ToolStripMenuItem)obj;
+                    menuItem.Enabled = (bool)(GetSafeValue(resources, fieldName + ".Enabled", menuItem.Enabled));
+                    menuItem.Text = (string)GetSafeValue(resources, fieldName + ".Text", menuItem.Text);
+                }
+                if (obj is System.Windows.Forms.StatusBarPanel)
+                {
+                    System.Windows.Forms.StatusBarPanel panel = (System.Windows.Forms.StatusBarPanel)obj;
+                    panel.Alignment         = (System.Windows.Forms.HorizontalAlignment)(GetSafeValue(resources, fieldName + ".Alignment", panel.Alignment));
+                    panel.Icon              = (System.Drawing.Icon)(GetSafeValue(resources, fieldName + ".Icon", panel.Icon));
+                    panel.MinWidth          = (int)(GetSafeValue(resources, fieldName + ".MinWidth", panel.MinWidth));
+                    panel.Text              = (string)(GetSafeValue(resources, fieldName + ".Text", panel.Text));
+                    panel.ToolTipText       = (string)(GetSafeValue(resources, fieldName + ".ToolTipText", panel.ToolTipText));
+                    panel.Width             = (int)(GetSafeValue(resources, fieldName + ".Width", panel.Width));
+                }
+                if (obj is System.Windows.Forms.ColumnHeader)
+                {
+                    System.Windows.Forms.ColumnHeader header = (System.Windows.Forms.ColumnHeader)obj;
+                    header.Text             = (string)(GetSafeValue(resources, fieldName + ".Text", header.Text));
+                    header.TextAlign        = (System.Windows.Forms.HorizontalAlignment)(GetSafeValue(resources, fieldName + ".TextAlign", header.TextAlign));
+                    header.Width            = (int)(GetSafeValue(resources, fieldName + ".Width", header.Width));
+                }
+                if (obj is System.Windows.Forms.ToolBarButton)
+                {
+                    System.Windows.Forms.ToolBarButton button = (System.Windows.Forms.ToolBarButton)obj;
+                    button.Enabled          = (bool)(GetSafeValue(resources, fieldName + ".Enabled", button.Enabled));
+                    button.ImageIndex       = (int)(GetSafeValue(resources, fieldName + ".ImageIndex", button.ImageIndex));
+                    button.Text             = (string)(GetSafeValue(resources, fieldName + ".Text", button.Text));
+                    button.ToolTipText      = (string)(GetSafeValue(resources, fieldName + ".ToolTipText", button.ToolTipText));
+                    button.Visible          = (bool)(GetSafeValue(resources, fieldName + ".Visible", button.Visible));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets resource value. If resource for new culture does not exists, leaves the current.
+        /// </summary>
+        /// <param name="resources"></param>
+        /// <param name="name"></param>
+        /// <param name="currentValue"></param>
+        /// <returns></returns>
+        private object GetSafeValue(System.Resources.ResourceManager resources, string name, object currentValue)
+        {
+            object newValue = resources.GetObject(name, m_cultureInfo);
+            if (newValue == null)
+            {
+                Trace.WriteLine(string.Format("Resource for {0} not found, using current value.", name));
+                return currentValue;
+            }
+            return newValue;
+        }
+
+        /// <summary>
+        /// Reloads items in following controls: <c>ComboBox</c>, 
+        /// <c>ListBox</c>, <c>DomainUpDown</c>. Method is made virtual so 
+        /// it can be overriden in derived class to redefine types.
+        /// </summary>
+        /// <param name="parent">
+        /// <c>Control</c> object.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> object.
+        /// </param>
+        protected virtual void ReloadListItems(System.Windows.Forms.Control control, System.Resources.ResourceManager resources)
+        {
+            if (control is System.Windows.Forms.ComboBox)
+            {
+                ReloadComboBoxItems((System.Windows.Forms.ComboBox)control, resources);
+            }
+            else if (control is System.Windows.Forms.ListBox)
+            {
+                ReloadListBoxItems((System.Windows.Forms.ListBox)control, resources);
+            }
+            else if (control is System.Windows.Forms.DomainUpDown)
+            {
+                ReloadUpDownItems((System.Windows.Forms.DomainUpDown)control, resources);
+            }
+        }
+
+        /// <summary>
+        /// Changes the language of the form.
+        /// </summary>
+        /// <param name="form">
+        /// <c>Form</c> object to apply changes to. 
+        /// </param>
+        private void ChangeFormLanguage(System.Windows.Forms.Form form)
+        {
+            form.SuspendLayout();
+            Cursor.Current = Cursors.WaitCursor;
+            System.Resources.ResourceManager resources = new System.Resources.ResourceManager(form.GetType());
+            // change main form resources
+            form.Text = (string)(GetSafeValue(resources, "$this.Text", form.Text));
+            ReloadControlCommonProperties(form, resources);
+            ToolTip toolTip = GetToolTip(form);
+            // change text of all containing controls
+            RecurControls(form, resources, toolTip);
+            // change the text of menus
+            ScanNonControls(form, resources);
+            form.ResumeLayout();
+        }
+
+        /// <summary>
+        /// Gets the <c>ToolTip</c> member of the control (<c>Form</c> or <c>UserControl</c>).
+        /// </summary>
+        /// <param name="control">
+        /// <c>Control</c> for which tooltip is requested.
+        /// </param>
+        /// <returns>
+        /// <c>ToolTip</c> of the control or <c>null</c> if not defined.
+        /// </returns>
+        private ToolTip GetToolTip(System.Windows.Forms.Control control)
+        {
+            Debug.Assert(control is System.Windows.Forms.Form || control is System.Windows.Forms.UserControl);
+            FieldInfo[] fieldInfo = control.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public);
+            for (int i = 0; i < fieldInfo.Length; i++)
+            {
+                object obj = fieldInfo[i].GetValue(control);
+                if (obj is System.Windows.Forms.ToolTip)
+                {
+                    return (ToolTip)obj;
+                }
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Recurs <c>Controls</c> members of the control to change corresponding texts.
+        /// </summary>
+        /// <param name="parent">
+        /// Parent <c>Control</c> object.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> object.
+        /// </param>
+        private void RecurControls(System.Windows.Forms.Control parent, System.Resources.ResourceManager resources, System.Windows.Forms.ToolTip toolTip)
+        {
+            foreach (Control control in parent.Controls)
+            {
+                control.SuspendLayout();
+                ReloadControlCommonProperties(control, resources);
+                ReloadControlSpecificProperties(control, resources);
+                if (toolTip != null)
+                {
+                    toolTip.SetToolTip(control, (string)GetSafeValue(resources, control.Name + ".ToolTip", control.Text));
+                }
+                if (control is System.Windows.Forms.UserControl)
+                {
+                    RecurUserControl((System.Windows.Forms.UserControl)control);
+                }
+                else
+                {
+                    ReloadTextForSelectedControls(control, resources);
+                    ReloadListItems(control, resources);
+                    if (control is System.Windows.Forms.TreeView)
+                    {
+                        ReloadTreeViewNodes((System.Windows.Forms.TreeView)control, resources);
+                    }
+                    if (control.Controls.Count > 0)
+                    {
+                        RecurControls(control, resources, toolTip);
+                    }
+                }
+                control.ResumeLayout();
+            }
+        }
+
+        /// <summary>
+        /// Reloads resources specific to the <c>Form</c> type.
+        /// </summary>
+        /// <param name="form">
+        /// <c>Form</c> object to apply changes to.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> object.
+        /// </param>
+        private void ReloadFormProperties(System.Windows.Forms.Form form, System.Resources.ResourceManager resources)
+        {
+            SetProperty(form, "AutoScaleBaseSize", resources);
+            SetProperty(form, "Icon", resources);
+            SetProperty(form, "MaximumSize", resources);
+            SetProperty(form, "MinimumSize", resources);
+        }
+
+        /// <summary>
+        /// Reloads resources specific to the <c>ScrollableControl</c> type.
+        /// </summary>
+        /// <param name="control">
+        /// <c>Control</c> object for which resources should be reloaded.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> object.
+        /// </param>
+        private void ReloadScrollableControlProperties(System.Windows.Forms.ScrollableControl control, System.Resources.ResourceManager resources)
+        {
+            SetProperty(control, "AutoScroll", resources);
+            SetProperty(control, "AutoScrollMargin", resources);
+            SetProperty(control, "AutoScrollMinSize", resources);
+        }
+
+        /// <summary>
+        /// Reloads resources for a property.
+        /// </summary>
+        /// <param name="control">
+        /// <c>Control</c> object for which resources should be reloaded.
+        /// </param>
+        /// <param name="propertyName">
+        /// Name of the property to reload.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> object.
+        /// </param>
+        private void SetProperty(System.Windows.Forms.Control control, string propertyName, System.Resources.ResourceManager resources)
+        {
+            try
+            {
+                PropertyInfo propertyInfo = control.GetType().GetProperty(propertyName);
+                if (propertyInfo != null)
+                {
+                    string controlName = control.Name;
+                    if (control is System.Windows.Forms.Form)
+                    {
+                        controlName = "$this";
+                    }
+                    object resObject = resources.GetObject(controlName + "." + propertyName, m_cultureInfo);
+                    if (resObject != null)
+                    {
+                        propertyInfo.SetValue(control, Convert.ChangeType(resObject, propertyInfo.PropertyType), null);
+                    }
+                }
+            }
+            catch (AmbiguousMatchException e)
+            {
+                Trace.WriteLine(e.ToString());
+            }
+        }
+        
+        /// <summary>
+        /// Recurs <c>UserControl</c> to change.
+        /// </summary>
+        /// <param name="parent">
+        /// <c>UserControl</c> object to scan.
+        /// </param>
+        private void RecurUserControl(System.Windows.Forms.UserControl userControl)
+        {
+            System.Resources.ResourceManager resources = new System.Resources.ResourceManager(userControl.GetType());
+            ToolTip toolTip = GetToolTip(userControl);
+            RecurControls(userControl, resources, toolTip);
+            // addition suggested by Piotr Sielski:
+            ScanNonControls(userControl, resources);
+        }
+
+        /// <summary>
+        /// Reloads items in the <c>ListBox</c>. If items are not sorted, selections are kept.
+        /// </summary>
+        /// <param name="listBox">
+        /// <c>ListBox</c> to localize.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> object.
+        /// </param>
+        private void ReloadListBoxItems(System.Windows.Forms.ListBox listBox, System.Resources.ResourceManager resources)
+        {
+            if (listBox.Items.Count > 0)
+            {
+                int[] selectedItems = new int[listBox.SelectedIndices.Count];
+                listBox.SelectedIndices.CopyTo(selectedItems, 0);
+                ReloadItems(listBox.Name, listBox.Items, listBox.Items.Count, resources);
+                if (!listBox.Sorted)
+                {
+                    for (int i = 0; i < selectedItems.Length; i++)
+                    {
+                        listBox.SetSelected(selectedItems[i], true);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Reloads items in the <c>ComboBox</c>. If items are not sorted, selection is kept.
+        /// </summary>
+        /// <param name="listBox">
+        /// <c>ComboBox</c> to localize.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> object.
+        /// </param>
+        private void ReloadComboBoxItems(System.Windows.Forms.ComboBox comboBox, System.Resources.ResourceManager resources)
+        {
+            if (comboBox.Items.Count > 0)
+            {
+                int selectedIndex = comboBox.SelectedIndex;
+                ReloadItems(comboBox.Name, comboBox.Items, comboBox.Items.Count, resources);
+                if (!comboBox.Sorted)
+                {
+                    comboBox.SelectedIndex = selectedIndex;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Reloads items in the <c>DomainUpDown</c> control. If items are not sorted, selection is kept.
+        /// </summary>
+        /// <param name="listBox">
+        /// <c>DomainUpDown</c> to localize.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> object.
+        /// </param>
+        private void ReloadUpDownItems(System.Windows.Forms.DomainUpDown domainUpDown, System.Resources.ResourceManager resources)
+        {
+            if (domainUpDown.Items.Count > 0)
+            {
+                int selectedIndex = domainUpDown.SelectedIndex;
+                ReloadItems(domainUpDown.Name, domainUpDown.Items, domainUpDown.Items.Count, resources);
+                if (!domainUpDown.Sorted)
+                {
+                    domainUpDown.SelectedIndex = selectedIndex;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Reloads content of a <c>TreeView</c>.
+        /// </summary>
+        /// <param name="treeView">
+        /// <c>TreeView</c> control to reload.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> object.
+        /// </param>
+        private void ReloadTreeViewNodes(System.Windows.Forms.TreeView treeView, System.Resources.ResourceManager resources)
+        {
+            if (treeView.Nodes.Count > 0)
+            {
+                string resourceName = treeView.Name + ".Nodes";
+                TreeNode[] newNodes = new TreeNode[treeView.Nodes.Count];
+                newNodes[0] = (System.Windows.Forms.TreeNode)resources.GetObject(resourceName, m_cultureInfo);
+                // VS2002 generates node resource names with additional ".Nodes" string
+                if (newNodes[0] == null)
+                {
+                    resourceName += ".Nodes";
+                    newNodes[0] = (System.Windows.Forms.TreeNode)resources.GetObject(resourceName, m_cultureInfo);
+                }
+                Debug.Assert(newNodes[0] != null);
+                for (int i = 1; i < treeView.Nodes.Count; i++)
+                {
+                    newNodes[i] = (System.Windows.Forms.TreeNode)resources.GetObject(resourceName + i.ToString(), m_cultureInfo);
+                }
+                treeView.Nodes.Clear();
+                treeView.Nodes.AddRange(newNodes);
+            }
+        }
+
+        /// <summary>
+        /// Clears all items in the <c>IList</c> and reloads the list with items according to language settings.
+        /// </summary>
+        /// <param name="controlName">
+        /// Name of the control.
+        /// </param>
+        /// <param name="list">
+        /// <c>IList</c> with items to change.
+        /// </param>
+        /// <param name="itemsNumber">
+        /// Number of items.
+        /// </param>
+        /// <param name="resources">
+        /// <c>ResourceManager</c> object.
+        /// </param>
+        private void ReloadItems(string controlName, IList list, int itemsNumber, System.Resources.ResourceManager resources)
+        {
+            string resourceName = controlName + ".Items";
+            object obj = resources.GetString(resourceName, m_cultureInfo);
+            // VS2002 generates item resource name with additional ".Items" string
+            if (obj == null)
+            {
+                resourceName += ".Items";
+                obj = resources.GetString(resourceName, m_cultureInfo);
+            }
+            if (obj != null)
+            {
+                list.Clear();
+                Debug.Assert(obj != null);
+                list.Add(obj);
+                for (int i = 1; i < itemsNumber; i++)
+                {
+                    list.Add(resources.GetString(resourceName + i, m_cultureInfo));
+                }
+            }
+        }
+
+        /// <summary>
+        /// <c>CultureInfo</c> used by Resource Manager.
+        /// </summary>
+        private System.Globalization.CultureInfo m_cultureInfo;
+    }
+}

FormLanguageSwitch/FormLanguageSwitch.csproj

@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build">
+  <PropertyGroup>
+    <ProjectType>Local</ProjectType>
+    <ProductVersion>7.0.9955</ProductVersion>
+    <SchemaVersion>1.0</SchemaVersion>
+    <ProjectGuid>{787B600C-9A56-41C7-A3C8-9553630FE3C1}</ProjectGuid>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ApplicationIcon />
+    <AssemblyKeyContainerName />
+    <AssemblyName>FormLanguageSwitch</AssemblyName>
+    <AssemblyOriginatorKeyFile />
+    <DefaultClientScript>JScript</DefaultClientScript>
+    <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>
+    <DefaultTargetSchema>IE50</DefaultTargetSchema>
+    <DelaySign>false</DelaySign>
+    <OutputType>Library</OutputType>
+    <RootNamespace>System.Globalization</RootNamespace>
+    <StartupObject />
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <OldToolsVersion>0.0</OldToolsVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <OutputPath>bin\Debug\</OutputPath>
+    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
+    <BaseAddress>285212672</BaseAddress>
+    <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
+    <ConfigurationOverrideFile />
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DocumentationFile />
+    <DebugSymbols>true</DebugSymbols>
+    <FileAlignment>4096</FileAlignment>
+    <Optimize>false</Optimize>
+    <RegisterForComInterop>false</RegisterForComInterop>
+    <RemoveIntegerChecks>false</RemoveIntegerChecks>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <WarningLevel>4</WarningLevel>
+    <DebugType>full</DebugType>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <OutputPath>bin\Release\</OutputPath>
+    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
+    <BaseAddress>285212672</BaseAddress>
+    <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
+    <ConfigurationOverrideFile />
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile />
+    <DebugSymbols>false</DebugSymbols>
+    <FileAlignment>4096</FileAlignment>
+    <Optimize>true</Optimize>
+    <RegisterForComInterop>false</RegisterForComInterop>
+    <RemoveIntegerChecks>false</RemoveIntegerChecks>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <WarningLevel>4</WarningLevel>
+    <DebugType>none</DebugType>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System">
+      <Name>System</Name>
+    </Reference>
+    <Reference Include="System.Data">
+      <Name>System.Data</Name>
+    </Reference>
+    <Reference Include="System.Drawing">
+      <Name>System.Drawing</Name>
+    </Reference>
+    <Reference Include="System.Windows.Forms">
+      <Name>System.Windows.Forms</Name>
+    </Reference>
+    <Reference Include="System.Xml">
+      <Name>System.XML</Name>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AssemblyInfo.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="FormLanguageSwitch.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="LanguageCollector.cs">
+      <SubType>Code</SubType>
+    </Compile>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent />
+    <PostBuildEvent />
+  </PropertyGroup>
+</Project>

FormLanguageSwitch/LanguageCollector.cs

@@ -0,0 +1,158 @@
+using System;
+using System.Collections;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+
+namespace System.Globalization
+{
+    public class CultureInfoDisplayItem
+    {
+        public CultureInfoDisplayItem(string displayName, CultureInfo cultureInfo)
+        {
+            DisplayName = displayName;
+            CultureInfo = cultureInfo;
+        }
+
+        public override string ToString()
+        {
+            return DisplayName;
+        }
+
+        public string DisplayName;
+
+        public readonly CultureInfo CultureInfo;
+    }
+
+    
+    /// <summary>
+	/// Class responsible to collect available localized resources.
+	/// </summary>
+	public class LanguageCollector
+    {
+
+        public enum LanguageNameDisplay
+        {
+            DisplayName,
+            EnglishName,
+            NativeName
+        }
+
+        /// <summary>
+        /// Initializes <c>LanguageCollector</c> object with a list of 
+        /// available localized resources based on subfolders names.
+        /// </summary>
+        public LanguageCollector()
+        {
+            m_avalableCutureInfos = GetApplicationAvailableCultures();
+            Debug.Assert(m_avalableCutureInfos != null);
+        }
+
+        /// <summary>
+        /// Initializes <c>LanguageCollector</c> object with a list of available localized resources
+        /// based on subfolders names plus <c>CultureInfo</c> supplied as a default culture.
+        /// </summary>
+        /// <param name="defaultCultureInfo">
+        /// Default culure for which application did not create subfolder.
+        /// </param>
+        public LanguageCollector(CultureInfo defaultCultureInfo) : this()
+        {
+            if (!m_avalableCutureInfos.Contains(defaultCultureInfo))
+            {
+                m_avalableCutureInfos.Add(defaultCultureInfo);
+                m_avalableCutureInfos.Sort(new CultureInfoComparer());
+            }
+            Debug.Assert(m_avalableCutureInfos != null);
+        }
+
+        private class CultureInfoComparer : IComparer
+        {
+
+            int IComparer.Compare(object x, object y)
+            {
+                return Compare((CultureInfo)x, (CultureInfo)y);
+            }
+
+            public int Compare(CultureInfo cix, CultureInfo ciy)
+            {
+                return string.Compare(cix.Name, ciy.Name);
+            }
+
+        }
+
+        /// <summary>
+        /// Returns an array of <c>CultureInfoDisplayItem</c> objects for all available localized resources.
+        /// </summary>
+        /// <param name="languageNameToDisplay">
+        /// <c>LanguageNameDisplay</c> value defining how language will be displayed.
+        /// </param>
+        /// <param name="currentLanguage">
+        /// Index of currently active UI culture.
+        /// </param>
+        /// <returns>
+        /// An array of <c>CultureInfoDisplayItem</c> objects, sorted by their names (not <c>DisplayName</c>s).
+        /// </returns>
+        public CultureInfoDisplayItem[] GetLanguages(LanguageNameDisplay languageNameToDisplay, out int currentLanguage)
+        {
+            CultureInfoDisplayItem[] cidi = new CultureInfoDisplayItem[m_avalableCutureInfos.Count];
+            currentLanguage = -1;
+            string currentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture.Name;
+            string parentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture.Parent.Name;
+            for (int i = 0; i < m_avalableCutureInfos.Count; i++)
+            {
+                CultureInfo ci = (CultureInfo)m_avalableCutureInfos[i];
+                string displayName = GetDisplayName(ci, languageNameToDisplay);
+                cidi[i] = new CultureInfoDisplayItem(displayName, ci);
+                if (currentCulture == ci.Name || (currentLanguage == -1 && parentCulture == ci.Name))
+                    currentLanguage = i;
+            }
+            Debug.Assert(currentLanguage > -1 && currentLanguage < m_avalableCutureInfos.Count);
+            return cidi;
+        }
+
+        private string GetDisplayName(CultureInfo cultureInfo, LanguageNameDisplay languageNameToDisplay)
+        {
+            switch (languageNameToDisplay)
+            {
+            case LanguageNameDisplay.DisplayName:
+                return cultureInfo.DisplayName;
+            case LanguageNameDisplay.EnglishName:
+                return cultureInfo.EnglishName;
+            case LanguageNameDisplay.NativeName:
+                return cultureInfo.NativeName;
+            }
+            Debug.Assert(false, string.Format("Not supported LanguageNameDisplay value {0}", languageNameToDisplay));
+            return "";
+        }
+
+        private Hashtable GetAllCultures()
+        {
+            CultureInfo[] cis = CultureInfo.GetCultures(CultureTypes.AllCultures);
+            Hashtable allCultures = new Hashtable(cis.Length);
+            foreach (CultureInfo ci in cis)
+            {
+                allCultures.Add(ci.Name, ci);
+            }
+            return allCultures;
+        }
+
+        private ArrayList GetApplicationAvailableCultures()
+        {
+            ArrayList availableCultures = new ArrayList();
+            Hashtable allCultures = GetAllCultures();
+            string executableRoot = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+            foreach (string directory in Directory.GetDirectories(executableRoot))
+            {
+                string subDirectory = Path.GetFileName(directory);
+                CultureInfo ci = (CultureInfo)allCultures[subDirectory];
+                if (ci != null)
+                {
+                    availableCultures.Add(ci);
+                }
+            }
+            return availableCultures;
+        }
+
+        private ArrayList m_avalableCutureInfos;
+	}
+}

FormLanguageSwitch/obj/Debug/.NETFramework,Version=v4.0.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.0", FrameworkDisplayName = ".NET Framework 4")]

FormLanguageSwitch/obj/Debug/FormLanguageSwitch.csproj.CoreCompileInputs.cache

@@ -0,0 +1 @@
+6ff992535ae4b815455fe7ad84bbac547d7b2a6d

FormLanguageSwitch/obj/Debug/FormLanguageSwitch.csproj.FileListAbsolute.txt

@@ -0,0 +1,18 @@
+H:\Programmieren\Git-Repository\VisualStudio\FormLanguageSwitch_src\FormLanguageSwitch\FormLanguageSwitch\bin\Debug\FormLanguageSwitch.dll
+H:\Programmieren\Git-Repository\VisualStudio\FormLanguageSwitch_src\FormLanguageSwitch\FormLanguageSwitch\bin\Debug\FormLanguageSwitch.pdb
+H:\Programmieren\Git-Repository\VisualStudio\FormLanguageSwitch_src\FormLanguageSwitch\FormLanguageSwitch\obj\Debug\FormLanguageSwitch.csprojAssemblyReference.cache
+H:\Programmieren\Git-Repository\VisualStudio\FormLanguageSwitch_src\FormLanguageSwitch\FormLanguageSwitch\obj\Debug\FormLanguageSwitch.csproj.CoreCompileInputs.cache
+H:\Programmieren\Git-Repository\VisualStudio\FormLanguageSwitch_src\FormLanguageSwitch\FormLanguageSwitch\obj\Debug\FormLanguageSwitch.dll
+H:\Programmieren\Git-Repository\VisualStudio\FormLanguageSwitch_src\FormLanguageSwitch\FormLanguageSwitch\obj\Debug\FormLanguageSwitch.pdb
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\FormLanguageSwitch\bin\Debug\FormLanguageSwitch.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\FormLanguageSwitch\bin\Debug\FormLanguageSwitch.pdb
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\FormLanguageSwitch\obj\Debug\FormLanguageSwitch.csprojAssemblyReference.cache
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\FormLanguageSwitch\obj\Debug\FormLanguageSwitch.csproj.CoreCompileInputs.cache
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\FormLanguageSwitch\obj\Debug\FormLanguageSwitch.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\FormLanguageSwitch\obj\Debug\FormLanguageSwitch.pdb
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\FormLanguageSwitch\bin\Debug\FormLanguageSwitch.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\FormLanguageSwitch\bin\Debug\FormLanguageSwitch.pdb
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\FormLanguageSwitch\obj\Debug\FormLanguageSwitch.csprojAssemblyReference.cache
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\FormLanguageSwitch\obj\Debug\FormLanguageSwitch.csproj.CoreCompileInputs.cache
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\FormLanguageSwitch\obj\Debug\FormLanguageSwitch.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\FormLanguageSwitch\obj\Debug\FormLanguageSwitch.pdb

ReplaceString/AppResources.Designer.cs

@@ -0,0 +1,100 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     Dieser Code wurde von einem Tool generiert.
+//     Laufzeitversion:4.0.30319.42000
+//
+//     Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn
+//     der Code erneut generiert wird.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace Eugen.ESystem.Windows.Forms {
+    using System;
+    
+    
+    /// <summary>
+    ///   Eine stark typisierte Ressourcenklasse zum Suchen von lokalisierten Zeichenfolgen usw.
+    /// </summary>
+    // Diese Klasse wurde von der StronglyTypedResourceBuilder automatisch generiert
+    // -Klasse über ein Tool wie ResGen oder Visual Studio automatisch generiert.
+    // Um einen Member hinzuzufügen oder zu entfernen, bearbeiten Sie die .ResX-Datei und führen dann ResGen
+    // mit der /str-Option erneut aus, oder Sie erstellen Ihr VS-Projekt neu.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class AppResources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal AppResources() {
+        }
+        
+        /// <summary>
+        ///   Gibt die zwischengespeicherte ResourceManager-Instanz zurück, die von dieser Klasse verwendet wird.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ReplaceString.AppResources", typeof(AppResources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Überschreibt die CurrentUICulture-Eigenschaft des aktuellen Threads für alle
+        ///   Ressourcenzuordnungen, die diese stark typisierte Ressourcenklasse verwenden.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Warnung ähnelt.
+        /// </summary>
+        internal static string messagebox001caption {
+            get {
+                return ResourceManager.GetString("messagebox001caption", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Eingabe unvollständig!
+        ///Bitte füllen Sie die Eingabefelder vollständig aus. ähnelt.
+        /// </summary>
+        internal static string messagebox001text {
+            get {
+                return ResourceManager.GetString("messagebox001text", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Information ähnelt.
+        /// </summary>
+        internal static string messagebox002caption {
+            get {
+                return ResourceManager.GetString("messagebox002caption", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Es wurde keine (weitere) Übereinstimmung gefunden. ähnelt.
+        /// </summary>
+        internal static string messagebox002text {
+            get {
+                return ResourceManager.GetString("messagebox002text", resourceCulture);
+            }
+        }
+    }
+}

ReplaceString/AppResources.de.resx

@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="messagebox001caption" xml:space="preserve">
+    <value>Warnung</value>
+  </data>
+  <data name="messagebox001text" xml:space="preserve">
+    <value>Eingabe unvollständig!
+Bitte füllen Sie die Eingabefelder vollständig aus.</value>
+  </data>
+  <data name="messagebox002caption" xml:space="preserve">
+    <value>Information</value>
+  </data>
+  <data name="messagebox002text" xml:space="preserve">
+    <value>Es wurde keine (weitere) Übereinstimmung gefunden.</value>
+  </data>
+</root>

ReplaceString/AppResources.en.resx

@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="messagebox001caption" xml:space="preserve">
+    <value>Warning</value>
+  </data>
+  <data name="messagebox001text" xml:space="preserve">
+    <value>Input incomplete!
+Please fill out the input fields completely.</value>
+  </data>
+  <data name="messagebox002caption" xml:space="preserve">
+    <value>Information</value>
+  </data>
+  <data name="messagebox002text" xml:space="preserve">
+    <value>No (further) match was found.</value>
+  </data>
+</root>

ReplaceString/AppResources.resx

@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="messagebox001caption" xml:space="preserve">
+    <value>Warnung</value>
+  </data>
+  <data name="messagebox001text" xml:space="preserve">
+    <value>Eingabe unvollständig!
+Bitte füllen Sie die Eingabefelder vollständig aus.</value>
+  </data>
+  <data name="messagebox002caption" xml:space="preserve">
+    <value>Information</value>
+  </data>
+  <data name="messagebox002text" xml:space="preserve">
+    <value>Es wurde keine (weitere) Übereinstimmung gefunden.</value>
+  </data>
+</root>

ReplaceString/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// Allgemeine Informationen über eine Assembly werden über die folgenden
+// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern,
+// die einer Assembly zugeordnet sind.
+[assembly: AssemblyTitle("ReplaceString")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("ReplaceString")]
+[assembly: AssemblyCopyright("Copyright © 2020 by Eugen Höglinger")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Durch Festlegen von ComVisible auf FALSE werden die Typen in dieser Assembly
+// für COM-Komponenten unsichtbar.  Wenn Sie auf einen Typ in dieser Assembly von
+// COM aus zugreifen müssen, sollten Sie das ComVisible-Attribut für diesen Typ auf "True" festlegen.
+[assembly: ComVisible(false)]
+
+// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird
+[assembly: Guid("b402b197-7eba-4994-9fcd-a658b23648b0")]
+
+// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten:
+//
+//      Hauptversion
+//      Nebenversion
+//      Buildnummer
+//      Revision
+//
+// Sie können alle Werte angeben oder Standardwerte für die Build- und Revisionsnummern verwenden,
+// indem Sie "*" wie unten gezeigt eingeben:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

ReplaceString/Replace.Designer.cs

@@ -0,0 +1,96 @@
+namespace Eugen.ESystem.Windows.Forms
+{
+    partial class Replace
+    {
+        /// <summary>
+        /// Erforderliche Designervariable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Verwendete Ressourcen bereinigen.
+        /// </summary>
+        /// <param name="disposing">True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Vom Komponenten-Designer generierter Code
+
+        /// <summary>
+        /// Erforderliche Methode für die Designerunterstützung. 
+        /// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Replace));
+            this.groupBoxReplace = new System.Windows.Forms.GroupBox();
+            this.buttonReplaceAll = new System.Windows.Forms.Button();
+            this.buttonReplace = new System.Windows.Forms.Button();
+            this.textBoxSubstituteString = new System.Windows.Forms.TextBox();
+            this.labelSubstituteString = new System.Windows.Forms.Label();
+            this.groupBoxReplace.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // groupBoxReplace
+            // 
+            resources.ApplyResources(this.groupBoxReplace, "groupBoxReplace");
+            this.groupBoxReplace.Controls.Add(this.buttonReplaceAll);
+            this.groupBoxReplace.Controls.Add(this.buttonReplace);
+            this.groupBoxReplace.Controls.Add(this.textBoxSubstituteString);
+            this.groupBoxReplace.Controls.Add(this.labelSubstituteString);
+            this.groupBoxReplace.Name = "groupBoxReplace";
+            this.groupBoxReplace.TabStop = false;
+            // 
+            // buttonReplaceAll
+            // 
+            resources.ApplyResources(this.buttonReplaceAll, "buttonReplaceAll");
+            this.buttonReplaceAll.Name = "buttonReplaceAll";
+            this.buttonReplaceAll.UseVisualStyleBackColor = true;
+            this.buttonReplaceAll.Click += new System.EventHandler(this.buttonReplaceAll_Click);
+            // 
+            // buttonReplace
+            // 
+            resources.ApplyResources(this.buttonReplace, "buttonReplace");
+            this.buttonReplace.Name = "buttonReplace";
+            this.buttonReplace.UseVisualStyleBackColor = true;
+            this.buttonReplace.Click += new System.EventHandler(this.buttonReplace_Click);
+            // 
+            // textBoxSubstituteString
+            // 
+            resources.ApplyResources(this.textBoxSubstituteString, "textBoxSubstituteString");
+            this.textBoxSubstituteString.Name = "textBoxSubstituteString";
+            this.textBoxSubstituteString.Click += new System.EventHandler(this.textBoxSubstituteString_Click);
+            this.textBoxSubstituteString.KeyDown += new System.Windows.Forms.KeyEventHandler(this.textBoxSubstituteString_KeyDown);
+            // 
+            // labelSubstituteString
+            // 
+            resources.ApplyResources(this.labelSubstituteString, "labelSubstituteString");
+            this.labelSubstituteString.Name = "labelSubstituteString";
+            // 
+            // Replace
+            // 
+            resources.ApplyResources(this, "$this");
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.Controls.Add(this.groupBoxReplace);
+            this.Name = "Replace";
+            this.groupBoxReplace.ResumeLayout(false);
+            this.groupBoxReplace.PerformLayout();
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.GroupBox groupBoxReplace;
+        private System.Windows.Forms.TextBox textBoxSubstituteString;
+        private System.Windows.Forms.Label labelSubstituteString;
+        private System.Windows.Forms.Button buttonReplaceAll;
+        private System.Windows.Forms.Button buttonReplace;
+    }
+}

ReplaceString/Replace.cs

@@ -0,0 +1,506 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace Eugen.ESystem.Windows.Forms
+{
+    public partial class Replace: UserControl
+    {
+        #region Version und Copyright
+        // Version und Copyright
+        string dllName = Path.GetFileNameWithoutExtension(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase); //Den Programmnamen auslesen
+        string dllVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
+        static object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false);
+        string copyright = GenerateCopyright();
+        string icon = Application.StartupPath + "\\Info.bmp";
+        //Assembly Datum und Zeit
+        static DateTime value = AssemblyDateTime();
+        string date = value.ToShortDateString();
+        string time = value.ToLongTimeString();
+        private static DateTime AssemblyDateTime()
+        {
+            var version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
+            var buildDateTime = new DateTime(2000, 1, 1).Add(new TimeSpan(TimeSpan.TicksPerDay * version.Build + TimeSpan.TicksPerSecond * 2 * version.Revision));
+            //Tage seit dem 1. Januar 2000 und Sekunden seit Mitternacht, (multiplizier mit 2 ergibt das Original)
+            return buildDateTime;
+        }
+
+        private static string CurrentYear()
+        {
+            DateTime dtn = DateTime.Now;
+            return dtn.Year.ToString();
+        }
+
+        private static string StartYear()
+        {
+            string startYear = "";
+            if (((AssemblyCopyrightAttribute)attributes[0]).Copyright.Contains("Copyright © "))
+            {
+                startYear = ((AssemblyCopyrightAttribute)attributes[0]).Copyright.Replace("Copyright © ", "");
+                while (startYear.StartsWith(" "))
+                {
+                    startYear = startYear.Remove(0, 1);
+                }
+                startYear = startYear.Remove(startYear.IndexOf(" "));
+                return startYear;
+            }
+            else
+            {
+                DateTime dtn = DateTime.Now;
+                return dtn.Year.ToString();
+            }
+        }
+
+        private static string GenerateCopyright()
+        {
+            string startYear = StartYear();
+            string currentYear = CurrentYear();
+
+            if (startYear == currentYear)
+            {
+                return ((AssemblyCopyrightAttribute)attributes[0]).Copyright;
+            }
+            else
+            {
+                return ((AssemblyCopyrightAttribute)attributes[0]).Copyright.Replace(startYear, String.Concat(startYear, "-", currentYear));
+            }
+        }
+        #endregion
+
+        #region DLL-Info
+        /// <summary>
+        /// Contains the name of the program file
+        /// </summary>
+        public static string DllName { set; get; }
+
+        /// <summary>
+        /// Contains the version of the program file
+        /// </summary>
+        public static string DllVersion { set; get; }
+
+        /// <summary>
+        /// Contains the copyright notice
+        /// </summary>
+        public static string Copyright { set; get; }
+
+        private void SetDllInfo()
+        {
+            //Name, Version und Copyright setzen
+            DllName = dllName;
+            DllVersion = dllVersion;
+            Copyright = copyright;
+        }
+        #endregion
+
+        /// <summary>
+        /// Replaces a string with another
+        /// </summary>
+        public Replace()
+        {
+            InitializeComponent();
+            SetDllInfo();
+            search.SetSearchString();
+            MoreMatch = true;
+        }
+
+        #region GlobaleVariablen
+        protected string SearchText { set; get; }
+        protected string SearchString { set; get; }
+        protected int SearchStringLength { set; get; }
+        protected int Index { set; get; }
+        /// <summary>
+        /// Contains the current cursor position
+        /// </summary>
+        protected int CurrentCursorPosition { set; get; }
+        /// <summary>
+        /// Contains a list with all found positions
+        /// </summary>
+        protected List<int> AllPositions { set; get; }
+        /// <summary>
+        /// String with which the search string should be replaced.
+        /// </summary>
+        protected string SubstituteString { set; get; }
+        /// <summary>
+        /// Tells you if there are still matches available
+        /// </summary>
+        protected static bool MoreMatch { set; get; }
+        ///// <summary>
+        ///// Is true if an error has occurred
+        ///// </summary>
+        //public bool Error { private set; get; }
+        #endregion
+
+        #region Public Methodes
+        /// <summary>
+        /// Sets the text to be searched.
+        /// </summary>
+        /// <param name="searchText">A valid string.</param>
+        public void SetSearchText(string searchText)
+        {
+            SearchText = searchText;
+        }
+
+        /// <summary>
+        /// Get the text to be searched.
+        /// </summary>
+        /// <returns>Returns a string.</returns>
+        public string GetSearchText()
+        {
+            return SearchText;
+        }
+
+        /// <summary>
+        /// Sets the search string.
+        /// </summary>
+        /// <param name="searchString">A valid string.</param>
+        public void SetSearchString(string searchString)
+        {
+            SearchString = searchString;
+        }
+
+        /// <summary>
+        /// Get the search string.
+        /// </summary>
+        /// <returns>Returns a string.</returns>
+        public string GetSearchString()
+        {
+            return SearchString;
+        }
+
+        /// <summary>
+        /// Sets the Search string length.
+        /// </summary>
+        /// <param name="searchStringLength">A valid int value.</param>
+        public void SetSearchStringLength(int searchStringLength)
+        {
+            SearchStringLength = searchStringLength;
+        }
+
+        /// <summary>
+        /// Get the Search string length.
+        /// </summary>
+        /// <returns>Returns a int value.</returns>
+        public int GetSearchStringLength()
+        {
+            return SearchStringLength;
+        }
+
+        /// <summary>
+        /// Sets the position for a found value in the array
+        /// </summary>
+        /// <param name="index">A valid int value. Must be smaller / equal to the maximum number of elements.</param>
+        public void SetIndex(int index)
+        {
+            Index = index;
+        }
+
+        /// <summary>
+        /// Get the position for a found value in the array
+        /// </summary>
+        /// <returns>Returns a int value.</returns>
+        public int GetIndex()
+        {
+            return Index;
+        }
+
+        /// <summary>
+        /// Sets the current cursor position in the search text.
+        /// </summary>
+        /// <param name="currentCursorPosition">A valid int value.</param>
+        public void SetCurrentCursorPosition(int currentCursorPosition)
+        {
+            CurrentCursorPosition = currentCursorPosition;
+        }
+
+        /// <summary>
+        /// Get the current cursor position in the search text.
+        /// </summary>
+        /// <returns>Returns a int value.</returns>
+        public int GetCurrentCursorPosition()
+        {
+            return CurrentCursorPosition;
+        }
+
+        /// <summary>
+        /// Returns all positions where the search string was found in the search text.
+        /// </summary>
+        /// <returns>Returns a int list.</returns>
+        public List<int> GetAllPositions()
+        {
+            return AllPositions;
+        }
+
+        /// <summary>
+        /// Sets the substitute string.
+        /// </summary>
+        /// <param name="substituteString">A valid string.</param>
+        public void SetSubstituteString(string substituteString)
+        {
+            SubstituteString = substituteString;
+        }
+
+        /// <summary>
+        /// Get the substitute string.
+        /// </summary>
+        /// <returns>Returns a string.</returns>
+        public string GetSubstituteString()
+        {
+            return SubstituteString;
+        }
+
+        /// <summary>
+        /// Sets whether there is no further hit.
+        /// </summary>
+        /// <param name="moreMatch">Is true or false.</param>
+        public void SetMoreMatch(bool moreMatch)
+        {
+            MoreMatch = moreMatch;
+        }
+        #endregion
+
+        #region Privat Methodes
+        private void SetValues()
+        {
+            SearchText = search.GetSearchText();
+            SearchString = search.GetSearchString();
+            if (!String.IsNullOrEmpty(SearchString) && search.GetAllPositionsCount() > 0)
+            {
+                search.SetSearchStringLength(SearchString.Length);
+                SearchStringLength = search.GetSearchStringLength();
+            }
+            Index = search.GetIndex();
+        }
+
+        private void SetValuesNoMatch()
+        {
+            SearchText = "";
+            SearchString = "";
+            Index = 0;
+        }
+
+        private bool IsInputOK()
+        {
+            if (!String.IsNullOrEmpty(search.GetSearchString()) && !String.IsNullOrEmpty(SubstituteString))
+            {
+                if (SubstituteString != textBoxSubstituteString.Text)
+                {
+                    SubstituteString = textBoxSubstituteString.Text; //Wenn ein Wert in der Textbox steht, aber noch nicht Return/Enter gedrückt wurde
+                }
+
+                if (search.GetAllPositionsCount() > 0)
+                {
+                    return true; //Sind beide Werte vorhanden und gleich, dann ist Alles OK
+                }
+                else
+                {
+                    return false; //Wenn es keinen Suchstring mehr gibt
+                }
+            }
+            else
+            {
+                if (!String.IsNullOrEmpty(search.GetSearchString()) & !String.IsNullOrEmpty(textBoxSubstituteString.Text))
+                {
+                    SubstituteString = textBoxSubstituteString.Text; //Wenn ein Wert in der Textbox steht, aber noch nicht Return/Enter gedrückt wurde
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+        }
+
+        private void ReplaceStr()
+        {
+            if (MoreMatch)
+            {
+                SetValues();
+            }
+            else
+            {
+                SetValuesNoMatch();
+            }
+
+            if (IsInputOK())
+            {
+                try
+                {
+                    if (MoreMatch)
+                    {
+                        //Den Text nach dem Tausch wieder zurückschreiben
+                        search.SetSearchText(ReplaceString(search.GetSearchText(), search.GetSearchString(), SubstituteString, search.GetCurrentCursorPosition()));
+                        search.SearchAndFindString();
+                        OnEvent(search.GetCurrentCursorPosition(), search.GetSearchStringLength()); //Anzeige aktualisieren
+                    }
+                }
+                catch (IncompleteInputException)
+                {
+                    MessageBox.Show(AppResources.messagebox001text, AppResources.messagebox001caption, MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                }
+                catch (StringNotMatchException)
+                {
+                    search.ClearSearchString();
+                    OnEvent(0, 0); //Anzeige aktualisieren
+                    MoreMatch = false;
+                    MessageBox.Show(AppResources.messagebox002text, AppResources.messagebox002caption, MessageBoxButtons.OK, MessageBoxIcon.Information);
+                }
+            }
+            else
+            {
+                if (search.GetAllPositionsCount() == 0)
+                {
+                    throw new StringNotMatchException();
+                }
+                else
+                {
+                    throw new IncompleteInputException();
+                }
+            }
+        }
+
+        private string ReplaceString(string searchText, string searchString, string textBoxReplacementString, int currentCursorPosition)
+        {
+            return searchText.Remove(currentCursorPosition, searchString.Length).Insert(currentCursorPosition, textBoxReplacementString);
+        }
+
+        private void ReplaceAll()
+        {
+            List<int> newList = new List<int>();
+            newList = search.GetAllPositions();
+            newList.Reverse();
+
+            if (MoreMatch)
+            {
+                foreach (var item in newList)
+                {
+                    //Das Ersetzen von hinten nach vorne durchführen. So sind die vorab ermittelten Positionen immer richtig
+                    search.SetSearchText(ReplaceString(search.GetSearchText(), search.GetSearchString(), SubstituteString, item));
+                }
+                MoreMatch = false;
+            }
+            else
+            {
+                if (search.GetAllPositionsCount() == 0)
+                {
+                    throw new StringNotMatchException();
+                }
+                else
+                {
+                    throw new IncompleteInputException();
+                }
+            }
+            
+        }
+        #endregion
+
+        #region Event
+        // Der Delegat muß die gleiche Signatur aufweisen wie die Eventhandler-Methode.
+        public delegate void EventDelegate(int currentCursorPosition, int searchStringLenght);
+
+        // Das Event-Objekt ist vom Typ dieses Delegaten.
+        public event EventDelegate StringFound;
+
+        public void OnEvent(int currentCursorPosition, int searchStringLength)
+        {
+            // Prüft ob das Event überhaupt einen Abonnenten hat.
+            StringFound?.Invoke(currentCursorPosition, searchStringLength);
+        }
+        #endregion
+
+        Search search = new Search();
+
+        private void buttonReplace_Click(object sender, EventArgs e)
+        {
+            try
+            {
+                ReplaceStr();
+            }
+            catch (IncompleteInputException)
+            {
+                MessageBox.Show(AppResources.messagebox001text, AppResources.messagebox001caption, MessageBoxButtons.OK, MessageBoxIcon.Warning);
+            }
+            catch (StringNotMatchException)
+            {
+                search.ClearSearchString();
+                MessageBox.Show(AppResources.messagebox002text, AppResources.messagebox002caption, MessageBoxButtons.OK, MessageBoxIcon.Information);
+            }
+        }
+
+        private void buttonReplaceAll_Click(object sender, EventArgs e)
+        {
+            try
+            {
+                if (MoreMatch)
+                {
+                    if (IsInputOK())
+                    {
+                        ReplaceAll();
+                        OnEvent(0, 0); //Anzeige aktualisieren
+                    }
+                    else
+                    {
+                        if (search.GetAllPositionsCount() == 0)
+                        {
+                            throw new StringNotMatchException();
+                        }
+                        else
+                        {
+                            throw new IncompleteInputException();
+                        }
+                    }
+                }
+                else
+                {
+                    throw new StringNotMatchException();
+                }
+            }
+            catch (IncompleteInputException)
+            {
+                MessageBox.Show(AppResources.messagebox001text, AppResources.messagebox001caption, MessageBoxButtons.OK, MessageBoxIcon.Warning);
+            }
+            catch (StringNotMatchException)
+            {
+                search.ClearSearchString();
+                MessageBox.Show(AppResources.messagebox002text, AppResources.messagebox002caption, MessageBoxButtons.OK, MessageBoxIcon.Information);
+            }
+        }
+
+        private void textBoxSubstituteString_KeyDown(object sender, KeyEventArgs e)
+        {
+            if (e.KeyCode == Keys.Enter)
+            {
+                if (!String.IsNullOrEmpty(search.GetSearchString()))
+                {
+                    MoreMatch = true;
+                    SetValues();
+
+                    try
+                    {
+                        SubstituteString = textBoxSubstituteString.Text;
+                        search.SearchAndFindString();
+                        OnEvent(search.GetCurrentCursorPosition(), search.GetSearchStringLength()); //Anzeige aktualisieren
+                    }
+                    catch (StringNotMatchException)
+                    {
+                        MessageBox.Show(AppResources.messagebox002text, AppResources.messagebox002caption, MessageBoxButtons.OK, MessageBoxIcon.Information);
+                    }
+                }
+            }
+        }
+
+        private void textBoxSubstituteString_Click(object sender, EventArgs e)
+        {
+            SetValues();
+            OnEvent(CurrentCursorPosition, SearchStringLength);
+            textBoxSubstituteString.Focus();
+        }
+    }
+}

ReplaceString/Replace.de.resx

@@ -0,0 +1,136 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="buttonReplaceAll.Text" xml:space="preserve">
+    <value>Alle ersetzen</value>
+  </data>
+  <data name="buttonReplace.Text" xml:space="preserve">
+    <value>Ersetzen</value>
+  </data>
+  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+  <data name="labelSubstituteString.Size" type="System.Drawing.Size, System.Drawing">
+    <value>78, 13</value>
+  </data>
+  <data name="labelSubstituteString.Text" xml:space="preserve">
+    <value>Ersetzen durch</value>
+  </data>
+  <data name="groupBoxReplace.Text" xml:space="preserve">
+    <value>Ersetzen</value>
+  </data>
+</root>

ReplaceString/Replace.en.resx

@@ -0,0 +1,136 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="buttonReplaceAll.Text" xml:space="preserve">
+    <value>Replace all</value>
+  </data>
+  <data name="buttonReplace.Text" xml:space="preserve">
+    <value>Replace</value>
+  </data>
+  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+  <data name="labelSubstituteString.Size" type="System.Drawing.Size, System.Drawing">
+    <value>69, 13</value>
+  </data>
+  <data name="labelSubstituteString.Text" xml:space="preserve">
+    <value>Replace with</value>
+  </data>
+  <data name="groupBoxReplace.Text" xml:space="preserve">
+    <value>Replace</value>
+  </data>
+</root>

ReplaceString/Replace.resx

@@ -0,0 +1,276 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="groupBoxReplace.Anchor" type="System.Windows.Forms.AnchorStyles, System.Windows.Forms">
+    <value>Top, Bottom, Left, Right</value>
+  </data>
+  <data name="buttonReplaceAll.Anchor" type="System.Windows.Forms.AnchorStyles, System.Windows.Forms">
+    <value>Bottom, Right</value>
+  </data>
+  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+  <data name="buttonReplaceAll.Location" type="System.Drawing.Point, System.Drawing">
+    <value>284, 39</value>
+  </data>
+  <data name="buttonReplaceAll.Size" type="System.Drawing.Size, System.Drawing">
+    <value>100, 23</value>
+  </data>
+  <assembly alias="mscorlib" name="mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="buttonReplaceAll.TabIndex" type="System.Int32, mscorlib">
+    <value>7</value>
+  </data>
+  <data name="buttonReplaceAll.Text" xml:space="preserve">
+    <value>Alle ersetzen</value>
+  </data>
+  <data name="&gt;&gt;buttonReplaceAll.Name" xml:space="preserve">
+    <value>buttonReplaceAll</value>
+  </data>
+  <data name="&gt;&gt;buttonReplaceAll.Type" xml:space="preserve">
+    <value>System.Windows.Forms.Button, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;buttonReplaceAll.Parent" xml:space="preserve">
+    <value>groupBoxReplace</value>
+  </data>
+  <data name="&gt;&gt;buttonReplaceAll.ZOrder" xml:space="preserve">
+    <value>0</value>
+  </data>
+  <data name="buttonReplace.Anchor" type="System.Windows.Forms.AnchorStyles, System.Windows.Forms">
+    <value>Bottom, Left</value>
+  </data>
+  <data name="buttonReplace.Location" type="System.Drawing.Point, System.Drawing">
+    <value>6, 39</value>
+  </data>
+  <data name="buttonReplace.Size" type="System.Drawing.Size, System.Drawing">
+    <value>100, 23</value>
+  </data>
+  <data name="buttonReplace.TabIndex" type="System.Int32, mscorlib">
+    <value>6</value>
+  </data>
+  <data name="buttonReplace.Text" xml:space="preserve">
+    <value>Ersetzen</value>
+  </data>
+  <data name="&gt;&gt;buttonReplace.Name" xml:space="preserve">
+    <value>buttonReplace</value>
+  </data>
+  <data name="&gt;&gt;buttonReplace.Type" xml:space="preserve">
+    <value>System.Windows.Forms.Button, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;buttonReplace.Parent" xml:space="preserve">
+    <value>groupBoxReplace</value>
+  </data>
+  <data name="&gt;&gt;buttonReplace.ZOrder" xml:space="preserve">
+    <value>1</value>
+  </data>
+  <data name="textBoxSubstituteString.Anchor" type="System.Windows.Forms.AnchorStyles, System.Windows.Forms">
+    <value>Top, Left, Right</value>
+  </data>
+  <data name="textBoxSubstituteString.Location" type="System.Drawing.Point, System.Drawing">
+    <value>89, 13</value>
+  </data>
+  <data name="textBoxSubstituteString.Size" type="System.Drawing.Size, System.Drawing">
+    <value>295, 20</value>
+  </data>
+  <data name="textBoxSubstituteString.TabIndex" type="System.Int32, mscorlib">
+    <value>3</value>
+  </data>
+  <data name="&gt;&gt;textBoxSubstituteString.Name" xml:space="preserve">
+    <value>textBoxSubstituteString</value>
+  </data>
+  <data name="&gt;&gt;textBoxSubstituteString.Type" xml:space="preserve">
+    <value>System.Windows.Forms.TextBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;textBoxSubstituteString.Parent" xml:space="preserve">
+    <value>groupBoxReplace</value>
+  </data>
+  <data name="&gt;&gt;textBoxSubstituteString.ZOrder" xml:space="preserve">
+    <value>2</value>
+  </data>
+  <data name="labelSubstituteString.AutoSize" type="System.Boolean, mscorlib">
+    <value>True</value>
+  </data>
+  <data name="labelSubstituteString.Location" type="System.Drawing.Point, System.Drawing">
+    <value>3, 16</value>
+  </data>
+  <data name="labelSubstituteString.Size" type="System.Drawing.Size, System.Drawing">
+    <value>78, 13</value>
+  </data>
+  <data name="labelSubstituteString.TabIndex" type="System.Int32, mscorlib">
+    <value>2</value>
+  </data>
+  <data name="labelSubstituteString.Text" xml:space="preserve">
+    <value>Ersetzen durch</value>
+  </data>
+  <data name="&gt;&gt;labelSubstituteString.Name" xml:space="preserve">
+    <value>labelSubstituteString</value>
+  </data>
+  <data name="&gt;&gt;labelSubstituteString.Type" xml:space="preserve">
+    <value>System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;labelSubstituteString.Parent" xml:space="preserve">
+    <value>groupBoxReplace</value>
+  </data>
+  <data name="&gt;&gt;labelSubstituteString.ZOrder" xml:space="preserve">
+    <value>3</value>
+  </data>
+  <data name="groupBoxReplace.Location" type="System.Drawing.Point, System.Drawing">
+    <value>0, 0</value>
+  </data>
+  <data name="groupBoxReplace.MinimumSize" type="System.Drawing.Size, System.Drawing">
+    <value>250, 68</value>
+  </data>
+  <data name="groupBoxReplace.Size" type="System.Drawing.Size, System.Drawing">
+    <value>390, 68</value>
+  </data>
+  <data name="groupBoxReplace.TabIndex" type="System.Int32, mscorlib">
+    <value>0</value>
+  </data>
+  <data name="groupBoxReplace.Text" xml:space="preserve">
+    <value>Ersetzen</value>
+  </data>
+  <data name="&gt;&gt;groupBoxReplace.Name" xml:space="preserve">
+    <value>groupBoxReplace</value>
+  </data>
+  <data name="&gt;&gt;groupBoxReplace.Type" xml:space="preserve">
+    <value>System.Windows.Forms.GroupBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;groupBoxReplace.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;groupBoxReplace.ZOrder" xml:space="preserve">
+    <value>0</value>
+  </data>
+  <metadata name="$this.Localizable" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
+    <value>True</value>
+  </metadata>
+  <data name="$this.AutoScaleDimensions" type="System.Drawing.SizeF, System.Drawing">
+    <value>6, 13</value>
+  </data>
+  <data name="$this.MinimumSize" type="System.Drawing.Size, System.Drawing">
+    <value>250, 68</value>
+  </data>
+  <data name="$this.Size" type="System.Drawing.Size, System.Drawing">
+    <value>390, 68</value>
+  </data>
+  <data name="&gt;&gt;$this.Name" xml:space="preserve">
+    <value>Replace</value>
+  </data>
+  <data name="&gt;&gt;$this.Type" xml:space="preserve">
+    <value>System.Windows.Forms.UserControl, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+</root>

ReplaceString/ReplaceString.csproj

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{B402B197-7EBA-4994-9FCD-A658B23648B0}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <RootNamespace>ReplaceString</RootNamespace>
+    <AssemblyName>ReplaceString</AssemblyName>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <Deterministic>false</Deterministic>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AppResources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>AppResources.resx</DependentUpon>
+    </Compile>
+    <Compile Include="Replace.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="Replace.Designer.cs">
+      <DependentUpon>Replace.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Service Include="{94E38DFF-614B-4cbd-B67C-F211BB35CE8B}" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="AppResources.de.resx">
+      <CustomToolNamespace>Eugen.ESystem.Windows.Forms</CustomToolNamespace>
+    </EmbeddedResource>
+    <EmbeddedResource Include="AppResources.en.resx">
+      <CustomToolNamespace>Eugen.ESystem.Windows.Forms</CustomToolNamespace>
+    </EmbeddedResource>
+    <EmbeddedResource Include="AppResources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>AppResources.Designer.cs</LastGenOutput>
+      <CustomToolNamespace>Eugen.ESystem.Windows.Forms</CustomToolNamespace>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Replace.de.resx">
+      <DependentUpon>Replace.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Replace.en.resx">
+      <DependentUpon>Replace.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Replace.resx">
+      <DependentUpon>Replace.cs</DependentUpon>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\SearchString\SearchString.csproj">
+      <Project>{91ec8467-e4fc-44c7-8092-c3ae6ae75009}</Project>
+      <Name>SearchString</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

ReplaceString/obj/Debug/.NETFramework,Version=v4.7.2.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]

ReplaceString/obj/Debug/ReplaceString.csproj.CoreCompileInputs.cache

@@ -0,0 +1 @@
+eed273b743287bcf1e0ed75602d38eb39b8549b9

ReplaceString/obj/Debug/ReplaceString.csproj.FileListAbsolute.txt

@@ -0,0 +1,55 @@
+H:\Programmieren\Git-Repository\VisualStudio\2017\_PROJEKTE\SearchFindReplace.git\ReplaceString\bin\Debug\ReplaceString.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_PROJEKTE\SearchFindReplace.git\ReplaceString\bin\Debug\ReplaceString.pdb
+H:\Programmieren\Git-Repository\VisualStudio\2017\_PROJEKTE\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.csproj.GenerateResource.cache
+H:\Programmieren\Git-Repository\VisualStudio\2017\_PROJEKTE\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.csproj.CoreCompileInputs.cache
+H:\Programmieren\Git-Repository\VisualStudio\2017\_PROJEKTE\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_PROJEKTE\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.pdb
+H:\Programmieren\Git-Repository\VisualStudio\2017\_PROJEKTE\SearchFindReplace.git\ReplaceString\obj\Debug\Eugen.ESystem.Windows.Forms.Replace.resources
+H:\Programmieren\Git-Repository\VisualStudio\2017\_PROJEKTE\SearchFindReplace.git\ReplaceString\bin\Debug\SearchString.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_PROJEKTE\SearchFindReplace.git\ReplaceString\bin\Debug\SearchString.pdb
+H:\Programmieren\Git-Repository\VisualStudio\2017\_PROJEKTE\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.csprojAssemblyReference.cache
+H:\Programmieren\Git-Repository\VisualStudio\2017\_PROJEKTE\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.csproj.CopyComplete
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\bin\Debug\ReplaceString.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\bin\Debug\ReplaceString.pdb
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\bin\Debug\SearchString.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\bin\Debug\SearchString.pdb
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.csprojAssemblyReference.cache
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\Eugen.ESystem.Windows.Forms.Replace.resources
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.csproj.GenerateResource.cache
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.csproj.CoreCompileInputs.cache
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.csproj.CopyComplete
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.pdb
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\bin\Debug\de\ReplaceString.resources.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\bin\Debug\en\ReplaceString.resources.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\bin\Debug\de\SearchString.resources.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\bin\Debug\en\SearchString.resources.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\Eugen.ESystem.Windows.Forms.Replace.de.resources
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\Eugen.ESystem.Windows.Forms.Replace.en.resources
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\de\ReplaceString.resources.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\en\ReplaceString.resources.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\bin\Debug\ReplaceString.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\bin\Debug\ReplaceString.pdb
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\bin\Debug\de\ReplaceString.resources.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\bin\Debug\en\ReplaceString.resources.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\bin\Debug\SearchString.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\bin\Debug\SearchString.pdb
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\bin\Debug\de\SearchString.resources.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\bin\Debug\en\SearchString.resources.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\ReplaceString.csprojAssemblyReference.cache
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\Eugen.ESystem.Windows.Forms.Replace.resources
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\Eugen.ESystem.Windows.Forms.Replace.de.resources
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\Eugen.ESystem.Windows.Forms.Replace.en.resources
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\ReplaceString.csproj.GenerateResource.cache
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\ReplaceString.csproj.CoreCompileInputs.cache
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\de\ReplaceString.resources.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\en\ReplaceString.resources.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\ReplaceString.csproj.CopyComplete
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\ReplaceString.dll
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\ReplaceString.pdb
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\ReplaceString.AppResources.resources
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\ReplaceString.AppResources.de.resources
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplaceV2.git\ReplaceString\obj\Debug\ReplaceString.AppResources.en.resources
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.AppResources.resources
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.AppResources.de.resources
+H:\Programmieren\Git-Repository\VisualStudio\2017\_USER CONTROL\SearchFindReplace.git\ReplaceString\obj\Debug\ReplaceString.AppResources.en.resources

ReplaceString/obj/Release/.NETFramework,Version=v4.7.2.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]

SearchFindReplace.sln

@@ -0,0 +1,43 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30611.23
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SearchFindReplace", "SearchFindReplace\SearchFindReplace.csproj", "{50068E99-23B8-46A2-B2D0-02E60C17CF3C}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SearchString", "SearchString\SearchString.csproj", "{91EC8467-E4FC-44C7-8092-C3AE6AE75009}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ReplaceString", "ReplaceString\ReplaceString.csproj", "{B402B197-7EBA-4994-9FCD-A658B23648B0}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FormLanguageSwitch", "FormLanguageSwitch\FormLanguageSwitch.csproj", "{787B600C-9A56-41C7-A3C8-9553630FE3C1}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{50068E99-23B8-46A2-B2D0-02E60C17CF3C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{50068E99-23B8-46A2-B2D0-02E60C17CF3C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{50068E99-23B8-46A2-B2D0-02E60C17CF3C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{50068E99-23B8-46A2-B2D0-02E60C17CF3C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{91EC8467-E4FC-44C7-8092-C3AE6AE75009}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{91EC8467-E4FC-44C7-8092-C3AE6AE75009}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{91EC8467-E4FC-44C7-8092-C3AE6AE75009}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{91EC8467-E4FC-44C7-8092-C3AE6AE75009}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B402B197-7EBA-4994-9FCD-A658B23648B0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B402B197-7EBA-4994-9FCD-A658B23648B0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B402B197-7EBA-4994-9FCD-A658B23648B0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B402B197-7EBA-4994-9FCD-A658B23648B0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{787B600C-9A56-41C7-A3C8-9553630FE3C1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{787B600C-9A56-41C7-A3C8-9553630FE3C1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{787B600C-9A56-41C7-A3C8-9553630FE3C1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{787B600C-9A56-41C7-A3C8-9553630FE3C1}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {EBB35311-07CA-437D-973F-33D6DFBBF950}
+	EndGlobalSection
+EndGlobal

SearchFindReplace/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
+    </startup>
+</configuration>

SearchFindReplace/AppResources.Designer.cs

@@ -0,0 +1,81 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     Dieser Code wurde von einem Tool generiert.
+//     Laufzeitversion:4.0.30319.42000
+//
+//     Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn
+//     der Code erneut generiert wird.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace SearchFindReplace {
+    using System;
+    
+    
+    /// <summary>
+    ///   Eine stark typisierte Ressourcenklasse zum Suchen von lokalisierten Zeichenfolgen usw.
+    /// </summary>
+    // Diese Klasse wurde von der StronglyTypedResourceBuilder automatisch generiert
+    // -Klasse über ein Tool wie ResGen oder Visual Studio automatisch generiert.
+    // Um einen Member hinzuzufügen oder zu entfernen, bearbeiten Sie die .ResX-Datei und führen dann ResGen
+    // mit der /str-Option erneut aus, oder Sie erstellen Ihr VS-Projekt neu.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class AppResources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal AppResources() {
+        }
+        
+        /// <summary>
+        ///   Gibt die zwischengespeicherte ResourceManager-Instanz zurück, die von dieser Klasse verwendet wird.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("SearchFindReplace.AppResources", typeof(AppResources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Überschreibt die CurrentUICulture-Eigenschaft des aktuellen Threads für alle
+        ///   Ressourcenzuordnungen, die diese stark typisierte Ressourcenklasse verwenden.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Information ähnelt.
+        /// </summary>
+        internal static string mbt000caption {
+            get {
+                return ResourceManager.GetString("mbt000caption", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Das ist ein Sprach Test. ähnelt.
+        /// </summary>
+        internal static string mbt000text {
+            get {
+                return ResourceManager.GetString("mbt000text", resourceCulture);
+            }
+        }
+    }
+}

SearchFindReplace/AppResources.de.resx

@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="mbt000caption" xml:space="preserve">
+    <value>Information</value>
+  </data>
+  <data name="mbt000text" xml:space="preserve">
+    <value>Das ist ein Sprach Test.</value>
+  </data>
+</root>

SearchFindReplace/AppResources.en.resx

@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="mbt000caption" xml:space="preserve">
+    <value>Information</value>
+  </data>
+  <data name="mbt000text" xml:space="preserve">
+    <value>This is a language test.</value>
+  </data>
+</root>

SearchFindReplace/AppResources.resx

@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="mbt000caption" xml:space="preserve">
+    <value>Information</value>
+  </data>
+  <data name="mbt000text" xml:space="preserve">
+    <value>Das ist ein Sprach Test.</value>
+  </data>
+</root>

SearchFindReplace/Form1.Designer.cs

@@ -0,0 +1,179 @@
+namespace SearchFindReplace
+{
+    partial class Form1
+    {
+        /// <summary>
+        /// Erforderliche Designervariable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Verwendete Ressourcen bereinigen.
+        /// </summary>
+        /// <param name="disposing">True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Vom Windows Form-Designer generierter Code
+
+        /// <summary>
+        /// Erforderliche Methode für die Designerunterstützung.
+        /// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Form1));
+            this.textBoxText = new System.Windows.Forms.TextBox();
+            this.groupBox1 = new System.Windows.Forms.GroupBox();
+            this.radioButtonEnglish = new System.Windows.Forms.RadioButton();
+            this.radioButtonGerman = new System.Windows.Forms.RadioButton();
+            this.menuStrip = new System.Windows.Forms.MenuStrip();
+            this.spracheToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
+            this.deutschToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
+            this.englischToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
+            this.labelDllInfo = new System.Windows.Forms.Label();
+            this.groupBoxDll = new System.Windows.Forms.GroupBox();
+            this.buttonCheckLanguage = new System.Windows.Forms.Button();
+            this.replace1 = new Eugen.ESystem.Windows.Forms.Replace();
+            this.search1 = new Eugen.ESystem.Windows.Forms.Search();
+            this.groupBox1.SuspendLayout();
+            this.menuStrip.SuspendLayout();
+            this.groupBoxDll.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // textBoxText
+            // 
+            resources.ApplyResources(this.textBoxText, "textBoxText");
+            this.textBoxText.Name = "textBoxText";
+            // 
+            // groupBox1
+            // 
+            this.groupBox1.Controls.Add(this.radioButtonEnglish);
+            this.groupBox1.Controls.Add(this.radioButtonGerman);
+            resources.ApplyResources(this.groupBox1, "groupBox1");
+            this.groupBox1.Name = "groupBox1";
+            this.groupBox1.TabStop = false;
+            // 
+            // radioButtonEnglish
+            // 
+            resources.ApplyResources(this.radioButtonEnglish, "radioButtonEnglish");
+            this.radioButtonEnglish.Name = "radioButtonEnglish";
+            this.radioButtonEnglish.UseVisualStyleBackColor = true;
+            this.radioButtonEnglish.CheckedChanged += new System.EventHandler(this.radioButtonEnglish_CheckedChanged);
+            // 
+            // radioButtonGerman
+            // 
+            resources.ApplyResources(this.radioButtonGerman, "radioButtonGerman");
+            this.radioButtonGerman.Checked = true;
+            this.radioButtonGerman.Name = "radioButtonGerman";
+            this.radioButtonGerman.TabStop = true;
+            this.radioButtonGerman.UseVisualStyleBackColor = true;
+            this.radioButtonGerman.CheckedChanged += new System.EventHandler(this.radioButtonGerman_CheckedChanged);
+            // 
+            // menuStrip
+            // 
+            this.menuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
+            this.spracheToolStripMenuItem});
+            resources.ApplyResources(this.menuStrip, "menuStrip");
+            this.menuStrip.Name = "menuStrip";
+            // 
+            // spracheToolStripMenuItem
+            // 
+            this.spracheToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
+            this.deutschToolStripMenuItem,
+            this.englischToolStripMenuItem});
+            this.spracheToolStripMenuItem.Name = "spracheToolStripMenuItem";
+            resources.ApplyResources(this.spracheToolStripMenuItem, "spracheToolStripMenuItem");
+            // 
+            // deutschToolStripMenuItem
+            // 
+            this.deutschToolStripMenuItem.Checked = true;
+            this.deutschToolStripMenuItem.CheckState = System.Windows.Forms.CheckState.Checked;
+            this.deutschToolStripMenuItem.Name = "deutschToolStripMenuItem";
+            resources.ApplyResources(this.deutschToolStripMenuItem, "deutschToolStripMenuItem");
+            this.deutschToolStripMenuItem.Click += new System.EventHandler(this.deutschToolStripMenuItem1_Click);
+            // 
+            // englischToolStripMenuItem
+            // 
+            this.englischToolStripMenuItem.Name = "englischToolStripMenuItem";
+            resources.ApplyResources(this.englischToolStripMenuItem, "englischToolStripMenuItem");
+            this.englischToolStripMenuItem.Click += new System.EventHandler(this.englischToolStripMenuItem_Click);
+            // 
+            // labelDllInfo
+            // 
+            resources.ApplyResources(this.labelDllInfo, "labelDllInfo");
+            this.labelDllInfo.Name = "labelDllInfo";
+            // 
+            // groupBoxDll
+            // 
+            this.groupBoxDll.Controls.Add(this.labelDllInfo);
+            resources.ApplyResources(this.groupBoxDll, "groupBoxDll");
+            this.groupBoxDll.Name = "groupBoxDll";
+            this.groupBoxDll.TabStop = false;
+            // 
+            // buttonCheckLanguage
+            // 
+            resources.ApplyResources(this.buttonCheckLanguage, "buttonCheckLanguage");
+            this.buttonCheckLanguage.Name = "buttonCheckLanguage";
+            this.buttonCheckLanguage.UseVisualStyleBackColor = true;
+            this.buttonCheckLanguage.Click += new System.EventHandler(this.buttonCheckLanguage_Click);
+            // 
+            // replace1
+            // 
+            resources.ApplyResources(this.replace1, "replace1");
+            this.replace1.Name = "replace1";
+            // 
+            // search1
+            // 
+            resources.ApplyResources(this.search1, "search1");
+            this.search1.Name = "search1";
+            // 
+            // Form1
+            // 
+            resources.ApplyResources(this, "$this");
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.Controls.Add(this.buttonCheckLanguage);
+            this.Controls.Add(this.groupBoxDll);
+            this.Controls.Add(this.groupBox1);
+            this.Controls.Add(this.replace1);
+            this.Controls.Add(this.search1);
+            this.Controls.Add(this.textBoxText);
+            this.Controls.Add(this.menuStrip);
+            this.MainMenuStrip = this.menuStrip;
+            this.Name = "Form1";
+            this.Load += new System.EventHandler(this.Form1_Load);
+            this.groupBox1.ResumeLayout(false);
+            this.groupBox1.PerformLayout();
+            this.menuStrip.ResumeLayout(false);
+            this.menuStrip.PerformLayout();
+            this.groupBoxDll.ResumeLayout(false);
+            this.groupBoxDll.PerformLayout();
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.TextBox textBoxText;
+        private Eugen.ESystem.Windows.Forms.Search search1;
+        private Eugen.ESystem.Windows.Forms.Replace replace1;
+        private System.Windows.Forms.GroupBox groupBox1;
+        private System.Windows.Forms.RadioButton radioButtonEnglish;
+        private System.Windows.Forms.RadioButton radioButtonGerman;
+        private System.Windows.Forms.MenuStrip menuStrip;
+        private System.Windows.Forms.ToolStripMenuItem spracheToolStripMenuItem;
+        private System.Windows.Forms.ToolStripMenuItem deutschToolStripMenuItem;
+        private System.Windows.Forms.ToolStripMenuItem englischToolStripMenuItem;
+        private System.Windows.Forms.Label labelDllInfo;
+        private System.Windows.Forms.GroupBox groupBoxDll;
+        private System.Windows.Forms.Button buttonCheckLanguage;
+    }
+}
+

SearchFindReplace/Form1.cs

@@ -0,0 +1,286 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+using Eugen.ESystem.Windows.Forms;
+
+namespace SearchFindReplace
+{
+    public partial class Form1 : Form
+    {
+        #region Version und Copyright
+        // Version und Copyright
+        string programName = Path.GetFileNameWithoutExtension(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase); //Den Programmnamen auslesen
+        string programVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
+        static object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false);
+        string copyright = GenerateCopyright();
+        string icon = Application.StartupPath + "\\Info.bmp";
+        //Assembly Datum und Zeit
+        static DateTime value = AssemblyDateTime();
+        string date = value.ToShortDateString();
+        string time = value.ToLongTimeString();
+        private static DateTime AssemblyDateTime()
+        {
+            var version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
+            var buildDateTime = new DateTime(2000, 1, 1).Add(new TimeSpan(TimeSpan.TicksPerDay * version.Build + TimeSpan.TicksPerSecond * 2 * version.Revision));
+            //Tage seit dem 1. Januar 2000 und Sekunden seit Mitternacht, (multiplizier mit 2 ergibt das Original)
+            return buildDateTime;
+        }
+
+        private static string CurrentYear()
+        {
+            DateTime dtn = DateTime.Now;
+            return dtn.Year.ToString();
+        }
+
+        private static string StartYear()
+        {
+            //string startYear = ((AssemblyCopyrightAttribute)attributes[0]).Copyright;
+            //return startYear.Remove(0, startYear.LastIndexOf(" ") + 1);
+            string startYear = "";
+            if (((AssemblyCopyrightAttribute)attributes[0]).Copyright.Contains("Copyright © "))
+            {
+                startYear = ((AssemblyCopyrightAttribute)attributes[0]).Copyright.Replace("Copyright © ", "");
+                while (startYear.StartsWith(" "))
+                {
+                    startYear = startYear.Remove(0, 1);
+                }
+                startYear = startYear.Remove(startYear.IndexOf(" "));
+                return startYear;
+            }
+            else
+            {
+                DateTime dtn = DateTime.Now;
+                return dtn.Year.ToString();
+            }
+        }
+
+        private static string GenerateCopyright()
+        {
+            string startYear = StartYear();
+            string currentYear = CurrentYear();
+
+            if (startYear == currentYear)
+            {
+                return ((AssemblyCopyrightAttribute)attributes[0]).Copyright;
+            }
+            else
+            {
+                //return String.Concat(((AssemblyCopyrightAttribute)attributes[0]).Copyright, "-", currentYear);
+                return ((AssemblyCopyrightAttribute)attributes[0]).Copyright.Replace(startYear, String.Concat(startYear, "-", currentYear));
+            }
+        }
+        #endregion
+
+        #region Programm-Info
+        /// <summary>
+        /// Contains the name of the program file
+        /// </summary>
+        public static string ProgramName { set; get; }
+
+        /// <summary>
+        /// Contains the version of the program file
+        /// </summary>
+        public static string ProgramVersion { set; get; }
+
+        /// <summary>
+        /// Contains the copyright notice
+        /// </summary>
+        public static string Copyright { set; get; }
+
+        private void SetProgramInfo()
+        {
+            //Name, Version und Copyright setzen
+            ProgramName = programName;
+            ProgramVersion = programVersion;
+            Copyright = copyright;
+        }
+        #endregion
+
+        public Form1()
+        {
+            SetProgramInfo(); //Name, Version und Copyright setzen
+			
+            InitializeComponent();
+
+            //Systemsprache auslesen und Programmsprache setzen oder ...
+            if (Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName == "de")
+            {
+                SetLanguage("Deutsch", CultureInfo.GetCultureInfo("de"));
+            }
+            else
+            {
+                SetLanguage("English", CultureInfo.GetCultureInfo("en"));
+            }
+
+            //... oder Programmsprache definitiv auf "Deutsch" setzen
+            SetLanguage("Deutsch", CultureInfo.GetCultureInfo("de"));
+
+            //Dll-Informationen laden
+            LoadDllInfo();
+        }
+
+        private void SetLanguage(string language, CultureInfo languageShortForm)
+        {
+            CultureInfoDisplayItem cidi = (CultureInfoDisplayItem)new CultureInfoDisplayItem(language, languageShortForm);
+            FormLanguageSwitchSingleton.Instance.ChangeLanguage(this, cidi.CultureInfo);
+            Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(languageShortForm.ToString());
+            ChangeLanguage(languageShortForm.ToString());
+        }
+
+        private void ChangeLanguage(string lang)
+        {
+            Thread.CurrentThread.CurrentUICulture = new
+                System.Globalization.CultureInfo(lang);
+            ComponentResourceManager resources = new ComponentResourceManager(typeof(Form1));
+            resources.ApplyResources(this, "$this");
+            ApplyResources(resources, this.Controls);
+        }
+
+        private void ApplyResources(ComponentResourceManager resources, Control.ControlCollection ctls)
+        {
+            //all controls
+            foreach (Control ctl in ctls)
+            {
+                resources.ApplyResources(ctl, ctl.Name);
+                ApplyResources(resources, ctl.Controls);
+            }
+
+            //the menu bar and its items
+            foreach (ToolStripItem item in menuStrip.Items)
+            {
+                if (item is ToolStripDropDownItem)
+                {
+                    resources.ApplyResources(item, item.Name);
+                    foreach (ToolStripItem dropDownItem in ((ToolStripDropDownItem)item).DropDownItems)
+                    {
+                        resources.ApplyResources(dropDownItem, dropDownItem.Name);
+                    }
+                }
+            }
+        }
+
+        private void MarkCurrentLanguage()
+        {
+            deutschToolStripMenuItem.Checked = !deutschToolStripMenuItem.Checked;
+            englischToolStripMenuItem.Checked = !englischToolStripMenuItem.Checked;
+            if (radioButtonGerman.Checked)
+            {
+                radioButtonEnglish.Checked = true;
+            }
+            else
+            {
+                radioButtonGerman.Checked = true;
+            }
+        }
+
+        private void LoadDllInfo()
+        {
+            string dllInfo = "";
+            dllInfo = String.Concat(FormLanguageSwitchSingleton.DllName, ": ", FormLanguageSwitchSingleton.DllVersion, "\n\r", FormLanguageSwitchSingleton.Copyright, "\n\r");
+            dllInfo = String.Concat(dllInfo, Search.DllName, ": ", Search.DllVersion, "\n\r", Search.Copyright, "\n\r");
+            dllInfo = String.Concat(dllInfo, Replace.DllName, ": ", Replace.DllVersion, "\n\r", Replace.Copyright);
+            labelDllInfo.Text = dllInfo;
+            labelDllInfo.Refresh();
+        }
+
+        private void buttonCheckLanguage_Click(object sender, EventArgs e)
+        {
+            MessageBox.Show(String.Concat(Resources.mbt000text, Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName), Resources.mbt000caption, MessageBoxButtons.OK, MessageBoxIcon.Information);
+        }
+
+        private void radioButtonGerman_CheckedChanged(object sender, EventArgs e)
+        {
+            SetLanguage("Deutsch", CultureInfo.GetCultureInfo("de"));
+
+            LoadDllInfo();
+        }
+
+        private void radioButtonEnglish_CheckedChanged(object sender, EventArgs e)
+        {
+            SetLanguage("Englisch", CultureInfo.GetCultureInfo("en"));
+
+            LoadDllInfo();
+        }
+
+        private void deutschToolStripMenuItem1_Click(object sender, EventArgs e)
+        {
+            SetLanguage("Deutsch", CultureInfo.GetCultureInfo("de"));
+            MarkCurrentLanguage();
+
+            LoadDllInfo();
+        }
+
+        private void englischToolStripMenuItem_Click(object sender, EventArgs e)
+        {
+            SetLanguage("Englisch", CultureInfo.GetCultureInfo("en"));
+            MarkCurrentLanguage();
+
+            LoadDllInfo();
+        }
+
+
+        //--------------------------------------------------------------
+        //--- Diesen Bereich ins eigene Programm einfügen --- Anfang ---
+        //--------------------------------------------------------------
+        // Die Zeile "using Eugen.ESystem.Windows.Forms;" einfügen
+        // Die Verweise "SearchString" und "ReplaceString" einfügen
+        //--------------------------------------------------------------
+        private void Form1_Load(object sender, EventArgs e)
+        {
+            try
+            {
+                search1.SetSearchText(textBoxText.Text); //Text aus der Textbox übergeben
+                search1.RefreshDisplay += new Search.RefreshDelegate(RefreshDisplay); //Hier wird das Event abonniert
+                search1.InputChanged += new Search.InputChangedDelegate(InputChanged); //Hier wird das Event abonniert
+
+                replace1.SetSearchText(textBoxText.Text); //Text aus der Textbox übergeben
+                replace1.StringFound += new Replace.EventDelegate(RefreshDisplay); //Hier wird das Event abonniert
+            }
+            catch (IncompleteInputException)
+            {
+                MessageBox.Show("Eingabe unvollständig!");
+            }
+            catch (StringNotMatchException)
+            {
+                MessageBox.Show("Keine (weitere) Übereinstimmung gefunden!");
+            }
+        }
+
+        //Zeichnet die TextBox neu
+        void RefreshDisplay(int currentCursorPosition, int searchStringLenght)
+        {
+            RefreshTextBox(currentCursorPosition, searchStringLenght); //Ansicht aktualisieren
+        }
+
+        //Trifft zu wenn sich die Eingabe geändert hat
+        void InputChanged()
+        {
+            replace1.SetMoreMatch(true); //Gibt der Replace Funktion bekannt, dass es weitere Treffer gibt
+        }
+
+        private void RefreshTextBox(int currentCursorPosition, int searchStringLenght)
+        {
+            //Ansicht aktualisieren
+            textBoxText.Text = search1.GetSearchText(); //Aktuellen Text zuweisen
+            textBoxText.Focus(); //Focus auf die Textbox
+            textBoxText.Select(currentCursorPosition, searchStringLenght); //Suchstring in der Textbox selektieren
+            textBoxText.Refresh();
+        }
+
+        //--------------------------------------------------------------
+        //--- Diesen Bereich ins eigene Programm einfügen ---  Ende  ---
+        //--------------------------------------------------------------
+    }
+}

SearchFindReplace/Form1.de.resx

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="groupBox1.Text" xml:space="preserve">
+    <value>Sprache</value>
+  </data>
+  <data name="groupBoxDll.Text" xml:space="preserve">
+    <value>Verwendete DLLs</value>
+  </data>
+  <data name="buttonCheckLanguage.Text" xml:space="preserve">
+    <value>Sprache in MessageBox testen</value>
+  </data>
+  <data name="spracheToolStripMenuItem.Text" xml:space="preserve">
+    <value>Sprache</value>
+  </data>
+</root>

SearchFindReplace/Form1.en.resx

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="groupBox1.Text" xml:space="preserve">
+    <value>Language</value>
+  </data>
+  <data name="groupBoxDll.Text" xml:space="preserve">
+    <value>Used DLLs</value>
+  </data>
+  <data name="buttonCheckLanguage.Text" xml:space="preserve">
+    <value>Test language in MessageBox</value>
+  </data>
+  <data name="spracheToolStripMenuItem.Text" xml:space="preserve">
+    <value>Language</value>
+  </data>
+</root>

SearchFindReplace/Form1.resx

@@ -0,0 +1,467 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+  <data name="textBoxText.Location" type="System.Drawing.Point, System.Drawing">
+    <value>13, 27</value>
+  </data>
+  <assembly alias="mscorlib" name="mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="textBoxText.Multiline" type="System.Boolean, mscorlib">
+    <value>True</value>
+  </data>
+  <data name="textBoxText.Size" type="System.Drawing.Size, System.Drawing">
+    <value>375, 411</value>
+  </data>
+  <data name="textBoxText.TabIndex" type="System.Int32, mscorlib">
+    <value>0</value>
+  </data>
+  <data name="textBoxText.Text" xml:space="preserve">
+    <value>Das ist ein Probetext. Er dient zum Testen einer Suchen und Finden Funktion.
+Wird ein angegebener Suchstring im Text gefunden, dann wird die Textstelle selektiert.
+Ist der Suchstring nicht im Text enthalten, dann wird eine Meldung ausgegeben.
+Mit "Nächster Treffer" wird im Text nach dem nächsten Vorkommen des Suchstrings gesucht. Wird ein weiteres Vorkommen gefunden, dann wird die Textstelle markiert.
+"Vorheriger Treffer" hat die gleiche Funktion wie "Nächster", nur ist die Suchrichtung rückwärts.
+Die Anderen Optionen müssen noch definiert werden.
+</value>
+    <comment>@Invariant</comment>
+  </data>
+  <data name="&gt;&gt;textBoxText.Name" xml:space="preserve">
+    <value>textBoxText</value>
+  </data>
+  <data name="&gt;&gt;textBoxText.Type" xml:space="preserve">
+    <value>System.Windows.Forms.TextBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;textBoxText.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;textBoxText.ZOrder" xml:space="preserve">
+    <value>5</value>
+  </data>
+  <data name="radioButtonEnglish.AutoSize" type="System.Boolean, mscorlib">
+    <value>True</value>
+  </data>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="radioButtonEnglish.ImeMode" type="System.Windows.Forms.ImeMode, System.Windows.Forms">
+    <value>NoControl</value>
+  </data>
+  <data name="radioButtonEnglish.Location" type="System.Drawing.Point, System.Drawing">
+    <value>326, 19</value>
+  </data>
+  <data name="radioButtonEnglish.Size" type="System.Drawing.Size, System.Drawing">
+    <value>59, 17</value>
+  </data>
+  <data name="radioButtonEnglish.TabIndex" type="System.Int32, mscorlib">
+    <value>1</value>
+  </data>
+  <data name="radioButtonEnglish.Text" xml:space="preserve">
+    <value>English</value>
+    <comment>@Invariant</comment>
+  </data>
+  <data name="&gt;&gt;radioButtonEnglish.Name" xml:space="preserve">
+    <value>radioButtonEnglish</value>
+  </data>
+  <data name="&gt;&gt;radioButtonEnglish.Type" xml:space="preserve">
+    <value>System.Windows.Forms.RadioButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;radioButtonEnglish.Parent" xml:space="preserve">
+    <value>groupBox1</value>
+  </data>
+  <data name="&gt;&gt;radioButtonEnglish.ZOrder" xml:space="preserve">
+    <value>0</value>
+  </data>
+  <data name="radioButtonGerman.AutoSize" type="System.Boolean, mscorlib">
+    <value>True</value>
+  </data>
+  <data name="radioButtonGerman.ImeMode" type="System.Windows.Forms.ImeMode, System.Windows.Forms">
+    <value>NoControl</value>
+  </data>
+  <data name="radioButtonGerman.Location" type="System.Drawing.Point, System.Drawing">
+    <value>6, 19</value>
+  </data>
+  <data name="radioButtonGerman.Size" type="System.Drawing.Size, System.Drawing">
+    <value>65, 17</value>
+  </data>
+  <data name="radioButtonGerman.TabIndex" type="System.Int32, mscorlib">
+    <value>0</value>
+  </data>
+  <data name="radioButtonGerman.Text" xml:space="preserve">
+    <value>Deutsch</value>
+    <comment>@Invariant</comment>
+  </data>
+  <data name="&gt;&gt;radioButtonGerman.Name" xml:space="preserve">
+    <value>radioButtonGerman</value>
+  </data>
+  <data name="&gt;&gt;radioButtonGerman.Type" xml:space="preserve">
+    <value>System.Windows.Forms.RadioButton, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;radioButtonGerman.Parent" xml:space="preserve">
+    <value>groupBox1</value>
+  </data>
+  <data name="&gt;&gt;radioButtonGerman.ZOrder" xml:space="preserve">
+    <value>1</value>
+  </data>
+  <data name="groupBox1.Location" type="System.Drawing.Point, System.Drawing">
+    <value>397, 366</value>
+  </data>
+  <data name="groupBox1.Size" type="System.Drawing.Size, System.Drawing">
+    <value>391, 43</value>
+  </data>
+  <data name="groupBox1.TabIndex" type="System.Int32, mscorlib">
+    <value>3</value>
+  </data>
+  <data name="groupBox1.Text" xml:space="preserve">
+    <value>Sprache</value>
+  </data>
+  <data name="&gt;&gt;groupBox1.Name" xml:space="preserve">
+    <value>groupBox1</value>
+  </data>
+  <data name="&gt;&gt;groupBox1.Type" xml:space="preserve">
+    <value>System.Windows.Forms.GroupBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;groupBox1.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;groupBox1.ZOrder" xml:space="preserve">
+    <value>2</value>
+  </data>
+  <metadata name="menuStrip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>17, 17</value>
+  </metadata>
+  <data name="deutschToolStripMenuItem.Size" type="System.Drawing.Size, System.Drawing">
+    <value>117, 22</value>
+  </data>
+  <data name="deutschToolStripMenuItem.Text" xml:space="preserve">
+    <value>Deutsch</value>
+    <comment>@Invariant</comment>
+  </data>
+  <data name="englischToolStripMenuItem.Size" type="System.Drawing.Size, System.Drawing">
+    <value>117, 22</value>
+  </data>
+  <data name="englischToolStripMenuItem.Text" xml:space="preserve">
+    <value>English</value>
+    <comment>@Invariant</comment>
+  </data>
+  <data name="spracheToolStripMenuItem.Size" type="System.Drawing.Size, System.Drawing">
+    <value>61, 20</value>
+  </data>
+  <data name="spracheToolStripMenuItem.Text" xml:space="preserve">
+    <value>Sprache</value>
+  </data>
+  <data name="menuStrip.Location" type="System.Drawing.Point, System.Drawing">
+    <value>0, 0</value>
+  </data>
+  <data name="menuStrip.Size" type="System.Drawing.Size, System.Drawing">
+    <value>800, 24</value>
+  </data>
+  <data name="menuStrip.TabIndex" type="System.Int32, mscorlib">
+    <value>4</value>
+  </data>
+  <data name="menuStrip.Text" xml:space="preserve">
+    <value>menuStrip1</value>
+    <comment>@Invariant</comment>
+  </data>
+  <data name="&gt;&gt;menuStrip.Name" xml:space="preserve">
+    <value>menuStrip</value>
+  </data>
+  <data name="&gt;&gt;menuStrip.Type" xml:space="preserve">
+    <value>System.Windows.Forms.MenuStrip, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;menuStrip.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;menuStrip.ZOrder" xml:space="preserve">
+    <value>6</value>
+  </data>
+  <data name="labelDllInfo.AutoSize" type="System.Boolean, mscorlib">
+    <value>True</value>
+  </data>
+  <data name="labelDllInfo.ImeMode" type="System.Windows.Forms.ImeMode, System.Windows.Forms">
+    <value>NoControl</value>
+  </data>
+  <data name="labelDllInfo.Location" type="System.Drawing.Point, System.Drawing">
+    <value>15, 16</value>
+  </data>
+  <data name="labelDllInfo.Size" type="System.Drawing.Size, System.Drawing">
+    <value>16, 13</value>
+  </data>
+  <data name="labelDllInfo.TabIndex" type="System.Int32, mscorlib">
+    <value>6</value>
+  </data>
+  <data name="labelDllInfo.Text" xml:space="preserve">
+    <value>...</value>
+    <comment>@Invariant</comment>
+  </data>
+  <data name="&gt;&gt;labelDllInfo.Name" xml:space="preserve">
+    <value>labelDllInfo</value>
+  </data>
+  <data name="&gt;&gt;labelDllInfo.Type" xml:space="preserve">
+    <value>System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;labelDllInfo.Parent" xml:space="preserve">
+    <value>groupBoxDll</value>
+  </data>
+  <data name="&gt;&gt;labelDllInfo.ZOrder" xml:space="preserve">
+    <value>0</value>
+  </data>
+  <data name="groupBoxDll.Location" type="System.Drawing.Point, System.Drawing">
+    <value>397, 260</value>
+  </data>
+  <data name="groupBoxDll.Size" type="System.Drawing.Size, System.Drawing">
+    <value>390, 100</value>
+  </data>
+  <data name="groupBoxDll.TabIndex" type="System.Int32, mscorlib">
+    <value>7</value>
+  </data>
+  <data name="groupBoxDll.Text" xml:space="preserve">
+    <value>Verwendete DLLs</value>
+  </data>
+  <data name="&gt;&gt;groupBoxDll.Name" xml:space="preserve">
+    <value>groupBoxDll</value>
+  </data>
+  <data name="&gt;&gt;groupBoxDll.Type" xml:space="preserve">
+    <value>System.Windows.Forms.GroupBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;groupBoxDll.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;groupBoxDll.ZOrder" xml:space="preserve">
+    <value>1</value>
+  </data>
+  <data name="buttonCheckLanguage.ImeMode" type="System.Windows.Forms.ImeMode, System.Windows.Forms">
+    <value>NoControl</value>
+  </data>
+  <data name="buttonCheckLanguage.Location" type="System.Drawing.Point, System.Drawing">
+    <value>397, 415</value>
+  </data>
+  <data name="buttonCheckLanguage.Size" type="System.Drawing.Size, System.Drawing">
+    <value>391, 23</value>
+  </data>
+  <data name="buttonCheckLanguage.TabIndex" type="System.Int32, mscorlib">
+    <value>8</value>
+  </data>
+  <data name="buttonCheckLanguage.Text" xml:space="preserve">
+    <value>Sprache in MessageBox testen</value>
+  </data>
+  <data name="&gt;&gt;buttonCheckLanguage.Name" xml:space="preserve">
+    <value>buttonCheckLanguage</value>
+  </data>
+  <data name="&gt;&gt;buttonCheckLanguage.Type" xml:space="preserve">
+    <value>System.Windows.Forms.Button, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;buttonCheckLanguage.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;buttonCheckLanguage.ZOrder" xml:space="preserve">
+    <value>0</value>
+  </data>
+  <data name="replace1.Anchor" type="System.Windows.Forms.AnchorStyles, System.Windows.Forms">
+    <value>Top, Left, Right</value>
+  </data>
+  <data name="replace1.Location" type="System.Drawing.Point, System.Drawing">
+    <value>398, 154</value>
+  </data>
+  <data name="replace1.MinimumSize" type="System.Drawing.Size, System.Drawing">
+    <value>250, 68</value>
+  </data>
+  <data name="replace1.Size" type="System.Drawing.Size, System.Drawing">
+    <value>390, 68</value>
+  </data>
+  <data name="replace1.TabIndex" type="System.Int32, mscorlib">
+    <value>2</value>
+  </data>
+  <data name="&gt;&gt;replace1.Name" xml:space="preserve">
+    <value>replace1</value>
+  </data>
+  <data name="&gt;&gt;replace1.Type" xml:space="preserve">
+    <value>Eugen.ESystem.Windows.Forms.Replace, ReplaceString, Version=1.0.7615.25398, Culture=neutral, PublicKeyToken=null</value>
+  </data>
+  <data name="&gt;&gt;replace1.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;replace1.ZOrder" xml:space="preserve">
+    <value>3</value>
+  </data>
+  <data name="search1.Anchor" type="System.Windows.Forms.AnchorStyles, System.Windows.Forms">
+    <value>Top, Left, Right</value>
+  </data>
+  <data name="search1.Location" type="System.Drawing.Point, System.Drawing">
+    <value>398, 27</value>
+  </data>
+  <data name="search1.MinimumSize" type="System.Drawing.Size, System.Drawing">
+    <value>250, 120</value>
+  </data>
+  <data name="search1.Size" type="System.Drawing.Size, System.Drawing">
+    <value>390, 120</value>
+  </data>
+  <data name="search1.TabIndex" type="System.Int32, mscorlib">
+    <value>1</value>
+  </data>
+  <data name="&gt;&gt;search1.Name" xml:space="preserve">
+    <value>search1</value>
+  </data>
+  <data name="&gt;&gt;search1.Type" xml:space="preserve">
+    <value>Eugen.ESystem.Windows.Forms.Search, SearchString, Version=1.0.7615.25397, Culture=neutral, PublicKeyToken=null</value>
+  </data>
+  <data name="&gt;&gt;search1.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;search1.ZOrder" xml:space="preserve">
+    <value>4</value>
+  </data>
+  <metadata name="$this.Localizable" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
+    <value>True</value>
+  </metadata>
+  <data name="$this.AutoScaleDimensions" type="System.Drawing.SizeF, System.Drawing">
+    <value>6, 13</value>
+  </data>
+  <data name="$this.ClientSize" type="System.Drawing.Size, System.Drawing">
+    <value>800, 450</value>
+  </data>
+  <data name="$this.ImeMode" type="System.Windows.Forms.ImeMode, System.Windows.Forms">
+    <value>NoControl</value>
+  </data>
+  <data name="$this.Text" xml:space="preserve">
+    <value>Test_User Control with language switch</value>
+    <comment>@Invariant</comment>
+  </data>
+  <data name="&gt;&gt;spracheToolStripMenuItem.Name" xml:space="preserve">
+    <value>spracheToolStripMenuItem</value>
+  </data>
+  <data name="&gt;&gt;spracheToolStripMenuItem.Type" xml:space="preserve">
+    <value>System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;deutschToolStripMenuItem.Name" xml:space="preserve">
+    <value>deutschToolStripMenuItem</value>
+  </data>
+  <data name="&gt;&gt;deutschToolStripMenuItem.Type" xml:space="preserve">
+    <value>System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;englischToolStripMenuItem.Name" xml:space="preserve">
+    <value>englischToolStripMenuItem</value>
+  </data>
+  <data name="&gt;&gt;englischToolStripMenuItem.Type" xml:space="preserve">
+    <value>System.Windows.Forms.ToolStripMenuItem, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;$this.Name" xml:space="preserve">
+    <value>Form1</value>
+  </data>
+  <data name="&gt;&gt;$this.Type" xml:space="preserve">
+    <value>System.Windows.Forms.Form, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+</root>

SearchFindReplace/Languages.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Eugen.ESystem.Windows.Forms
+{
+    class Languages
+    {
+        public static Languages.Language CurrentLanguage { set; get; }
+
+        public enum Language
+        {
+            German,
+            English
+        }
+    }
+}

SearchFindReplace/Program.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace SearchFindReplace
+{
+    static class Program
+    {
+        /// <summary>
+        /// Der Haupteinstiegspunkt für die Anwendung.
+        /// </summary>
+        [STAThread]
+        static void Main()
+        {
+            CultureInfo myCultureInfo = new CultureInfo("en");
+            Thread.CurrentThread.CurrentCulture = myCultureInfo;
+            Thread.CurrentThread.CurrentUICulture = myCultureInfo;
+
+            Application.EnableVisualStyles();
+            Application.SetCompatibleTextRenderingDefault(false);
+            Application.Run(new Form1());
+        }
+    }
+}

SearchFindReplace/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// Allgemeine Informationen über eine Assembly werden über die folgenden
+// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern,
+// die einer Assembly zugeordnet sind.
+[assembly: AssemblyTitle("SearchFindReplace")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("SearchFindReplace")]
+[assembly: AssemblyCopyright("Copyright © 2020 by Eugen Höglinger")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Durch Festlegen von ComVisible auf FALSE werden die Typen in dieser Assembly
+// für COM-Komponenten unsichtbar.  Wenn Sie auf einen Typ in dieser Assembly von
+// COM aus zugreifen müssen, sollten Sie das ComVisible-Attribut für diesen Typ auf "True" festlegen.
+[assembly: ComVisible(false)]
+
+// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird
+[assembly: Guid("50068e99-23b8-46a2-b2d0-02e60c17cf3c")]
+
+// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten:
+//
+//      Hauptversion
+//      Nebenversion
+//      Buildnummer
+//      Revision
+//
+// Sie können alle Werte angeben oder Standardwerte für die Build- und Revisionsnummern verwenden,
+// indem Sie "*" wie unten gezeigt eingeben:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

SearchFindReplace/Properties/Resources.Designer.cs

@@ -0,0 +1,82 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     Dieser Code wurde von einem Tool generiert.
+//     Laufzeitversion:4.0.30319.42000
+//
+//     Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn
+//     der Code erneut generiert wird.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace SearchFindReplace {
+    using System;
+    
+    
+    /// <summary>
+    ///   Eine stark typisierte Ressourcenklasse zum Suchen von lokalisierten Zeichenfolgen usw.
+    /// </summary>
+    // Diese Klasse wurde von der StronglyTypedResourceBuilder automatisch generiert
+    // -Klasse über ein Tool wie ResGen oder Visual Studio automatisch generiert.
+    // Um einen Member hinzuzufügen oder zu entfernen, bearbeiten Sie die .ResX-Datei und führen dann ResGen
+    // mit der /str-Option erneut aus, oder Sie erstellen Ihr VS-Projekt neu.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Gibt die zwischengespeicherte ResourceManager-Instanz zurück, die von dieser Klasse verwendet wird.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("SearchFindReplace.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Überschreibt die CurrentUICulture-Eigenschaft des aktuellen Threads für alle
+        ///   Ressourcenzuordnungen, die diese stark typisierte Ressourcenklasse verwenden.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Information ähnelt.
+        /// </summary>
+        internal static string mbt000caption {
+            get {
+                return ResourceManager.GetString("mbt000caption", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Das ist ein Sprach Test.
+        ///Ausgewählt ist:  ähnelt.
+        /// </summary>
+        internal static string mbt000text {
+            get {
+                return ResourceManager.GetString("mbt000text", resourceCulture);
+            }
+        }
+    }
+}

SearchFindReplace/Properties/Resources.de.resx

@@ -0,0 +1,127 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="mbt000caption" xml:space="preserve">
+    <value>Information</value>
+  </data>
+  <data name="mbt000text" xml:space="preserve">
+    <value>Das ist ein Sprach Test.
+Ausgewählt ist: </value>
+  </data>
+</root>

SearchFindReplace/Properties/Resources.en.resx

@@ -0,0 +1,127 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="mbt000caption" xml:space="preserve">
+    <value>Information</value>
+  </data>
+  <data name="mbt000text" xml:space="preserve">
+    <value>This is a language test.
+Selected is: </value>
+  </data>
+</root>

SearchFindReplace/Properties/Resources.resx

@@ -0,0 +1,127 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="mbt000caption" xml:space="preserve">
+    <value>Information</value>
+  </data>
+  <data name="mbt000text" xml:space="preserve">
+    <value>Das ist ein Sprach Test.
+Ausgewählt ist: </value>
+  </data>
+</root>

SearchFindReplace/Properties/Settings.Designer.cs

@@ -0,0 +1,30 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace SearchFindReplace.Properties
+{
+
+
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
+    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
+    {
+
+        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+
+        public static Settings Default
+        {
+            get
+            {
+                return defaultInstance;
+            }
+        }
+    }
+}

SearchFindReplace/Properties/Settings.settings

@@ -0,0 +1,7 @@
+<?xml version='1.0' encoding='utf-8'?>
+<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)">
+  <Profiles>
+    <Profile Name="(Default)" />
+  </Profiles>
+  <Settings />
+</SettingsFile>

SearchFindReplace/SearchFindReplace.csproj

@@ -0,0 +1,140 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{50068E99-23B8-46A2-B2D0-02E60C17CF3C}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <RootNamespace>SearchFindReplace</RootNamespace>
+    <AssemblyName>SearchFindReplace</AssemblyName>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <Deterministic>false</Deterministic>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Deployment" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AppResources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>AppResources.resx</DependentUpon>
+    </Compile>
+    <Compile Include="AppResources.en.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>AppResources.en.resx</DependentUpon>
+    </Compile>
+    <Compile Include="Form1.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Form1.Designer.cs">
+      <DependentUpon>Form1.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\Resources.Designer.cs">
+      <DependentUpon>Resources.resx</DependentUpon>
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+    </Compile>
+    <Compile Include="Properties\Resources.en.Designer.cs">
+      <DependentUpon>Resources.en.resx</DependentUpon>
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+    </Compile>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <EmbeddedResource Include="AppResources.de.resx">
+      <CustomToolNamespace>SearchFindReplace</CustomToolNamespace>
+    </EmbeddedResource>
+    <EmbeddedResource Include="AppResources.en.resx">
+      <CustomToolNamespace>SearchFindReplace</CustomToolNamespace>
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>AppResources.en.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+    <EmbeddedResource Include="AppResources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>AppResources.Designer.cs</LastGenOutput>
+      <CustomToolNamespace>SearchFindReplace</CustomToolNamespace>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Form1.de.resx">
+      <DependentUpon>Form1.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Form1.en.resx">
+      <DependentUpon>Form1.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Form1.resx">
+      <DependentUpon>Form1.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Properties\Resources.de.resx">
+      <CustomToolNamespace>SearchFindReplace</CustomToolNamespace>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Properties\Resources.en.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.en.Designer.cs</LastGenOutput>
+      <CustomToolNamespace>SearchFindReplace</CustomToolNamespace>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+      <CustomToolNamespace>SearchFindReplace</CustomToolNamespace>
+    </EmbeddedResource>
+    <None Include="Properties\Settings.settings">
+      <Generator>SettingsSingleFileGenerator</Generator>
+      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
+    </None>
+    <Compile Include="Properties\Settings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Settings.settings</DependentUpon>
+      <DesignTimeSharedInput>True</DesignTimeSharedInput>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\FormLanguageSwitch\FormLanguageSwitch.csproj">
+      <Project>{787b600c-9a56-41c7-a3c8-9553630fe3c1}</Project>
+      <Name>FormLanguageSwitch</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\ReplaceString\ReplaceString.csproj">
+      <Project>{b402b197-7eba-4994-9fcd-a658b23648b0}</Project>
+      <Name>ReplaceString</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\SearchString\SearchString.csproj">
+      <Project>{91ec8467-e4fc-44c7-8092-c3ae6ae75009}</Project>
+      <Name>SearchString</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

SearchFindReplace/bin/Debug/SearchFindReplace.exe.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
+    </startup>
+</configuration>

SearchFindReplace/obj/Debug/.NETFramework,Version=v4.7.2.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]