private static string GetEnvironmentVariableCore(string variable) { if (AppDomain.IsAppXModel() && !AppDomain.IsAppXDesignMode()) { // Environment variable accessors are not approved modern API. // Behave as if the variable was not found in this case. return(null); } StringBuilder sb = StringBuilderCache.Acquire(128); // A somewhat reasonable default size int requiredSize = Win32Native.GetEnvironmentVariable(variable, sb, sb.Capacity); if (requiredSize == 0 && Marshal.GetLastWin32Error() == Win32Native.ERROR_ENVVAR_NOT_FOUND) { StringBuilderCache.Release(sb); return(null); } while (requiredSize > sb.Capacity) { sb.Capacity = requiredSize; sb.Length = 0; requiredSize = Win32Native.GetEnvironmentVariable(variable, sb, sb.Capacity); } return(StringBuilderCache.GetStringAndRelease(sb)); }
// This is used by the runtime when re-throwing a managed exception. It will // copy the stack trace to _remoteStackTraceString. internal void InternalPreserveStackTrace() { string tmpStackTraceString; #if FEATURE_APPX if (AppDomain.IsAppXModel()) { // Call our internal GetStackTrace in AppX so we can parse the result should // we need to strip file/line info from it to make it PII-free. Calling the // public and overridable StackTrace getter here was probably not intended. tmpStackTraceString = GetStackTrace(true); // Make sure that the _source field is initialized if Source is not overriden. // We want it to contain the original faulting point. string source = Source; } else #else // FEATURE_APPX // Preinitialize _source on CoreSystem as well. The legacy behavior is not ideal and // we keep it for back compat but we can afford to make the change on the Phone. string source = Source; #endif // FEATURE_APPX { // Call the StackTrace getter in classic for compat. tmpStackTraceString = StackTrace; } if (tmpStackTraceString != null && tmpStackTraceString.Length > 0) { _remoteStackTraceString = tmpStackTraceString + Environment.NewLine; } _stackTrace = null; _stackTraceString = null; }
private static void SetEnvironmentVariableCore(string variable, string value) { // explicitly null out value if is the empty string. if (string.IsNullOrEmpty(value) || value[0] == '\0') { value = null; } if (AppDomain.IsAppXModel() && !AppDomain.IsAppXDesignMode()) { // Environment variable accessors are not approved modern API. // so we throw PlatformNotSupportedException. throw new PlatformNotSupportedException(); } if (!Win32Native.SetEnvironmentVariable(variable, value)) { int errorCode = Marshal.GetLastWin32Error(); switch (errorCode) { case Win32Native.ERROR_ENVVAR_NOT_FOUND: // Allow user to try to clear a environment variable return; case Win32Native.ERROR_FILENAME_EXCED_RANGE: // The error message from Win32 is "The filename or extension is too long", // which is not accurate. throw new ArgumentException(GetResourceString("Argument_LongEnvVarValue")); default: throw new ArgumentException(Win32Native.GetMessage(errorCode)); } } }
private static IDictionary GetEnvironmentVariablesCore() { if (AppDomain.IsAppXModel() && !AppDomain.IsAppXDesignMode()) { // Environment variable accessors are not approved modern API. // Behave as if no environment variables are defined in this case. return(new Dictionary <string, string>(0)); } return(GetRawEnvironmentVariables()); }
public override string ToString() { if (AppDomain.IsAppXModel()) { IStringable stringable = this as IStringable; if (stringable != null) { return(stringable.ToString()); } } return(base.ToString()); }
/// <summary> /// Overrides ToString() to make sure we call to IStringable if the COM /// object implements it in the case of weakly typed RCWs /// </summary> public override string ToString() { // Only do the IStringable cast when running under AppX for better compat // Otherwise we could do a IStringable cast in classic apps which could introduce // a thread transition which would lead to deadlock. if (AppDomain.IsAppXModel()) { // Check whether the type implements IStringable. if (this is IStringable stringableType) { return(stringableType.ToString()); } } return(base.ToString()); }
internal static IEnumerable <KeyValuePair <string, string> > EnumerateEnvironmentVariablesFromRegistry(EnvironmentVariableTarget target) { #if FEATURE_WIN32_REGISTRY if (AppDomain.IsAppXModel()) #endif { // Without registry support we have nothing to return ValidateTarget(target); yield break; } #if FEATURE_WIN32_REGISTRY RegistryKey baseKey; string keyName; if (target == EnvironmentVariableTarget.Machine) { baseKey = Registry.LocalMachine; keyName = @"System\CurrentControlSet\Control\Session Manager\Environment"; } else if (target == EnvironmentVariableTarget.User) { Debug.Assert(target == EnvironmentVariableTarget.User); baseKey = Registry.CurrentUser; keyName = @"Environment"; } else { throw new ArgumentOutOfRangeException(nameof(target), target, SR.Format(SR.Arg_EnumIllegalVal, target)); } using (RegistryKey environmentKey = baseKey.OpenSubKey(keyName, writable: false)) { if (environmentKey != null) { foreach (string name in environmentKey.GetValueNames()) { string value = environmentKey.GetValue(name, "").ToString(); yield return(new KeyValuePair <string, string>(name, value)); } } } #endif // FEATURE_WIN32_REGISTRY }
// Token: 0x060005CC RID: 1484 RVA: 0x00014A78 File Offset: 0x00012C78 internal void InternalPreserveStackTrace() { string stackTrace; if (AppDomain.IsAppXModel()) { stackTrace = this.GetStackTrace(true); string source = this.Source; } else { stackTrace = this.StackTrace; } if (stackTrace != null && stackTrace.Length > 0) { this._remoteStackTraceString = stackTrace + Environment.NewLine; } this._stackTrace = null; this._stackTraceString = null; }
private static string GetEnvironmentVariableCore(string variable, EnvironmentVariableTarget target) { if (target == EnvironmentVariableTarget.Process) { return(GetEnvironmentVariableCore(variable)); } #if FEATURE_WIN32_REGISTRY if (AppDomain.IsAppXModel()) #endif { return(null); } #if FEATURE_WIN32_REGISTRY RegistryKey baseKey; string keyName; if (target == EnvironmentVariableTarget.Machine) { baseKey = Registry.LocalMachine; keyName = @"System\CurrentControlSet\Control\Session Manager\Environment"; } else if (target == EnvironmentVariableTarget.User) { Debug.Assert(target == EnvironmentVariableTarget.User); baseKey = Registry.CurrentUser; keyName = "Environment"; } else { throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, (int)target)); } using (RegistryKey environmentKey = baseKey.OpenSubKey(keyName, writable: false)) { return(environmentKey?.GetValue(variable) as string); } #endif }
private static void SetEnvironmentVariableCore(string variable, string value, EnvironmentVariableTarget target) { if (target == EnvironmentVariableTarget.Process) { SetEnvironmentVariableCore(variable, value); return; } #if FEATURE_WIN32_REGISTRY if (AppDomain.IsAppXModel()) #endif { // other targets ignored return; } #if FEATURE_WIN32_REGISTRY // explicitly null out value if is the empty string. if (string.IsNullOrEmpty(value) || value[0] == '\0') { value = null; } RegistryKey baseKey; string keyName; if (target == EnvironmentVariableTarget.Machine) { baseKey = Registry.LocalMachine; keyName = @"System\CurrentControlSet\Control\Session Manager\Environment"; } else if (target == EnvironmentVariableTarget.User) { Debug.Assert(target == EnvironmentVariableTarget.User); // User-wide environment variables stored in the registry are limited to 255 chars for the environment variable name. const int MaxUserEnvVariableLength = 255; if (variable.Length >= MaxUserEnvVariableLength) { throw new ArgumentException(SR.Argument_LongEnvVarValue, nameof(variable)); } baseKey = Registry.CurrentUser; keyName = "Environment"; } else { throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, (int)target)); } using (RegistryKey environmentKey = baseKey.OpenSubKey(keyName, writable: true)) { if (environmentKey != null) { if (value == null) { environmentKey.DeleteValue(variable, throwOnMissingValue: false); } else { environmentKey.SetValue(variable, value); } } } // send a WM_SETTINGCHANGE message to all windows IntPtr r = Win32Native.SendMessageTimeout(new IntPtr(Win32Native.HWND_BROADCAST), Win32Native.WM_SETTINGCHANGE, IntPtr.Zero, "Environment", 0, 1000, IntPtr.Zero); if (r == IntPtr.Zero) { Debug.Assert(false, "SetEnvironmentVariable failed: " + Marshal.GetLastWin32Error()); } #endif // FEATURE_WIN32_REGISTRY }
public static String ExpandEnvironmentVariables(String name) { if (name == null) { throw new ArgumentNullException(nameof(name)); } Contract.EndContractBlock(); if (name.Length == 0) { return(name); } if (AppDomain.IsAppXModel() && !AppDomain.IsAppXDesignMode()) { // Environment variable accessors are not approved modern API. // Behave as if no variables are defined in this case. return(name); } int currentSize = 100; StringBuilder blob = new StringBuilder(currentSize); // A somewhat reasonable default size #if PLATFORM_UNIX // Win32Native.ExpandEnvironmentStrings isn't available int lastPos = 0, pos; while (lastPos < name.Length && (pos = name.IndexOf('%', lastPos + 1)) >= 0) { if (name[lastPos] == '%') { string key = name.Substring(lastPos + 1, pos - lastPos - 1); string value = Environment.GetEnvironmentVariable(key); if (value != null) { blob.Append(value); lastPos = pos + 1; continue; } } blob.Append(name.Substring(lastPos, pos - lastPos)); lastPos = pos; } blob.Append(name.Substring(lastPos)); #else int size; blob.Length = 0; size = Win32Native.ExpandEnvironmentStrings(name, blob, currentSize); if (size == 0) { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } while (size > currentSize) { currentSize = size; blob.Capacity = currentSize; blob.Length = 0; size = Win32Native.ExpandEnvironmentStrings(name, blob, currentSize); if (size == 0) { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } } #endif // PLATFORM_UNIX return(blob.ToString()); }