Gibt es eine Möglichkeit zu überprüfen, ob WPF derzeit im Entwurfsmodus ausgeführt wird oder nicht?

Kennt jemand einige global state variables, die verfügbar ist, damit ich überprüfen kann, ob der code aktuell ausgeführt wird im design-Modus (z.B. im Blend oder Visual Studio) oder nicht?

Es würde in etwa so Aussehen:

//pseudo code:
if (Application.Current.ExecutingStatus == ExecutingStatus.DesignMode) 
{
    ...
}

Der Grund, warum ich brauchen, ist dies: wenn meine Anwendung im design-Modus in Expression Blend, ich will das ViewModel zu verwenden "Design-Customer-Klasse", die mock-Daten, dass die designer-Ansicht im design-Modus.

Jedoch, wenn die Anwendung tatsächlich ausgeführt wird, ich natürlich will das ViewModel zu verwenden, die realen Kunden-Klasse gibt echte Daten.

Derzeit ich dieses Problem lösen, indem der designer, bevor er ihn bearbeitet, gehen Sie in das ViewModel und ändern "ApplicationDevelopmentMode.Ausführung" "ApplicationDevelopmentMode.Gestaltung":

public CustomersViewModel()
{
    _currentApplicationDevelopmentMode = ApplicationDevelopmentMode.Designing;
}

public ObservableCollection<Customer> GetAll
{
    get
    {
        try
        {
            if (_currentApplicationDevelopmentMode == ApplicationDevelopmentMode.Developing)
            {
                return Customer.GetAll;
            }
            else
            {
                return CustomerDesign.GetAll;
            }
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message);
        }
    }
}

InformationsquelleAutor der Frage Edward Tanguay | 2009-05-07

c#expression-blend wpf

191

Ich glaube, Sie sind auf der Suche für GetIsInDesignModedie eine DependencyObject.

Ie.
```
//'this' is your UI element
DesignerProperties.GetIsInDesignMode(this);
```
Edit: Bei der Verwendung von Silverlight /WP7, sollten Sie IsInDesignTool seit GetIsInDesignMode können manchmal false zurück, während Sie in Visual Studio:
```
DesignerProperties.IsInDesignTool
```
Edit: Und schließlich, im Interesse der Vollständigkeit, der Gegenwert in der WinRT /Metro /Windows-Store-Anwendungen ist DesignModeEnabled:
```
Windows.ApplicationModel.DesignMode.DesignModeEnabled
```
InformationsquelleAutor der Antwort Richard Szalay
95

Können Sie etwas wie das hier tun:
```
DesignerProperties.GetIsInDesignMode(new DependencyObject());
```
InformationsquelleAutor der Antwort Sacha Bruttin
20
```
public static bool InDesignMode()
{
    return !(Application.Current is App);
}
```
Funktioniert von überall. Ich benutze es, um stop-Datenbindung videos von spielen in der designer.

InformationsquelleAutor der Antwort Patrick
8

Wenn Visual Studio automatisch generierten code für mich es verwendet
```
if (!System.ComponentModel.DesignerProperties.GetIsInDesignMode(this)) 
{
    ...
}
```
InformationsquelleAutor der Antwort Darren

- Und wenn Sie nutzen Sie ausgiebig Caliburn.Micro für Ihre großen WPF /Silverlight /WP8 /WinRT Anwendung, die Sie verwenden könnte, handlich und universal caliburn ist Execute.InDesignMode statische Eigenschaft in der view-Modelle als auch (und es funktioniert in der Mischung so gut wie in Visual Studio):

using Caliburn.Micro;

//...

///<summary>
///Default view-model's ctor without parameters.
///</summary>
public SomeViewModel()
{
    if(Execute.InDesignMode)
    {
        //Add fake data for design-time only here:

        //SomeStringItems = new List<string>
        //{
        // "Item 1",
        // "Item 2",
        // "Item 3"
        //};
    }
}

InformationsquelleAutor der Antwort Sevenate

6

Gibt es andere (vielleicht neueren) Methoden zur Angabe von design-time data in WPF, wie genannt werden in diesem Zusammenhang beantworten.

Im wesentlichen, Sie können geben Sie design-time-Daten mit einer design-time-Instanz von der ViewModel:
```
d:DataContext="{d:DesignInstance Type=v:MySampleData, IsDesignTimeCreatable=True}"
```
oder durch die Angabe von Beispiel-Daten, die in einer XAML-Datei:
```
d:DataContext="{d:DesignData Source=../DesignData/SamplePage.xaml}">
```
Müssen Sie die SamplePage.xaml Datei-Eigenschaften:
```
BuildAction:               DesignData
Copy to Output Directory:  Do not copy
Custom Tool:               [DELETE ANYTHING HERE SO THE FIELD IS EMPTY]
```
Stelle ich diese in meinem UserControl tag, wie diesem:
```
<UserControl
    ...
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    ...
    d:DesignWidth="640" d:DesignHeight="480"
    d:DataContext="...">
```
Zur Laufzeit, alle "d:" design-time-tags verschwinden, so werden Sie nur bekommen, Ihre run-time-Daten-Kontext, wie auch immer Sie wählen, um es.

Bearbeiten
Möglicherweise müssen Sie auch diese Zeilen (ich bin mir nicht sicher, aber Sie scheinen relevant):
```
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
mc:Ignorable="d" 
```
InformationsquelleAutor der Antwort cod3monk3y
2

Ich habe nur getestet mit Visual Studio 2013 und .NET 4.5, aber es funktioniert der trick.
```
public static bool IsDesignerContext()
{
  var maybeExpressionUseLayoutRounding =
    Application.Current.Resources["ExpressionUseLayoutRounding"] as bool?;
  return maybeExpressionUseLayoutRounding ?? false;
}
```
Es ist jedoch möglich, dass einige Einstellung in Visual Studio ändern, wird dieser Wert auf false, wenn das jemals passiert, können wir das Ergebnis, um nur zu überprüfen, ob diese Ressource-Namen vorhanden. Es war null wenn ich lief meinen code außerhalb des Designers.

Der Vorteil dieses Ansatzes ist, dass es erfordert keine explizite Kenntnis der spezifischen App Klasse ist und dass Sie weltweit verwendet werden können überall in Ihrem code. Speziell zum Auffüllen von Ansicht-Modellen mit dummy-Daten.

InformationsquelleAutor der Antwort John Leidegren

Habe ich eine Idee für Sie, wenn Sie Ihre Klasse nicht brauchen, einen leeren Konstruktor.

Die Idee ist, erstellen Sie einen leeren Konstruktor, dann markieren Sie Sie mit dem ObsoleteAttribute. Der designer ignoriert das obsolete-Attribut, aber der compiler wird eine Fehlermeldung ausgeben, wenn Sie versuchen, es zu verwenden, so gibt es keine Gefahr, versehentlich mit es selbst.

(pardon my visual basic)

Public Class SomeClass

    <Obsolete("Constructor intended for design mode only", True)>
    Public Sub New()
        DesignMode = True
        If DesignMode Then
            Name = "Paula is Brillant"
        End If
    End Sub

    Public Property DesignMode As Boolean
    Public Property Name As String = "FileNotFound"
End Class

Und xaml:

<UserControl x:Class="TestDesignMode"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
             xmlns:vm="clr-namespace:AssemblyWithViewModels;assembly=AssemblyWithViewModels"
             mc:Ignorable="d" 
             >
  <UserControl.Resources>
    <vm:SomeClass x:Key="myDataContext" />
  </UserControl.Resources>
  <StackPanel>
    <TextBlock d:DataContext="{StaticResource myDataContext}" Text="{Binding DesignMode}" Margin="20"/>
    <TextBlock d:DataContext="{StaticResource myDataContext}" Text="{Binding Name}" Margin="20"/>
  </StackPanel>
</UserControl>

Gibt es eine Möglichkeit zu überprüfen, ob WPF derzeit im Entwurfsmodus ausgeführt wird oder nicht?

Das wird nicht funktionieren, wenn Sie wirklich müssen die leeren Konstruktor für etwas anderes.

InformationsquelleAutor der Antwort DonkeyMaster

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.