Einen Rand von einem verbindlichen

Habe ich einen verbindlichen Wert, liefert einen int, repräsentiert einen Wert, den ich nicht zuordnen linken und rechten Rand eines Elements ein.

Heres, was ich versucht habe, aber es wird nicht kompilieren.

Es funktioniert, wenn ich die gesamte Marge, aber ich will nur Links und rechts.

Xaml:

<Image x:Name="_image" Source="mat.png" Margin="{Binding EditorRow.BondIndent},0,{Binding EditorRow.BondIndent},0" />

Klasse:

public int BondIndent
{
    get { return _bondSequence * 5; }
}

Wie über die Rückkehr einer Thickness statt?
Default, ich habe die Kontrolle über das, was zurückgegeben wird, die von der Klasse hinter sich. Könnten Sie bitte fügen Sie einer Antwort auf die Rückgabe eines Dicke-und ich werde daneben als Antwort
Hinzugefügt eine Antwort statt. HTH

InformationsquelleAutor user589195 | 2013-01-16

binding c#margin wpf xaml

Rückkehr der Marge?

public Thickness Margin
{
    get { return new Thickness(BondIndent,0,BondIndent,0);}
}

Dann ändern:

<Image x:Name="_image" Source="mat.png" Margin="{Binding EditorRow.Margin}" />

InformationsquelleAutor Luuk

13

Werden Sie wahrscheinlich benötigen, um ein ValueConverter für diese. So etwas wie:
```
public class LeftRightThicknessConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        if (value is int)
        {
            int margin = (int)value;
            return Thickness(margin, 0, margin, 0);
        }
        return Thickness();
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}
```
Können Sie dann den Konverter in der folgenden Weise:
```
<Grid>
    <Grid.Resources>
        <xxx:LeftRightThicknessConverter x:Key="LeftRightThicknessConverter" />
    </Grid.Resources>

    <Image Margin="{Binding SomePropertyPath, Converter={StaticResource LeftRightThicknessConverter}}" />
</Grid>
```
Unter der Annahme, dass xxx ist ein gültiges xml-namespace.
- Wie funktioniert die OP-verwenden Sie diese valueconverter?
- Guter Punkt! Hinzugefügt ein kurzes Beispiel.
- Kann die Wert-Konverter werden statische und gespeichert in einer anderen Baugruppe?
- Sie können die definition der converter-Klasse in einer anderen assembly. Aber Sie müssen eine Instanz zugänglich aus dem XAML-Code. In der Regel erstellen Sie eine Instanz wie im obigen Beispiel im Mittel eines Elements (ein UserControl-element zum Beispiel). Sie können definieren, xml-namespaces, die sich auf Ihrer Versammlung (und bestimmten namespace), indem Sie xmlns:xxx="clr-namespace:MyOtherAssembly.TheNamespace;assembly=MyOtherAssembly" den root-Knoten des usercontrol-oder Vorlagen-Kontrolle. Ersetzen xxx dem passenden Namen natürlich.
- Ein Vorschlag wäre, die Nutzung as - operator anstelle von is + cast
- as Betreiber arbeitet nicht mit Wert-Typen wie int.
- Seit der OP ist nicht mit MVVM, ich sehe keinen Grund zu entkoppeln, um diesen Grad. Die Natur seines Eigentums übernimmt der DataContext für die Ansicht, dass Entscheidungen über, wie die Dinge Aussehen sollte... Was bedeutet, eine bessere (einfachere) Lösung wäre einfach, um wieder eine Dicke.
- Das kann gut der Fall sein, aber ich wünschte zu erhalten, die OP-Daten-Modell.
- Vielen Dank für diese odyss - Wäre fein gearbeitet, aber da habe ich die Kontrolle der Rückgabe-Typ aus der Klasse bin ich einfach wieder eine Dicke anstelle eines int. Nützliches Beispiel für mich, wie valueconverter aswell.
InformationsquelleAutor odyss-jii
2

Anstatt eine int Sie zurückgeben kann Dicke, die die Margin eigentlich ist:
```
public Thickness BondIndent
{
    get
    {
        int margin = _bondSequence * 5;
        return new Thickness(margin, 0, margin, 0);
    }
}
```
Den Grund, warum dein Beispiel funktioniert, weil Thickness hat überladene Konstruktoren, nehmen Sie 1, 2 oder 4 Argumente an. Whenthe Konstruktor mit 1 argument aufgerufen wird, werden alle Seiten initialisiert, der Wert. WPF konvertiert dieses automatisch in einen Thickness basierend auf dem bestimmten Wert.

Einem anderen Thema, BondIndent könnte besser genannt werden BondMargin oder BondThickness jetzt.

InformationsquelleAutor Default

Nur schrieb einige angefügte Eigenschaften, die sollten stellen Sie einfach eine einzelne Margin-Wert aus einer Bindung oder statische Ressource:

WPF:

public class Margin
{
    public static readonly DependencyProperty LeftProperty = DependencyProperty.RegisterAttached(
        "Left",
        typeof(double),
        typeof(Margin),
        new PropertyMetadata(0.0, LeftChanged));

    private static void LeftChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var frameworkElement = d as FrameworkElement;
        if (frameworkElement != null)
        {
            Thickness currentMargin = frameworkElement.Margin;
            frameworkElement.Margin = new Thickness((double)e.NewValue, currentMargin.Top, currentMargin.Right, currentMargin.Bottom);
        }
    }

    public static void SetLeft(UIElement element, double value)
    {
        element.SetValue(LeftProperty, value);
    }

    public static double GetLeft(UIElement element)
    {
        return 0;
    }

    public static readonly DependencyProperty TopProperty = DependencyProperty.RegisterAttached(
        "Top",
        typeof(double),
        typeof(Margin),
        new PropertyMetadata(0.0, TopChanged));

    private static void TopChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var frameworkElement = d as FrameworkElement;
        if (frameworkElement != null)
        {
            Thickness currentMargin = frameworkElement.Margin;
            frameworkElement.Margin = new Thickness(currentMargin.Left, (double)e.NewValue, currentMargin.Right, currentMargin.Bottom);
        }
    }

    public static void SetTop(UIElement element, double value)
    {
        element.SetValue(TopProperty, value);
    }

    public static double GetTop(UIElement element)
    {
        return 0;
    }

    public static readonly DependencyProperty RightProperty = DependencyProperty.RegisterAttached(
        "Right",
        typeof(double),
        typeof(Margin),
        new PropertyMetadata(0.0, RightChanged));

    private static void RightChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var frameworkElement = d as FrameworkElement;
        if (frameworkElement != null)
        {
            Thickness currentMargin = frameworkElement.Margin;
            frameworkElement.Margin = new Thickness(currentMargin.Left, currentMargin.Top, (double)e.NewValue, currentMargin.Bottom);
        }
    }

    public static void SetRight(UIElement element, double value)
    {
        element.SetValue(RightProperty, value);
    }

    public static double GetRight(UIElement element)
    {
        return 0;
    }

    public static readonly DependencyProperty BottomProperty = DependencyProperty.RegisterAttached(
        "Bottom",
        typeof(double),
        typeof(Margin),
        new PropertyMetadata(0.0, BottomChanged));

    private static void BottomChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var frameworkElement = d as FrameworkElement;
        if (frameworkElement != null)
        {
            Thickness currentMargin = frameworkElement.Margin;
            frameworkElement.Margin = new Thickness(currentMargin.Left, currentMargin.Top, currentMargin.Right, (double)e.NewValue);
        }
    }

    public static void SetBottom(UIElement element, double value)
    {
        element.SetValue(BottomProperty, value);
    }

    public static double GetBottom(UIElement element)
    {
        return 0;
    }
}

UWP:

public class Margin
{
    public static readonly DependencyProperty LeftProperty = DependencyProperty.RegisterAttached(
        "Left",
        typeof(double),
        typeof(Margin),
        new PropertyMetadata(0.0));

    public static void SetLeft(UIElement element, double value)
    {
        var frameworkElement = element as FrameworkElement;
        if (frameworkElement != null)
        {
            Thickness currentMargin = frameworkElement.Margin;

            frameworkElement.Margin = new Thickness(value, currentMargin.Top, currentMargin.Right, currentMargin.Bottom);
        }
    }

    public static double GetLeft(UIElement element)
    {
        return 0;
    }

    public static readonly DependencyProperty TopProperty = DependencyProperty.RegisterAttached(
        "Top",
        typeof(double),
        typeof(Margin),
        new PropertyMetadata(0.0));

    public static void SetTop(UIElement element, double value)
    {
        var frameworkElement = element as FrameworkElement;
        if (frameworkElement != null)
        {
            Thickness currentMargin = frameworkElement.Margin;

            frameworkElement.Margin = new Thickness(currentMargin.Left, value, currentMargin.Right, currentMargin.Bottom);
        }
    }

    public static double GetTop(UIElement element)
    {
        return 0;
    }

    public static readonly DependencyProperty RightProperty = DependencyProperty.RegisterAttached(
        "Right",
        typeof(double),
        typeof(Margin),
        new PropertyMetadata(0.0));

    public static void SetRight(UIElement element, double value)
    {
        var frameworkElement = element as FrameworkElement;
        if (frameworkElement != null)
        {
            Thickness currentMargin = frameworkElement.Margin;

            frameworkElement.Margin = new Thickness(currentMargin.Left, currentMargin.Top, value, currentMargin.Bottom);
        }
    }

    public static double GetRight(UIElement element)
    {
        return 0;
    }

    public static readonly DependencyProperty BottomProperty = DependencyProperty.RegisterAttached(
        "Bottom",
        typeof(double),
        typeof(Margin),
        new PropertyMetadata(0.0));

    public static void SetBottom(UIElement element, double value)
    {
        var frameworkElement = element as FrameworkElement;
        if (frameworkElement != null)
        {
            Thickness currentMargin = frameworkElement.Margin;

            frameworkElement.Margin = new Thickness(currentMargin.Left, currentMargin.Top, currentMargin.Right, value);
        }
    }

    public static double GetBottom(UIElement element)
    {
        return 0;
    }
}

Verwendung:

<TextBlock Text="Test"
    app:Margin.Top="{Binding MyValue}"
    app:Margin.Right="{StaticResource MyResource}"
    app:Margin.Bottom="20" />

Das schöne daran ist, dass Sie nicht überschreiben die anderen Werte auf dem Rand, so können Sie kombinieren, Sie als gut.

setter und Getter sind nicht direkt aufgerufen. Sie haben, um eine PropertyCallback der DependencyProperty. Ich kann wirklich nicht glauben, dass Sie es getestet 🙂
href="https://msdn.microsoft.com/en-us/library/ms749011(v=vs. 110).aspx" >msdn.microsoft.com/en-us/library/ms749011(v=vs. 110).aspx Blättern Sie nach unten auf "Benutzerdefinierte Angefügte Eigenschaften" -> "Wie erstellen Sie eine angefügte Eigenschaft". Verwenden Sie Namenskonventionen für die getter-und setter-Methoden, und Sie brauchen nicht zu liefern, eine Eigenschaft callback auf die DependencyProperty. Wir haben mit dieser alles-über-unsere-code; es funktioniert.
Blend und Visual Studio-Designer verwenden Sie diese Funktionen, aber WPF nicht. Diese Methoden sind einfach nur interessant zu get/set-Eigenschaften durch den code hinter...aber Sie legen diese Eigenschaften in XAML in Ihrem Beispiel (nicht code-behind). Da WPF ist die Verwaltung der Informationen, sollten Sie nicht mit Logik in die Methoden, neben Einstellung und das abrufen der Informationen.
Ahh, WPF funktioniert ein wenig anders. Hinzugefügt eine version von die angefügte Eigenschaft, das dort arbeitet.
thx für das snippet, es funktioniert gut für UWP

InformationsquelleAutor RandomEngy

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.