async में CurrentCulture रखें/इंतजार

Question

मैं छद्म कोड

string GetData() 
{ 
    var steps = new List<Task<string>> 
    { 
    DoSomeStep(), 
    DoSomeStep2() 
    }; 

    await Task.WhenAll(steps); 

    return SomeResourceManagerProxy.RetrieveValuesForLocalizedStrings(steps.Select(s => s.Result)); 

} 

इस विधि WebService, जहां मैं उपयोगकर्ता के ब्राउज़र सेटिंग्स के अनुसार Thread.CurrentUICulture सेट से कहा जाता है निम्नलिखित है।

प्रतीक्षा के बाद, CurrentUICulture खो गया है (मैं अलग-अलग धागे पर चलता हूं)।

मैं निम्नलिखित के साथ इस मुद्दे को हल किया है:

public class MyAwaiter<T> : INotifyCompletion 
    { 
     private TaskAwaiter<T> waiter; 
     private CultureInfo culture; 

     public MyAwaiter(TaskAwaiter<T> waiter) 
     { 
      this.waiter = waiter; 
     } 

     public PreserveCultureAwaiter<T> GetAwaiter() { return this; } 

     public bool IsCompleted { get { return waiter.IsCompleted; } } 

     public void OnCompleted(Action continuation) 
     { 
      culture = Thread.CurrentThread.CurrentUICulture; 
      waiter.OnCompleted(continuation); 
     } 

     public T GetResult() 
     { 
      Thread.CurrentThread.CurrentUICulture = culture; 
      return waiter.GetResult(); 
     } 
    } 

    public static MyAwaiter<T> KeepCulture<T>(this Task<T> task) 
    { 
     return new MyAwaiter<T>(task.GetAwaiter()); 
    } 

... 

    await Task.WhenAll(steps).KeepCulture(); 

यह एक दोष यह है - पर KeepCulture() कॉल करने के लिए हर कार्य किया जाता है कि समय से प्रतीक्षा की जा रही याद रखने के लिए की जरूरत है। (यूआई संस्कृति को कार्य में रखने के लिए मेरे पास कुछ विस्तार विधि भी है)।

क्या यूआई संस्कृति को संरक्षित करने का कोई आसान तरीका है?

Answer 1

संस्कृति .NET Framework, एक बहुत कुख्यात समस्या में बहती नहीं है। विंडोज़ पर हल करना बहुत मुश्किल है, संस्कृति unmanaged property धागे का है, इसलिए सीएलआर यह सुनिश्चित नहीं कर सकता कि यह हमेशा सही ढंग से सेट हो। यह मुख्य धागे पर एक बड़ी वसा गलती पर CurrentCulture के साथ tinkering बनाता है। आपको मिलने वाली बग का निदान करना बहुत मुश्किल है। एक सॉर्टेडलिस्ट की तरह आप एक थ्रेड पर बनाते हैं जिसे अचानक किसी अन्य पर क्रमबद्ध नहीं किया जाता है। छी।

माइक्रोसॉफ्ट ने .NET 4.5 में इसके बारे में कुछ किया, उन्होंने CultureInfo.DefaultThreadCurrentCulture संपत्ति को जोड़ा। इसके अलावा DefaultThreadCurrentUICulture। यह अभी भी गारंटी नहीं देता है कि यह सही ढंग से सेट किया जाएगा, अप्रबंधित कोड जिसे आप कॉल कर सकते हैं उसे बदल सकते हैं और सीएलआर इसके बारे में कुछ भी नहीं कर सकता है। दूसरे शब्दों में, निदान करने के लिए एक बग बहुत कठिन होगा। लेकिन कम से कम आपके पास कुछ विचार हो सकता है जब यह बदल सकता है।

---

अद्यतन: इस समस्या को नेट 4.6 में अच्छी तरह से तय किया गया था, संस्कृति अब एक थ्रेड से दूसरे में बहती है और CultureInfo.DefaultThreadCurrentCulture हैक लंबे समय तक आवश्यक है और न ही उपयोगी नहीं है। CultureInfo.CurrentCulture के लिए एमएसडीएन आलेख में दस्तावेज। जैसा कि अभी लिखा गया है, पूरी तरह से सही नहीं दिखता है, जब मैंने इसका परीक्षण किया तो यह हमेशा बहता था और डिफॉल्ट थ्रेड कंटेंटकल्चर अब और कोई भूमिका निभाता प्रतीत होता है।

Answer 2

अब तक मैं अपने खुद के SynchronizationContext, जो मैं दोनों ASP.NET और सांत्वना अनुप्रयोगों के साथ परीक्षण किया है बना लिया है, और दोनों में यह संस्कृति रहता है मैं इसे चाहते हैं:

/// <summary> 
/// Class that captures current thread's culture, and is able to reapply it to different one 
/// </summary> 
internal sealed class ThreadCultureHolder 
{ 
    private readonly CultureInfo threadCulture; 
    private readonly CultureInfo threadUiCulture; 

    /// <summary> 
    /// Captures culture from currently running thread 
    /// </summary> 
    public ThreadCultureHolder() 
    { 
     threadCulture = Thread.CurrentThread.CurrentCulture; 
     threadUiCulture = Thread.CurrentThread.CurrentUICulture; 
    } 

    /// <summary> 
    /// Applies stored thread culture to current thread 
    /// </summary> 
    public void ApplyCulture() 
    { 
     Thread.CurrentThread.CurrentCulture = threadCulture; 
     Thread.CurrentThread.CurrentUICulture = threadUiCulture; 
    } 

    public override string ToString() 
    { 
     return string.Format("{0}, UI: {1}", threadCulture.Name, threadUiCulture.Name); 
    } 
} 

/// <summary> 
/// SynchronizationContext that passes around current thread's culture 
/// </summary> 
internal class CultureAwareSynchronizationContext : SynchronizationContext 
{ 
    private readonly ThreadCultureHolder cultureHolder; 
    private readonly SynchronizationContext synchronizationImplementation; 

    /// <summary> 
    /// Creates default SynchronizationContext, using current(previous) SynchronizationContext 
    /// and captures culture information from currently running thread 
    /// </summary> 
    public CultureAwareSynchronizationContext() 
     : this(Current) 
    {} 

    /// <summary> 
    /// Uses passed SynchronizationContext (or null, in that case creates new empty SynchronizationContext) 
    /// and captures culture information from currently running thread 
    /// </summary> 
    /// <param name="previous"></param> 
    public CultureAwareSynchronizationContext(SynchronizationContext previous) 
     : this(new ThreadCultureHolder(), previous) 
    { 
    } 

    internal CultureAwareSynchronizationContext(ThreadCultureHolder currentCultureHolder, SynchronizationContext currentSynchronizationContext) 
    { 
     cultureHolder = currentCultureHolder; 
     synchronizationImplementation = currentSynchronizationContext ?? new SynchronizationContext(); 
    } 

    public override void Send(SendOrPostCallback d, object state) 
    { 
     cultureHolder.ApplyCulture(); 
     synchronizationImplementation.Send(d, state); 
    } 

    public override void Post(SendOrPostCallback d, object state) 
    { 
     synchronizationImplementation.Post(passedState => 
     { 
      SetSynchronizationContext(this); 
      cultureHolder.ApplyCulture(); 
      d.Invoke(s); 
     }, state); 
    } 

    public override SynchronizationContext CreateCopy() 
    { 
     return new CultureAwareSynchronizationContext(cultureHolder, synchronizationImplementation.CreateCopy()); 
    } 

    public override string ToString() 
    { 
     return string.Format("CultureAwareSynchronizationContext: {0}", cultureHolder); 
    } 
} 

उपयोग:

/// code that detects Browser's culture 
void Detection() 
{ 
     Thread.CurrentThread.CurrentUICulture = new CultureInfo("cs"); 
     SynchronizationContext.SetSynchronizationContext(new CultureAwareSynchronizationContext()); 
} 

यह समाधान संभव issues mentioned by Hans Passant से पीड़ित है।