Chargement des ressources dans l'assemblage importé

Question

J'ai développé pour les applications un programme de planification et un programme d'administration de bibliothèque. L'admnistration de bibliothèque a besoin de certaines des mêmes fonctionnalités dans le programme du planificateur. Il a donc publié le programme du planificateur sur NuGet et l'a installé dans le programme d'administration de libray et utilisé les contrôles utilisateur du logiciel du planificateur ici. Cela fonctionne correctement, sauf que les traductions du planificateur ne sont pas chargées lorsque je l'utilise dans le programme de bibliothèque. Cela fonctionne très bien lorsque j'utilise le programme du planificateur seul.

Dans les deux programmes i ont créé un ResourceDictionary comme celui-ci

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
xmlns:cultures="clr-namespace:LibraryAdministration.Cultures"> 

<!-- Resources ODP contains the current instance of the WPFLocalize.Properties.Resources class. 
    Used in bindings to get localized strings and automatic updates when the culture is updated --> 
<ObjectDataProvider x:Key="Resources" ObjectType="{x:Type cultures:CultureResources}" MethodName="GetResourceInstance"/> 

<!-- CultureResources ODP provides access to list of currently available cultures --> 
<ObjectDataProvider x:Key="CultureResourcesDS" ObjectType="{x:Type cultures:CultureResources}"/> 
<ResourceDictionary.MergedDictionaries> 
    <ResourceDictionary 
      Source="pack://application:,,,/Administration;component/resourcedictionary.xaml" /> 
</ResourceDictionary.MergedDictionaries> 

je charge les ressources dans les deux programmes comme celui-ci

{Binding Path=MainWindow_Title, Source={StaticResource Resources}} 

Ceci est ma culture classe dans les deux applications

public class CultureResources 
{ 
    //only fetch installed cultures once 
    private static bool bFoundInstalledCultures = false; 

    private static List<CultureInfo> pSupportedCultures = new List<CultureInfo>(); 
    /// <summary> 
    /// List of available cultures, enumerated at startup 
    /// </summary> 
    public static List<CultureInfo> SupportedCultures 
    { 
     get { return pSupportedCultures; } 
    } 

    public CultureResources() 
    { 
     if (!bFoundInstalledCultures) 
     { 
      //determine which cultures are available to this application 
      Debug.WriteLine("Get Installed cultures:"); 
      CultureInfo tCulture = new CultureInfo(""); 
      foreach (string dir in Directory.GetDirectories(Application.StartupPath)) 
      { 
       try 
       { 
        //see if this directory corresponds to a valid culture name 
        DirectoryInfo dirinfo = new DirectoryInfo(dir); 
        tCulture = CultureInfo.GetCultureInfo(dirinfo.Name); 

        //determine if a resources dll exists in this directory that matches the executable name 
        if (dirinfo.GetFiles(Path.GetFileNameWithoutExtension(Application.ExecutablePath) + ".resources.dll").Length > 0) 
        { 
         pSupportedCultures.Add(tCulture); 
         Debug.WriteLine(string.Format(" Found Culture: {0} [{1}]", tCulture.DisplayName, tCulture.Name)); 
        } 
       } 
       catch(ArgumentException) //ignore exceptions generated for any unrelated directories in the bin folder 
       { 
       } 
      } 
      bFoundInstalledCultures = true; 
     } 
    } 

    /// <summary> 
    /// The Resources ObjectDataProvider uses this method to get an instance of the WPFLocalize.Properties.Resources class 
    /// </summary> 
    /// <returns></returns> 
    public LibraryAdministration.Cultures.Resources GetResourceInstance() 
    { 

     return new Resources(); 
    } 

    private static ObjectDataProvider m_provider; 
    public static ObjectDataProvider ResourceProvider 
    { 
     get 
     { 
      if (m_provider == null) 
       m_provider = (ObjectDataProvider)App.Current.FindResource("Resources"); 
      return m_provider; 
     } 
    } 

    /// <summary> 
    /// Change the current culture used in the application. 
    /// If the desired culture is available all localized elements are updated. 
    /// </summary> 
    /// <param name="culture">Culture to change to</param> 
    public static void ChangeCulture(CultureInfo culture) 
    { 
     //remain on the current culture if the desired culture cannot be found 
     // - otherwise it would revert to the default resources set, which may or may not be desired. 
     if (pSupportedCultures.Contains(culture)) 
     { 
      Resources.Culture = culture; 
      ResourceProvider.Refresh(); 
     } 
     else 
      Debug.WriteLine(string.Format("Culture [{0}] not available", culture)); 
    } 
} 

}

Je sais que le problème est que les ressources du logiciel de planification ne sont pas initialisés, j'ai essayé de créer un MergedDictionaries dans mon application bibliothèque comme ça avec pas de chance

<ResourceDictionary.MergedDictionaries> 
    <ResourceDictionary 
      Source="pack://application:,,,/Administration;component/resourcedictionary.xaml" /> 
</ResourceDictionary.MergedDictionaries> 

J'espère qu'il y a quelqu'un qui peut m'aider avec ça.

Merci Anders Mikkelsen

Answer 1

Je l'ai résolu en ajoutant un ObjectDataProvider à mon resourceDirectory.xaml dans mon administration de la bibliothèque

<ObjectDataProvider x:Key="CSResources" ObjectType="{x:Type CScultures:CultureResources}" MethodName="GetResourceInstance"/> 

de mon administration schduler

"xmlns:CScultures="clr-namespace:Administration.Cultures;assembly=Administration" 

Je l'ai appelé la clé le même que je fais dans mon administration de planificateur.

Puisqu'il ne peut pas y avoir 2 clés avec la même valeur, je change le nom de ma ressource à CSResource.