private static string GetEnvironmentVariableCore(string variable, EnvironmentVariableTarget target)
        {
            if (target == EnvironmentVariableTarget.Process)
            {
                return GetEnvironmentVariableCore(variable);
            }
            else
            {
                RegistryKey baseKey;
                string keyName;

                if (target == EnvironmentVariableTarget.Machine)
                {
                    baseKey = Registry.LocalMachine;
                    keyName = @"System\CurrentControlSet\Control\Session Manager\Environment";
                }
                else
                {
                    Debug.Assert(target == EnvironmentVariableTarget.User);
                    baseKey = Registry.CurrentUser;
                    keyName = "Environment";
                }

                using (RegistryKey environmentKey = baseKey.OpenSubKey(keyName, writable: false))
                {
                    return environmentKey?.GetValue(variable) as string;
                }
            }
        }

        /// <summary>
        /// Retrieves all environment variable names and their values
        /// from the Windows operating system registry key for the
        /// current user or local machine.
        /// </summary>
        /// <param name="target">
        /// One of the <see cref="System.EnvironmentVariableTarget" /> values.
        /// </param>
        /// <returns>
        /// A dictionary that contains all environment variables
        /// names and their values from the source specified by the
        /// target parameter; otherwise, an empty dictionary if no
        /// environment variables are found.
        /// </returns>
        public static IDictionary<string, string> GetEnvironmentVariables(EnvironmentVariableTarget target)
        {
            Dictionary<string, string> variables = new Dictionary<string, string>();

            string keyName;
            RegistryKey registryKey;

            switch (target)
            {
                case EnvironmentVariableTarget.Machine:
                    keyName = @"SYSTEM\CurrentControlSet\Control\Session Manager\Environment";
                    registryKey = Registry.LocalMachine.OpenSubKey(keyName);
                    break;
                case EnvironmentVariableTarget.User:
                    keyName = @"Environment";
                    registryKey = Registry.CurrentUser.OpenSubKey(keyName);
                    break;
                default:
                    throw new ArgumentException("Invalid environment variable target", "target");
            }

            foreach (string name in registryKey.GetValueNames())
            {
                variables.Add(name, (string)registryKey.GetValue(name, null, RegistryValueOptions.DoNotExpandEnvironmentNames));
            }

            return variables;
        }

        /// <summary>
        /// Creates, modifies, or deletes an environment variable stored
        /// in the Windows operating system registry key reserved for the
        /// current user or local machine.
        /// </summary>
        /// <param name="variable">
        /// The name of an environment variable.
        /// </param>
        /// <param name="value">A value to assign to variable.</param>
        /// <param name="target">
        /// One of the <see cref="System.EnvironmentVariableTarget" /> values.
        /// </param>
        public static void SetEnvironmentVariable(string variable, string value, EnvironmentVariableTarget target)
        {
            string keyName;
            RegistryKey registryKey;

            switch (target)
            {
                case EnvironmentVariableTarget.Machine:
                    keyName = @"SYSTEM\CurrentControlSet\Control\Session Manager\Environment";
                    registryKey = Registry.LocalMachine.OpenSubKey(keyName, true);
                    break;
                case EnvironmentVariableTarget.User:
                    keyName = @"Environment";
                    registryKey = Registry.CurrentUser.OpenSubKey(keyName, true);
                    break;
                default:
                    throw new ArgumentException("Invalid environment variable target", "target");
            }

            if (value == null)
            {
                registryKey.DeleteValue(variable, false);
            }
            else
            {
                registryKey.SetValue(variable, value, RegistryValueKind.ExpandString);
            }

            Notification.EnvironmentChanged();
        }

        private string GetExisting(EnvironmentVariableTarget target, string variableName)
        {
            var existingVariable = _variables[target][variableName];
            if (!IsValid(existingVariable)) UpdateVariable(existingVariable);

            return existingVariable.Content;
        }

 public static void AllVariables(EnvironmentVariableTarget target)
 {
     foreach (DictionaryEntry var in Environment.GetEnvironmentVariables(target))
     {
         string key = (string)var.Key;
         string value = (string)var.Value;
         ConsoleHelper.WriteLine(key + ": " + value);
     }
 }

 public string Get(string variableName, EnvironmentVariableTarget target)
 {
     lock (LockKey)
     {
         return _variables[target].ContainsKey(variableName)
                    ? GetExisting(target, variableName)
                    : GetNew(target, variableName);
     }
 }

        /// <summary>
        /// Loads the environment variables.
        /// </summary>
        /// <param name="dg">The Data Grid View.</param>
        /// <param name="target">The target.</param>
        private void LoadEnvironmentVariables(
            DataGrid dg, EnvironmentVariableTarget target)
        {
            dg.IsReadOnly = true;

            IDictionary environmentVariables
                = this.variableManger.GetEnvVariables(target);

            dg.ItemsSource = environmentVariables;
        }

        public static string GetEnvironmentVariable(string variable, EnvironmentVariableTarget target)
        {
            if (variable == null)
            {
                throw new ArgumentNullException(nameof(variable));
            }

            ValidateTarget(target);

            return GetEnvironmentVariableCore(variable, target);
        }

        public bool Exists(string variableName, EnvironmentVariableTarget target)
        {
            lock (LockKey)
            {
                if (_variables[target].ContainsKey(variableName) && _variables[target][variableName].Content != null) return true;

                var variable = System.Environment.GetEnvironmentVariable(variableName, target);

                return variable != null;
            }
        }

        /// <summary>
        /// This program allows you to view and modify the PATH environment.
        /// </summary>
        /// <param name="args"></param>
        private void Run(string[] args)
        {
            Console.OutputEncoding = Encoding.GetEncoding(Encoding.Default.CodePage);
            Args = new InputArgs("pathed", string.Format(resource.IDS_TITLE, AppVersion.Get()) + "\r\n" + resource.IDS_COPYRIGHT);

            Args.Add(InputArgType.Flag, "machine", false, Presence.Optional, resource.IDS_CMD_machine_doc);
            Args.Add(InputArgType.Flag, "user", false, Presence.Optional, resource.IDS_CMD_user_doc);
            Args.Add(InputArgType.ExistingDirectory, "add", "", Presence.Optional, resource.IDS_CMD_add_doc);
            Args.Add(InputArgType.ExistingDirectory, "append", "", Presence.Optional, resource.IDS_CMD_append_doc);
            Args.Add(InputArgType.StringList, "remove", null, Presence.Optional, resource.IDS_CMD_remove_doc);
            Args.Add(InputArgType.Flag, "slim", false, Presence.Optional, resource.IDS_CMD_slim_doc);
            Args.Add(InputArgType.Parameter, "env", "PATH", Presence.Optional, resource.IDS_CMD_env_doc);

            if (Args.Process(args))
            {
                EnvironmentVariableName = Args.GetString("env");

                if (Args.GetFlag("slim"))
                    SlimPath();

                if (Args.GetFlag("machine"))
                    EnvironmentVariableTarget = EnvironmentVariableTarget.Machine;

                else if (Args.GetFlag("user"))
                    EnvironmentVariableTarget = EnvironmentVariableTarget.User;

                try
                {
                    List<string> removeItems = Args.GetStringList("remove");
                    if (removeItems != null)
                        Remove(removeItems);

                    string add = Args.GetString("add");
                    if (!string.IsNullOrEmpty(add))
                        AddHead(SanitizePath(add));

                    string append = Args.GetString("append");
                    if (!string.IsNullOrEmpty(append))
                        AddTail(SanitizePath(append));
                }
                catch (SecurityException ex)
                {
                    if (EnvironmentVariableTarget == EnvironmentVariableTarget.Machine)
                    {
                        Console.WriteLine(ex.Message);
                        Console.WriteLine(resource.IDS_ERR_access_denied);
                        return;
                    }
                    else throw;
                }

                ListPath();
            }
        }

        public void LoadEnvironment(EnvironmentVariableTarget target)
        {
            VarList.Items.Clear();

            environment = new EnvModel(target);

            foreach (string variable in environment.Variables.Keys)
            {
                VarList.Items.Add(variable);
            }

            SelectVariable(DefaultVariable);
        }

        public void LoadEnvironment(EnvironmentVariableTarget target)
        {
            VarList.Items.Clear();

            environment = new EnvModel(target);

            foreach (string variable in environment.Variables.Keys)
            {
                VarList.Items.Add(variable);
                environment.Variables[variable].CollectionChanged += new NotifyCollectionChangedEventHandler(Entries_CollectionChanged);
            }

            SelectVariable(DefaultVariable);
        }

        public static string GetVariable(string variable, EnvironmentVariableTarget target = EnvironmentVariableTarget.User)
        {
            string value;
            try
            {
                value = Environment.GetEnvironmentVariable(variable, target);
            }
            catch
            {
                value = null;
            }

            return value;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="EditModel" /> class.
 /// </summary>
 /// <param name="name">The name.</param>
 /// <param name="value">The value.</param>
 /// <param name="target">The target.</param>
 /// <param name="canEditName">if set to <c> true </c> [can edit name].</param>
 /// <param name="canEditValue">if set to <c> true </c> [can edit value].</param>
 /// <param name="canEditTarget">if set to <c> true </c> [can edit target].</param>
 public EditModel(
     string name = EmptyString,
     string value = EmptyString,
     EnvironmentVariableTarget target = EnvironmentVariableTarget.Process,
     bool canEditName = true,
     bool canEditValue = true,
     bool canEditTarget = true)
 {
     this.CanEditName = canEditName;
     this.CanEditValue = canEditValue;
     this.CanEditTarget = canEditTarget;
     this.Value = value;
     this.Name = name;
     this.Target = target;
 }

        public bool Parse(string[] args)
        {
            Target = EnvironmentVariableTarget.Machine;

            foreach (string arg in args)
            {
                if (arg.StartsWith("-"))
                {
                    switch (arg)
                    {
                        case "-p":
                            Target = EnvironmentVariableTarget.Process;
                            break;

                        case "-m":
                            Target = EnvironmentVariableTarget.Machine;
                            break;

                        case "-u":
                            Target = EnvironmentVariableTarget.User;
                            break;

                        default:
                            Console.WriteLine("Unknown option: {0}", arg);
                            return false;
                    }
                }
                else
                {
                    if (PathSegment == null)
                    {
                        PathSegment = arg;
                    }
                    else
                    {
                        Console.WriteLine("Unknown parameter: {0}", arg);
                        return false;
                    }
                }

            }

            if (PathSegment == null)
            {
                return false;
            }
            return true;
        }

		/////////////////////////////////////////////////////////////////////////////

		private static void AddString( string varName, EnvironmentVariableTarget target, string strIn )
		{
			// ******
			string oldValue = Environment.GetEnvironmentVariable( varName, target );
			if( null == oldValue ) {
				oldValue = string.Empty;
			}
			
			// ******
			if( ItemInString(oldValue, strIn) ) {
				//
				// already there
				//
				return;
			}

			// ******
			string newValue = string.Format( "{0}{1}{2}", oldValue, oldValue.EndsWith(";") ? string.Empty : ";", strIn );
			Environment.SetEnvironmentVariable( varName, newValue, target );
		}

        private static void ChangeForTargetEnvironment(Func<IEnumerable<string>, IEnumerable<string>> job, EnvironmentVariableTarget target)
        {
            string psModulePath = Environment.GetEnvironmentVariable(PSModulePathName, target) ?? string.Empty;
            IEnumerable<string> paths = psModulePath.Split(';');
            paths = job(paths);

            if (paths.Count() == 0)
            {
                Environment.SetEnvironmentVariable(PSModulePathName, null, target);
            }
            else if (paths.Count() == 1)
            {
                Environment.SetEnvironmentVariable(PSModulePathName, paths.First(), target);
            }
            else
            {
                psModulePath = string.Join(";", paths.Distinct());
                Environment.SetEnvironmentVariable(PSModulePathName, psModulePath, target);
            }
        }

        void __file_env_vars_value(EnvironmentVariableTarget target, string varname)
        {
            lstEnvVarValues.Items.Clear();

            if(varname == null)
                return;

            string value = Environment.GetEnvironmentVariable(varname, target);

            if (value == null)
                return;

            string[] value_split = value.Split(new char[] { ';' });

            foreach (string val in value_split)
            {
                lstEnvVarValues.Items.Add(val);
            }
            return;
        }

        private static void Add(EnvironmentVariableTarget Target, string NewItem, bool Append)
        {
            if(NewItem == "")
            ShowUse("You must provide a path when using ADD", -1);

              string work = NewItem;
              DirectoryInfo di = null;

              try { di = new DirectoryInfo(NewItem); }
              catch (SystemException se) { ShowError(se, -1); }

              if (di.Exists)
              {
             if(_matchCase)
            {
              string s = GetCaseFromFileSystem(di.FullName);
              if(s != work)
              {
            Verbose("Corrected case: " + s);
            work = s;
              }
            }
              }
              else
              {
            if (!_keepOrphans)
            {
              Console.WriteLine("New path item does not exist, you must set KeepOphans to add it.");
              return;
            }
              }

              List<string> original = GetCurrentPath(Target);

              if (Append)
            original.Add(work);
              else
            original.Insert(0, work);

              UpdatePath(Target, original);
        }

        public InputParameters(string[] args)
        {
            if (args.Length == 0)
            {
                _DisplayUsage = true;

                return;
            }

            for (int _Index = 0; _Index < args.Length; _Index++)
            {
                switch (args[_Index])
                {
                    case "-name":
                    case "/name":
                        this._VariableName = args[++_Index];
                        break;
                    case "-machine":
                    case "/machine":
                        this._VariableScope = EnvironmentVariableTarget.Machine;
                        break;
                    case "-help":
                    case "-?":
                    case "/help":
                    case "/?":
                        this._DisplayUsage = true;
                        break;
                    default:
                        throw new ArgumentException("Invalid parameter specified.", args[_Index]);
                }
            }

            if (!this.DisplayUsage && this.VariableName == String.Empty)
            {
                throw new ArgumentNullException("-name", "You must specify an Environment Variable Name!");
            }
        }