static class AppContextSwitches {
public static readonly bool ThrowExceptionIfDisposedCancellationTokenSource = true;
public static readonly bool SetActorAsReferenceWhenCopyingClaimsIdentity = false;
+ public static readonly bool NoAsyncCurrentCulture = false;
}
}
\ No newline at end of file
const int CalendarTypeBits = 8;
const string MSG_READONLY = "This instance is read only";
+
+ static volatile CultureInfo s_DefaultThreadCurrentUICulture;
+ static volatile CultureInfo s_DefaultThreadCurrentCulture;
public static CultureInfo InvariantCulture {
get {
return Thread.CurrentThread.CurrentCulture;
}
set {
- throw new NotImplementedException ();
+ Thread.CurrentThread.CurrentCulture = value;
}
}
return Thread.CurrentThread.CurrentUICulture;
}
set {
- throw new NotImplementedException ();
+ Thread.CurrentThread.CurrentUICulture = value;
}
}
}
}
- internal void CheckNeutral ()
+ void CheckNeutral ()
{
}
public static CultureInfo DefaultThreadCurrentCulture {
get {
- return Thread.default_culture;
+ return s_DefaultThreadCurrentCulture;
}
set {
- Thread.default_culture = value;
+ s_DefaultThreadCurrentCulture = value;
}
}
public static CultureInfo DefaultThreadCurrentUICulture {
get {
- return Thread.default_ui_culture;
+ return s_DefaultThreadCurrentUICulture;
}
set {
- Thread.default_ui_culture = value;
+ s_DefaultThreadCurrentUICulture = value;
}
}
}
}
+ internal static CultureInfo UserDefaultUICulture {
+ get {
+ return ConstructCurrentUICulture ();
+ }
+ }
+
+ internal static CultureInfo UserDefaultCulture {
+ get {
+ return ConstructCurrentCulture ();
+ }
+ }
+
+
#region reference sources
// TODO:
internal static readonly bool IsTaiwanSku;
return true;
}
+ internal static bool VerifyCultureName(CultureInfo culture, bool throwException) {
+ Contract.Assert(culture!=null, "[CultureInfo.VerifyCultureName]culture!=null");
+
+ //If we have an instance of one of our CultureInfos, the user can't have changed the
+ //name and we know that all names are valid in files.
+ if (!culture.m_isInherited) {
+ return true;
+ }
+
+ return VerifyCultureName(culture.Name, throwException);
+
+ }
+
#endregion
}
}
IPrincipal principal;
int principal_version;
- bool current_culture_set;
- bool current_ui_culture_set;
- CultureInfo current_culture;
- CultureInfo current_ui_culture;
// the name of current_thread is
// important because they are used by the runtime.
[ThreadStatic]
static Thread current_thread;
- static internal CultureInfo default_culture;
- static internal CultureInfo default_ui_culture;
-
// can be both a ThreadStart and a ParameterizedThreadStart
private MulticastDelegate m_Delegate;
}
}
- //[MethodImplAttribute (MethodImplOptions.InternalCall)]
- //private static extern int current_lcid ();
-
- public CultureInfo CurrentCulture {
- get {
- CultureInfo culture = current_culture;
- if (current_culture_set && culture != null)
- return culture;
-
- if (default_culture != null)
- return default_culture;
-
- current_culture = culture = CultureInfo.ConstructCurrentCulture ();
- return culture;
- }
-
- [SecurityPermission (SecurityAction.Demand, ControlThread=true)]
- set {
- if (value == null)
- throw new ArgumentNullException ("value");
-
- value.CheckNeutral ();
- current_culture = value;
- current_culture_set = true;
- }
- }
-
- public CultureInfo CurrentUICulture {
- get {
- CultureInfo culture = current_ui_culture;
- if (current_ui_culture_set && culture != null)
- return culture;
-
- if (default_ui_culture != null)
- return default_ui_culture;
-
- current_ui_culture = culture = CultureInfo.ConstructCurrentUICulture ();
- return culture;
- }
-
- set {
- if (value == null)
- throw new ArgumentNullException ("value");
- current_ui_culture = value;
- current_ui_culture_set = true;
- }
- }
-
public bool IsThreadPoolThread {
get {
return IsThreadPoolThreadInternal;
return ManagedThreadId;
}
- internal CultureInfo GetCurrentUICultureNoAppX ()
- {
- return CultureInfo.CurrentUICulture;
- }
-
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern void GetStackTraces (out Thread[] threads, out object[] stack_frames);
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Threading;
+using System.Threading.Tasks;
using NUnit.Framework;
}
[Test]
- public void DefaultThreadCurrentCultureAndNumberFormaters () {
+ public void DefaultThreadCurrentCultureIsIgnoredWhenCultureFlowsToThread ()
+ {
string us_str = null;
string br_str = null;
+
var thread = new Thread (() => {
CultureInfo.DefaultThreadCurrentCulture = new CultureInfo("en-US");
us_str = 100000.ToString ("C");
CultureInfo.DefaultThreadCurrentCulture = new CultureInfo("pt-BR");
br_str = 100000.ToString ("C");
});
+
+ var expected = 100000.ToString ("C");
+
thread.Start ();
thread.Join ();
CultureInfo.DefaultThreadCurrentCulture = null;
- Assert.AreEqual ("$100,000.00", us_str, "#1");
- Assert.AreEqual ("R$ 100.000,00", br_str, "#2");
+ Assert.AreEqual (expected, us_str, "#1");
+ Assert.AreEqual (expected, br_str, "#2");
+ }
+
+ [Test]
+ public void FlowCultureInfoFromParentThreadSinceNet46 ()
+ {
+ Func<Task> f = async () => {
+ Thread.CurrentThread.CurrentUICulture = new CultureInfo ("pt-BR");
+ await Task.Yield ();
+ Assert.AreEqual ("pt-BR", Thread.CurrentThread.CurrentUICulture.Name);
+ };
+
+ f ().Wait ();
}
}
}
dls.Store.SetData(slot, data);
}
-#if !MONO
// #threadCultureInfo
//
}
#if! FEATURE_LEAK_CULTURE_INFO
+
+#if MONO
+ static void nativeInitCultureAccessors()
+ {
+ m_CurrentCulture = CultureInfo.ConstructCurrentCulture ();
+ m_CurrentUICulture = CultureInfo.ConstructCurrentUICulture ();
+ }
+#else
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
private static extern void nativeInitCultureAccessors();
#endif
+#endif
+
+#if !MONO
/*=============================================================*/
projects / mono.git / commitdiff