Evitare gli errori di design Visual Studio quando risorsa WPF è definito in progetto separato

Question

Come posso evitare errori di Visual Studio di design quando una risorsa WPF è definita nel progetto separato?

Ho tre progetti in un'applicazione composita WPF: l'applicazione principale, una biblioteca "infrastruttura" e una biblioteca "modulo". L'applicazione principale fa riferimento agli altri progetti tramite le loro DLL di uscita (i progetti non si trovano in un'unica soluzione insieme).

Sto definendo una pelle (alcuni pennelli e stili in un ResourceDictionary) nella libreria "infrastruttura". Vorrei l'applicazione principale per selezionare una pelle e renderla disponibile per l'intera applicazione (tramite MergedDictionaries in App.xaml).

Nel mio modulo voglio usare le risorse definite nella pelle che il principale applicazione carica. Se mi riferimento alla risorsa come se fosse disponibile a livello locale in questo modo:

Background={StaticResource MainBackgroundBrush}

quasi tutto funziona, se lo desideri. L'eccezione è che progettista di Visual Studio si confonde e mi dice che " 'MainBackgroundBrush' riferimento StaticResource non è stato trovato". Questo mi impedisce di fatto l'utilizzo del progettista.

Che cosa posso fare per definire un ResourceDictionary "pelle" in un progetto, di riferimento che la pelle nel ricorso principale, e quindi utilizzare le proprie risorse in un progetto di modulo?

Answer 1

Una possibile soluzione è quella di utilizzare DynamicResource piuttosto che StaticResource. Il Visual Studio 2008 progettista visualizza semplicemente i controlli senza alcuna styling, come VS2010 beta 1 non quando non si può risolvere un StaticResource.

utilizzando DynamicResource è appropriato in situazioni in cui un particolare stile può cambiare in fase di esecuzione, come quando la scuoiatura.

Ho trovato alcune domande relative a sostegno di questa:

• stili / root a livello Assembly ampio in classe WPF biblioteca
• Qual è la differenza tra StaticResource e DynamicResource in WPF?
• WPF - Dynamic vs statico Risorse

Inoltre ho trovato qualcuno che afferma che DynamicResource deve essere utilizzato ogni volta che una risorsa non è locale:

• Statico vs dinamico Risorse

Answer 2

È possibile creare la propria classe ResourceDictionary, eredita da ResourceDictionary. Poi si può disporre che in fase di progettazione questo carichi ResourceDictionary personalizzato qualche modo esplicito stili definiti (vale a dire quelli caricati dal app in fase di esecuzione), mentre in fase di esecuzione non fa niente per niente. L'IsInDesignMode-proprietà potrebbe essere valutato per questo.

Diciamo che avete un tale classe, chiamato 'DesignTimeResourceDictionary', poi basta usare s.th. come

 <UserControl.Resources>
    <ResourceDictionary>
        <ResourceDictionary.MergedDictionaries>
            <Util:DesignTimeResourceDictionary Source="SomeUriToYourResources"/>
        </ResourceDictionary.MergedDictionaries>
    </ResourceDictionary>
 </UserControl.Resources>

per caricare le risorse in fase di progettazione e fare il lavoro del progettista. In fase di esecuzione si può quindi fare il vostro DesignTimeResourceDictionary saltare il caricamento di risorse e raggiungere il comportamento desiderato.

Se avete bisogno, si potrebbe davvero creare una copia delle risorse reali per questo, oppure si può semplicemente creare un dizionario fittizio che contiene tutti i tasti necessari per mantenere il progettista a lavorare.

Answer 3

Voglio solo di estendere Simon D. risposta. Ciò che egli propone è la soluzione che sto usando in questo momento. Volevo solo condividere il codice sorgente completo. E 'da questo trucco per utilizzare una ResourceDictionary solo quando è in modalità di progettazione fonte.

public class DesignTimeResourceDictionary : ResourceDictionary
{
    /// <summary>
    /// Local field storing info about designtime source.
    /// </summary>
    private string designTimeSource;

    /// <summary>
    /// Gets or sets the design time source.
    /// </summary>
    /// <value>
    /// The design time source.
    /// </value>
    public string DesignTimeSource
    {
        get
        {
            return this.designTimeSource;
        }

        set
        {
            this.designTimeSource = value;
            if ((bool)DesignerProperties.IsInDesignModeProperty.GetMetadata(typeof(DependencyObject)).DefaultValue)
            {
                base.Source = new Uri(designTimeSource);
            }
        }
    }

    /// <summary>
    /// Gets or sets the uniform resource identifier (URI) to load resources from.
    /// </summary>
    /// <returns>The source location of an external resource dictionary. </returns>
    public new Uri Source
    {
        get
        {
            throw new Exception("Use DesignTimeSource instead Source!");
        }

        set
        {
            throw new Exception("Use DesignTimeSource instead Source!");
        }
    }
}

<Window x:Class="WpfApplication1.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation Jump "
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml Jump "
    Title="MainWindow" Height="350" Width="525"
    xmlns:local="clr-namespace:WpfApplication1">

  <Window.Resources>
    <local:DesignTimeResourceDictionary DesignTimeSource="pack://application:,,,/BlueColors.xaml"/>
  </Window.Resources>

    <Grid>
      <Button Background="{DynamicResource defaultBackground}"
      HorizontalAlignment="Center" VerticalAlignment="Center">click me</Button>
    </Grid>
</Window>