Geben Sie einen leeren Standard-DataTemplate anstelle des default 'ToString()' DataTemplate

Den Standard-DataTemplate in einer wpf-Anwendung zeigt das Ergebnis der .ToString() Methode. Ich entwickle eine Anwendung, wo die Standard-DataTemplate sollte nichts anzeigen.

Ich versucht habe:

<Grid.Resources>
  <DataTemplate DataType="{x:Type System:Object}">
   <Grid></Grid>
  </DataTemplate>
</Grid.Resources>

Aber das funktioniert nicht. Wer weiß, ob dies möglich ist, ohne specifiing eine bestimmte DataTemplate für jede Klasse geben, in der Anwendung?

InformationsquelleAutor J W | 2009-04-02

c#datatemplate default wpf

4

Kenne ich keinen Weg, dies zu tun. Als pro Joe ' s Kommentar unten, WPF speziell verbietet die Angabe eines DataTemplate für Typ Object.

Je nach Ihren genauen Anforderungen, kann es einfacher sein, die Suche nach einem DataTemplate entspricht dem spezifischen Typ. Wenn Sie eine finden, verwenden Sie es. Andernfalls wird nichts angezeigt. Zum Beispiel:
```
<ContentControl Content="{Binding YourContent}" ContentTemplateSelector="{StaticResource MyContentTemplateSelector}"/>
```
Und in Ihrem Selektor (pseudo-code, natürlich):
```
var dataTemplateKey = new DataTemplateKey() { DataType = theType; };
var dataTemplate = yourControl.FindResource(dataTemplateKey);

if (dataTemplate != null)
{
    return dataTemplate;
}

return NulloDataTemplate;
```
- "WPF entspricht ein Objekt mit seinen DataTemplate durch exakte Laufzeit-Typ" - Nicht wahr. Wenn Sie fügen Sie ein DataTemplate mit DataType=BaseClass, es passen Unterklasse als gut. Ich habe gesehen, es funktioniert. Leider ist das framework speziell verbietet die Herstellung ein DataTemplate für das System.Objekt, erhalten Sie eine Laufzeit-Fehler "Der Typ "DataTemplateKey' ist fehlgeschlagen Bau. DataTemplate.Datentyp nicht vom Typ Objekt."
- Du hast Recht. Ich war das denken von Stilen, die nicht automatisch vererbt werden. Die Aktualisierung meiner Antwort. Danke.
InformationsquelleAutor Kent Boogaart
4

Wenn Sie mit dem MVVM-Muster und eine abstrakte Klasse, die alle Ihre ViewModel-Klassen ableiten soll, können Sie, dass die Klasse anstelle von System.Objekt:
```
<Grid.Resources>
    <DataTemplate DataType="{x:Type vm:VMBase}">
    </DataTemplate>
</Grid.Resources>
```
- Sie nur mein Leben gerettet. Also, nicht wörtlich natürlich, aber das ist genau das, was ich suchte
InformationsquelleAutor Greg Sansom
3

Ich verwendet, die null-Werte zulässt, arbeitete für meine situation.
```
<DataTemplate DataType="{x:Type sys:Nullable}">

</DataTemplate>
```
InformationsquelleAutor Forss

Ich bin mir nicht sicher über das ersetzen der Standard-DataTemplate, Sie können jedoch einen ValueConverter übergeben display ToString in dem Fall bestimmter Arten und andernfalls eine leere Zeichenfolge. Hier finden Sie den code (beachten Sie, dass die typeb textblock nicht den Konverter auf ihm zu zeigen, was es sieht aus wie normalerweise):

.xaml:

<Window x:Class="EmptyTemplate.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:loc="clr-namespace:EmptyTemplate"
    Title="Window1" Height="300" Width="300">
    <Window.Resources>
        <loc:AType x:Key="atype"/>
        <loc:BType x:Key="btype"/>
        <loc:TypeConverter x:Key="TypeConverter"/>
    </Window.Resources>
    <StackPanel>
        <Button Content="{Binding Source={StaticResource atype}, Converter={StaticResource TypeConverter}}"/>
        <Button Content="{Binding Source={StaticResource btype}, Converter={StaticResource TypeConverter}}"/>
        <TextBlock Text="{Binding Source={StaticResource atype}, Converter={StaticResource TypeConverter}}"/>
        <TextBlock Text="{Binding Source={StaticResource btype}}"/>
    </StackPanel>
</Window>

.xaml.cs:

namespace EmptyTemplate
{
    ///<summary>
    ///Interaction logic for Window1.xaml
    ///</summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }
    }

    public class AType { }

    public class BType { }

    public class TypeConverter : IValueConverter
    {
        public DataTemplate DefaultTemplate { get; set; }

        #region IValueConverter Members

        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            if (value.GetType() == typeof(AType))
            {
                return value.ToString();
            }
            return DefaultTemplate;
        }

        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            throw new NotImplementedException();
        }

        #endregion
    }
}

InformationsquelleAutor Mark Synowiec

Hier ein funktionierendes Beispiel, wie Sie dies über einen Selektor (am besten IMO):

public class EmptyDefaultDataTemplateSelector : DataTemplateSelector
{
    public override DataTemplate SelectTemplate(object item, DependencyObject container)
    {
        if (item != null)
        {
            var dataTemplateKey = new DataTemplateKey(item.GetType());
            var dataTemplate = ((FrameworkElement) container).TryFindResource(dataTemplateKey);
            if (dataTemplate != null)
                return (DataTemplate) dataTemplate;
        }

        return new DataTemplate(); //null does not work
    }
}

InformationsquelleAutor Snicker

Entdeckte ich etwas versehentlich. Ich war mit einer benutzerdefinierten Abhängigkeitseigenschaft Datacontext auf ein Benutzersteuerelement, das hatte ein contentcontrol mit Datatemplates basierend auf Typen(Entitäten in meinem Fall). Da hatte ich verschiedene Arten von Entitäten, die meine benutzerdefinierte Abhängigkeitseigenschaft war

` typeof(object)

War dies das Gerät, die ich verwendet, um zu binden, an den datacontext des ContentControl.

 public object MySelectedItem
    {
        get { return (object)GetValue(Property1Property); }
        set { SetValue(Property1Property, value); }
    }

            public static readonly DependencyProperty Property1Property
        = DependencyProperty.Register(
              "MySelectedItem",
              typeof(object),
              typeof(PromotionsMenu),
              new PropertyMetadata(false)
          );

Wie folgt verwendet:

 MySelectedItem = SomeEntity;

Ich entdeckte, konnte ich es auch so nutzen:

 MySelectedItem = "some text";

Und die contextcontrol drucken würde etwas text als Kontext.

MySelectedItem = "";

arbeitet für eine völlig leere Kontext.

InformationsquelleAutor Jon

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.