ShaderEffect Klasse

Definition

Stellt mithilfe von PixelShader einen benutzerdefinierten Bitmapeffekt bereit.Provides a custom bitmap effect by using a PixelShader.

public ref class ShaderEffect abstract : System::Windows::Media::Effects::Effect
public abstract class ShaderEffect : System.Windows.Media.Effects.Effect
type ShaderEffect = class
    inherit Effect
Public MustInherit Class ShaderEffect
Inherits Effect
Vererbung

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie von der ShaderEffect -Klasse abgeleitet wird.The following code example shows how to derive from the ShaderEffect class.

using System;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Effects;
using System.Reflection;

namespace ShaderEffectDemo
{

    public class ThresholdEffect : ShaderEffect
    {
        private static PixelShader _pixelShader =
            new PixelShader() { UriSource = MakePackUri("ThresholdEffect.fx.ps") };

        public ThresholdEffect()
        {
            PixelShader = _pixelShader;

            UpdateShaderValue(InputProperty);
            UpdateShaderValue(ThresholdProperty);
            UpdateShaderValue(BlankColorProperty);
        }

        // MakePackUri is a utility method for computing a pack uri
        // for the given resource. 
        public static Uri MakePackUri(string relativeFile)
        {
            Assembly a = typeof(ThresholdEffect).Assembly;

            // Extract the short name.
            string assemblyShortName = a.ToString().Split(',')[0];

            string uriString = "pack://application:,,,/" +
                assemblyShortName +
                ";component/" +
                relativeFile;

            return new Uri(uriString);
        }

        ///////////////////////////////////////////////////////////////////////
        #region Input dependency property

        public Brush Input
        {
            get { return (Brush)GetValue(InputProperty); }
            set { SetValue(InputProperty, value); }
        }

        public static readonly DependencyProperty InputProperty =
            ShaderEffect.RegisterPixelShaderSamplerProperty("Input", typeof(ThresholdEffect), 0);

        #endregion

        ///////////////////////////////////////////////////////////////////////
        #region Threshold dependency property

        public double Threshold
        {
            get { return (double)GetValue(ThresholdProperty); }
            set { SetValue(ThresholdProperty, value); }
        }

        public static readonly DependencyProperty ThresholdProperty =
            DependencyProperty.Register("Threshold", typeof(double), typeof(ThresholdEffect),
                    new UIPropertyMetadata(0.5, PixelShaderConstantCallback(0)));

        #endregion

        ///////////////////////////////////////////////////////////////////////
        #region BlankColor dependency property

        public Color BlankColor
        {
            get { return (Color)GetValue(BlankColorProperty); }
            set { SetValue(BlankColorProperty, value); }
        }

        public static readonly DependencyProperty BlankColorProperty =
            DependencyProperty.Register("BlankColor", typeof(Color), typeof(ThresholdEffect),
                    new UIPropertyMetadata(Colors.Transparent, PixelShaderConstantCallback(1)));

        #endregion
    }
}

Das folgende Codebeispiel zeigt einen Shader, der der vorherigen ShaderEffect -Klasse entspricht.The following code example shows a shader that corresponds to the previous ShaderEffect class.

// Threshold shader 

// Object Declarations

sampler2D implicitInput : register(s0);
float threshold : register(c0);
float4 blankColor : register(c1);

//--------------------------------------------------------------------------------------
// Pixel Shader
//--------------------------------------------------------------------------------------
float4 main(float2 uv : TEXCOORD) : COLOR
{
    float4 color = tex2D(implicitInput, uv);
    float intensity = (color.r + color.g + color.b) / 3;
    
    float4 result;
    if (intensity > threshold)
    {
        result = color;
    }
    else
    {
        result = blankColor;
    }
    
    return result;
}

Der folgende XAML-Code zeigt die Verwendung des benutzerdefinierten shadereffekts.The following XAML shows how to use the custom shader effect.

<Window x:Class="ShaderEffectDemo.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:ShaderEffectDemo"
    Title="Window1" Height="300" Width="300">
    <Window.Resources>
        <local:ThresholdEffect x:Key="thresholdEffect" Threshold="0.25" BlankColor="Orange" />
    </Window.Resources>
    
    <Grid Effect="{StaticResource thresholdEffect}">

    </Grid>
</Window>

Hinweise

Leiten Sie von ShaderEffect der-Klasse ab, um eine benutzerdefinierte Auswirkung basierend auf einem einzelnen Pixelshader zu implementieren.Derive from the ShaderEffect class to implement a custom effect based on a single pixel shader.

In den folgenden Schritten wird gezeigt, wie ein benutzerdefinierter Effekt erstellt wird.The following steps show how to create a custom effect.

  1. Laden Sie PixelShader einen aus der vorkompilierten High Level Shading Language (HLSL)-Bytecode.Load a PixelShader from precompiled High Level Shading Language (HLSL) bytecode.

  2. Definieren Sie Abhängigkeits Eigenschaften, die die Parameter des Effekts und Brushder-basierten Oberflächen Eingaben darstellen.Define dependency properties that represent the parameters of the effect and the Brush-based surface inputs. Verwenden Sie eine der RegisterPixelShaderSamplerProperty -über Ladungen, um diese Eingaben mit Register Nummern zuzuordnen, auf die im HLSL-Bytecode verwiesen wird.Use one of the RegisterPixelShaderSamplerProperty overloads to associate these inputs with register numbers that are referenced in the HLSL bytecode.

Die Anzahl der Samplern ist auf 4 beschränkt.The number of samplers is limited to 4.

Die folgenden Einschränkungen gelten, wenn Sie einen PS 3,0-Shader verwenden.The following restrictions apply when using a PS 3.0 shader.

  • Wenn ein PS 3,0-Shader zugewiesen wird, erhöht sich die Anzahl der Samplern auf 8.When a PS 3.0 shader is assigned, the number of samplers increases to 8. Weisen Sie den PS 3,0-Shader vor anderen Shadern zu, um die Registrierung von 8 Samplers zu aktivieren.Assign the PS 3.0 shader before other shaders to enable registering 8 samplers.

  • Das vollständige Registrierungs Limit für Shader von 224 für float-Ausdrücke wird verwendet.The full shader constant register limit of 224 for floats is used. Weitere Informationen finden Sie unter ps_3_0.For more information, see ps_3_0.

  • Die folgenden Datentypen werden nur in PS 3,0-Shadern unterstützt.The following data types are supported in PS 3.0 shaders only. Eine Ausnahme wird ausgelöst, wenn Sie in niedrigeren shaderversionen verwendet werden.An exception is thrown if these are used in lower shader versions.

    • int-und-Typen intkonvertierbar bytein sbyte: long ulong short,,, ,ushort,,, uint``charint and types convertible to int: uint, byte, sbyte, long, ulong, short, ushort, char

    • bool

  • Wenn ein gültiger PS 3,0-Shader auf einem Computer geladen wird, der nicht über eine Hardwareunterstützung für PS 3,0 verfügt, wird der Shader ignoriert.If a valid PS 3.0 shader is loaded on a computer that does not have hardware support for PS 3.0, the shader is ignored. Wenn der Shader ungültig ist, wird keine Ausnahme ausgelöst.If the shader is invalid, no exception is thrown.

  • Wenn ein Computer über mehr als eine Grafikkarte verfügt, wird das Verhalten von der geringstmöglichen Grafikkarte definiert.If a computer has more than one video card, the behavior is defined by the least capable video card. Wenn der Computer z. b. über zwei Videokarten verfügt, von denen eine PS 3,0 unterstützt und von denen eine nicht verwendet wird, ist das Verhalten identisch mit dem Computer, auf dem PS 3,0 nicht unterstützt wird.For example, if the computer has two video cards, one of which supports PS 3.0 and one of which does not, the behavior is the same as if the computer does not support PS 3.0.

  • Wenn ein Computer das Rendern von PS 3,0 in der Hardware unterstützt, aber ein ungültiger PS 3,0 InvalidPixelShaderEncountered -Shader zugewiesen ist, wird das-Ereignis ausgelöst.If a computer supports rendering PS 3.0 in hardware, but an invalid PS 3.0 shader is assigned, the InvalidPixelShaderEncountered event is raised. Ein Beispiel für einen ungültigen PS 3,0-Shader ist eine Kompilierung mit dem ps_3_sw -Flag.An example of an invalid PS 3.0 shader is one compiled with the ps_3_sw flag. Die ShaderEffect Klasse akzeptiert nur PS 3,0-Shader, die mit dem ps_3_0 an FXC. exe über gebenden Flag kompiliert werden.The ShaderEffect class accepts only PS 3.0 shaders that are compiled with the ps_3_0 flag passed to fxc.exe. Weitere Informationen finden Sie unter Effect-Compiler-Tool.For more information, see Effect-Compiler Tool.

Hinweis

PS 2,0-Shader werden beim Rendern in Software ausgeführt.PS 2.0 shaders run when rendering in software. Auch wenn PS 3,0 von der Hardware des Systems unterstützt wird, werden PS 3,0-Shader während des Software Rendering nicht ausgeführt.However, even if PS 3.0 is supported by the system's hardware, PS 3.0 shaders do not run during software rendering.

Konstruktoren

ShaderEffect()

Initialisiert eine neue Instanz der ShaderEffect-Klasse.Initializes a new instance of the ShaderEffect class.

Felder

PixelShaderProperty

Bezeichnet die PixelShader-Abhängigkeitseigenschaft.Identifies the PixelShader dependency property.

Eigenschaften

CanFreeze

Ruft einen Wert ab, der anzeigt, ob das Objekt als nicht änderbar festgelegt werden kann.Gets a value that indicates whether the object can be made unmodifiable.

(Geerbt von Freezable)
DdxUvDdyUvRegisterIndex

Ruft einen Wert ab, der das Shaderregister für die partiellen Ableitungen der Texturkoordinaten bezüglich des Bildraums angibt, oder legt diesen Wert fest.Gets or sets a value that indicates the shader register to use for the partial derivatives of the texture coordinates with respect to screen space.

DependencyObjectType

Ruft den DependencyObjectType ab, der den CLRCLR-Typ dieser Instanz umschließt.Gets the DependencyObjectType that wraps the CLRCLR type of this instance.

(Geerbt von DependencyObject)
Dispatcher

Ruft den Dispatcher ab, der diesem DispatcherObject zugeordnet ist.Gets the Dispatcher this DispatcherObject is associated with.

(Geerbt von DispatcherObject)
EffectMapping

Transformiert beim Überschreiben in einer abgeleiteten Klasse die Mauseingabe und Koordinatensysteme durch den Effekt.When overridden in a derived class, transforms mouse input and coordinate systems through the effect.

(Geerbt von Effect)
HasAnimatedProperties

Ruft einen Wert ab, der angibt, ob einer der Abhängigkeitseigenschaften dieses Objekts ein oder mehrere AnimationClock-Objekte zugeordnet sind.Gets a value that indicates whether one or more AnimationClock objects is associated with any of this object's dependency properties.

(Geerbt von Animatable)
IsFrozen

Ruft einen Wert ab, der angibt, ob das Objekt derzeit geändert werden kann.Gets a value that indicates whether the object is currently modifiable.

(Geerbt von Freezable)
IsSealed

Ruft einen Wert ab, der angibt, ob diese Instanz derzeit versiegelt (schreibgeschützt) ist.Gets a value that indicates whether this instance is currently sealed (read-only).

(Geerbt von DependencyObject)
PaddingBottom

Ruft einen Wert ab, der angibt, dass die Ausgabetextur des Effekts größer als die entsprechende Eingabetextur entlang des unteren Rands ist, oder legt diesen fest.Gets or sets a value indicating that the effect's output texture is larger than its input texture along the bottom edge.

PaddingLeft

Ruft einen Wert ab, der angibt, dass die Ausgabetextur des Effekts größer als die entsprechende Eingabetextur entlang des linken Rands ist, oder legt diesen fest.Gets or sets a value indicating that the effect's output texture is larger than its input texture along the left edge.

PaddingRight

Ruft einen Wert ab, der angibt, dass die Ausgabetextur des Effekts größer als die entsprechende Eingabetextur entlang des rechten Rands ist, oder legt diesen fest.Gets or sets a value indicating that the effect's output texture is larger than its input texture along the right edge.

PaddingTop

Ruft einen Wert ab, der angibt, dass die Ausgabetextur des Effekts größer als die entsprechende Eingabetextur entlang des oberen Rands ist, oder legt diesen fest.Gets or sets a value indicating that the effect's output texture is larger than its input texture along the top edge.

PixelShader

Ruft den für den Effekt zu verwendenden PixelShader ab oder legt diesen fest.Gets or sets the PixelShader to use for the effect.

Methoden

ApplyAnimationClock(DependencyProperty, AnimationClock)

Wendet einen AnimationClock auf die angegebene DependencyProperty an.Applies an AnimationClock to the specified DependencyProperty. Wenn die Eigenschaft bereits animiert wird, wird das SnapshotAndReplace-Übergabeverhalten verwendet.If the property is already animated, the SnapshotAndReplace handoff behavior is used.

(Geerbt von Animatable)
ApplyAnimationClock(DependencyProperty, AnimationClock, HandoffBehavior)

Wendet einen AnimationClock auf die angegebene DependencyProperty an.Applies an AnimationClock to the specified DependencyProperty. Wenn die Eigenschaft bereits animiert wird, wird das angegebene HandoffBehavior verwendet.If the property is already animated, the specified HandoffBehavior is used.

(Geerbt von Animatable)
BeginAnimation(DependencyProperty, AnimationTimeline)

Wendet eine Animation auf die angegebene DependencyProperty an.Applies an animation to the specified DependencyProperty. Die Animation wird gestartet, wenn der nächste Frame gerendert wird.The animation is started when the next frame is rendered. Wenn die angegebene Eigenschaft bereits animiert wird, wird das SnapshotAndReplace-Übergabeverhalten verwendet.If the specified property is already animated, the SnapshotAndReplace handoff behavior is used.

(Geerbt von Animatable)
BeginAnimation(DependencyProperty, AnimationTimeline, HandoffBehavior)

Wendet eine Animation auf die angegebene DependencyProperty an.Applies an animation to the specified DependencyProperty. Die Animation wird gestartet, wenn der nächste Frame gerendert wird.The animation is started when the next frame is rendered. Wenn die angegebene Eigenschaft bereits animiert wird, wird das angegebene HandoffBehavior verwendet.If the specified property is already animated, the specified HandoffBehavior is used.

(Geerbt von Animatable)
CheckAccess()

Bestimmt, ob der aufrufende Thread auf dieses DispatcherObject zugreifen kann.Determines whether the calling thread has access to this DispatcherObject.

(Geerbt von DispatcherObject)
ClearValue(DependencyProperty)

Löscht den lokalen Wert einer Eigenschaft.Clears the local value of a property. Die Eigenschaft, deren Wert gelöscht werden soll, wird durch einen DependencyProperty-Bezeichner angegeben.The property to be cleared is specified by a DependencyProperty identifier.

(Geerbt von DependencyObject)
ClearValue(DependencyPropertyKey)

Löscht den lokalen Wert einer schreibgeschützten Eigenschaft.Clears the local value of a read-only property. Die Eigenschaft, deren Wert gelöscht werden soll, wird durch einen DependencyPropertyKey angegeben.The property to be cleared is specified by a DependencyPropertyKey.

(Geerbt von DependencyObject)
Clone()

Erstellt einen änderbaren Klon des ShaderEffect-Objekts, indem tiefe Kopien der Werte dieses Objekts erzeugt werden.Creates a modifiable clone of this ShaderEffect object, making deep copies of this object's values. Beim Kopieren von Abhängigkeitseigenschaften dieses Objekts kopiert diese Methode Ressourcenverweise und Datenbindungen (die jedoch möglicherweise nicht mehr aufgelöst werden können), jedoch keine Animationen oder ihre aktuellen Werte.When copying this object's dependency properties, this method copies resource references and data bindings (which may no longer resolve), but not animations or their current values.

CloneCore(Freezable)

Definiert die Instanz als Klon (tiefe Kopie) des angegebenen Freezable-Elements, indem Basiseigenschaftenwerte (nicht animiert) verwendet werden.Makes the instance a clone (deep copy) of the specified Freezable using base (non-animated) property values.

CloneCurrentValue()

Erstellt einen änderbaren Klon des ShaderEffect-Objekts, indem tiefe Kopien der aktuellen Werte dieses Objekts erzeugt werden.Creates a modifiable clone of this ShaderEffect object, making deep copies of this object's current values. Ressourcenverweise, Datenbindungen und Animationen werden nicht kopiert, ihre aktuellen Werte werden jedoch kopiert.Resource references, data bindings, and animations are not copied, but their current values are copied.

CloneCurrentValueCore(Freezable)

Macht die Instanz mithilfe aktueller Eigenschaftswerte zu einem Klon (tiefe Kopie) des angegebenen Freezable-Elements, der geändert werden kann.Makes the instance a modifiable clone (deep copy) of the specified Freezable using current property values.

CoerceValue(DependencyProperty)

Erzwingt den Wert der angegebenen Abhängigkeitseigenschaft.Coerces the value of the specified dependency property. Dies erfolgt durch den Aufruf einer beliebigen CoerceValueCallback-Funktion, die in den Metadaten für die Abhängigkeitseigenschaft angegeben ist, während sie beim aufrufenden DependencyObject beendet wird.This is accomplished by invoking any CoerceValueCallback function specified in property metadata for the dependency property as it exists on the calling DependencyObject.

(Geerbt von DependencyObject)
CreateInstance()

Initialisiert eine neue Instanz der Freezable-Klasse.Initializes a new instance of the Freezable class.

(Geerbt von Freezable)
CreateInstanceCore()

Erstellt eine neue Instanz der aus Freezable abgeleiteten Klasse.Creates a new instance of the Freezable derived class.

Equals(Object)

Bestimmt, ob ein angegebenes DependencyObject dem aktuellen DependencyObject entspricht.Determines whether a provided DependencyObject is equivalent to the current DependencyObject.

(Geerbt von DependencyObject)
Freeze()

Definiert das aktuelle Objekt als nicht änderbar und legt seine IsFrozen-Eigenschaft auf true fest.Makes the current object unmodifiable and sets its IsFrozen property to true.

(Geerbt von Freezable)
FreezeCore(Boolean)

Legt dieses Animatable-Objekt als nicht änderbar fest oder bestimmt, ob es als nicht änderbar festgelegt werden kann.Makes this Animatable object unmodifiable or determines whether it can be made unmodifiable.

(Geerbt von Animatable)
GetAnimationBaseValue(DependencyProperty)

Gibt den nicht animierten Wert der angegebenen DependencyProperty zurück.Returns the non-animated value of the specified DependencyProperty.

(Geerbt von Animatable)
GetAsFrozen()

Erstellt eine fixierte Kopie von Freezable mit Basiseigenschaftswerten (nicht animiert).Creates a frozen copy of the Freezable, using base (non-animated) property values. Da die Kopie fixiert ist, werden alle fixierten Unterobjekte als Verweis kopiert.Because the copy is frozen, any frozen sub-objects are copied by reference.

(Geerbt von Freezable)
GetAsFrozenCore(Freezable)

Definiert die Instanz als fixierten Klon des angegebenen Freezable mit Basiseigenschaftswerten (nicht animiert).Makes the instance a frozen clone of the specified Freezable using base (non-animated) property values.

GetCurrentValueAsFrozen()

Erstellt eine fixierte Kopie von Freezable mit aktuellen Eigenschaftswerten.Creates a frozen copy of the Freezable using current property values. Da die Kopie fixiert ist, werden alle fixierten Unterobjekte als Verweis kopiert.Because the copy is frozen, any frozen sub-objects are copied by reference.

(Geerbt von Freezable)
GetCurrentValueAsFrozenCore(Freezable)

Legt die aktuelle Instanz als fixierten Klon des angegebenen Freezable fest.Makes the current instance a frozen clone of the specified Freezable. Wenn das Objekt über animierte Abhängigkeitseigenschaften verfügt, werden die aktuellen animierten Werte kopiert.If the object has animated dependency properties, their current animated values are copied.

GetHashCode()

Ruft einen Hashcode für diese DependencyObject ab.Gets a hash code for this DependencyObject.

(Geerbt von DependencyObject)
GetLocalValueEnumerator()

Erstellt einen spezialisierten Enumerator, mit dem bestimmt wird, welche Abhängigkeitseigenschaften dieses DependencyObject über lokal festgelegte Werte verfügen.Creates a specialized enumerator for determining which dependency properties have locally set values on this DependencyObject.

(Geerbt von DependencyObject)
GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
GetValue(DependencyProperty)

Gibt den aktuellen effektiven Wert einer Abhängigkeitseigenschaft für diese Instanz eines DependencyObject zurück.Returns the current effective value of a dependency property on this instance of a DependencyObject.

(Geerbt von DependencyObject)
InvalidateProperty(DependencyProperty)

Wertet den effektiven Wert für die angegebene Abhängigkeitseigenschaft erneut aus.Re-evaluates the effective value for the specified dependency property.

(Geerbt von DependencyObject)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
OnChanged()

Wird aufgerufen, wenn das aktuelle Freezable-Objekt geändert wird.Called when the current Freezable object is modified.

(Geerbt von Freezable)
OnFreezablePropertyChanged(DependencyObject, DependencyObject)

Stellt sicher, dass entsprechende Kontextzeiger für einen gerade festgelegten DependencyObjectType-Datenmember eingerichtet werden.Ensures that appropriate context pointers are established for a DependencyObjectType data member that has just been set.

(Geerbt von Freezable)
OnFreezablePropertyChanged(DependencyObject, DependencyObject, DependencyProperty)

Dieser Member unterstützt die Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF)-Infrastruktur und ist nicht für die direkte Verwendung im Code vorgesehen.This member supports the Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) infrastructure and is not intended to be used directly from your code.

(Geerbt von Freezable)
OnPropertyChanged(DependencyPropertyChangedEventArgs)

Überschreibt die DependencyObject-Implementierung von OnPropertyChanged(DependencyPropertyChangedEventArgs), damit in Reaktion auf eine geänderte Abhängigkeitseigenschaft des Typs Freezable auch Changed-Handler aufgerufen werden.Overrides the DependencyObject implementation of OnPropertyChanged(DependencyPropertyChangedEventArgs) to also invoke any Changed handlers in response to a changing dependency property of type Freezable.

(Geerbt von Freezable)
PixelShaderConstantCallback(Int32)

Ordnet dem Gleitkommakonstantenregister eines Pixelshaders den Wert einer Abhängigkeitseigenschaft zu.Associates a dependency property value with a pixel shader's float constant register.

PixelShaderSamplerCallback(Int32)

Ordnet dem Samplerregister eines Pixelshaders den Wert einer Abhängigkeitseigenschaft zu.Associates a dependency property value with a pixel shader's sampler register.

PixelShaderSamplerCallback(Int32, SamplingMode)

Ordnet dem Samplerregister eines Pixelshaders und SamplingMode den Wert einer Abhängigkeitseigenschaft zu.Associates a dependency property value with a pixel shader's sampler register and a SamplingMode.

ReadLocalValue(DependencyProperty)

Gibt, sofern vorhanden, den lokalen Wert einer Abhängigkeitseigenschaft zurück.Returns the local value of a dependency property, if it exists.

(Geerbt von DependencyObject)
ReadPreamble()

Stellt sicher, dass über einen gültigen Thread auf Freezable zugegriffen wird.Ensures that the Freezable is being accessed from a valid thread. Vererber von Freezable müssen diese Methode am Anfang jeder API aufrufen, die Datenmember liest, bei denen es sich nicht um Abhängigkeitseigenschaften handelt.Inheritors of Freezable must call this method at the beginning of any API that reads data members that are not dependency properties.

(Geerbt von Freezable)
RegisterPixelShaderSamplerProperty(String, Type, Int32)

Ordnet dem Samplerregister eines Shaders eine Abhängigkeitseigenschaft zu.Associates a dependency property with a shader sampler register.

RegisterPixelShaderSamplerProperty(String, Type, Int32, SamplingMode)

Ordnet einer Abhängigkeitseigenschaft das Samplerregister eines Shaders und einen SamplingMode zu.Associates a dependency property with a shader sampler register and a SamplingMode.

SetCurrentValue(DependencyProperty, Object)

Legt den Wert einer Abhängigkeitseigenschaft fest, ohne die Wertquelle zu ändern.Sets the value of a dependency property without changing its value source.

(Geerbt von DependencyObject)
SetValue(DependencyProperty, Object)

Legt den lokalen Wert einer Abhängigkeitseigenschaft fest, die über ihren Bezeichner angegeben wird.Sets the local value of a dependency property, specified by its dependency property identifier.

(Geerbt von DependencyObject)
SetValue(DependencyPropertyKey, Object)

Legt den lokalen Wert einer schreibgeschützten Abhängigkeitseigenschaft fest, die durch den DependencyPropertyKey-Bezeichner der Abhängigkeitseigenschaft angegeben ist.Sets the local value of a read-only dependency property, specified by the DependencyPropertyKey identifier of the dependency property.

(Geerbt von DependencyObject)
ShouldSerializeProperty(DependencyProperty)

Gibt einen Wert zurück, der angibt, ob Serialisierungsprozesse den Wert der bereitgestellten Abhängigkeitseigenschaft serialisieren sollen.Returns a value that indicates whether serialization processes should serialize the value for the provided dependency property.

(Geerbt von DependencyObject)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Geerbt von Object)
UpdateShaderValue(DependencyProperty)

Benachrichtigt den Effekt darüber, dass die Shaderkonstante oder der Shadersampler, die bzw. der der angegebenen Abhängigkeitseigenschaft entspricht, aktualisiert werden muss.Notifies the effect that the shader constant or sampler corresponding to the specified dependency property should be updated.

VerifyAccess()

Erzwingt, dass der aufrufende Thread auf dieses DispatcherObject zugreifen kann.Enforces that the calling thread has access to this DispatcherObject.

(Geerbt von DispatcherObject)
WritePostscript()

Löst das Changed-Ereignis für das Freezable-Objekt aus und ruft dessen OnChanged()-Methode auf.Raises the Changed event for the Freezable and invokes its OnChanged() method. Klassen, die aus Freezable abgeleitet werden, sollten diese Methode am Ende jeder API aufrufen, die Klassenmember ändert, die nicht als Abhängigkeitseigenschaften gespeichert sind.Classes that derive from Freezable should call this method at the end of any API that modifies class members that are not stored as dependency properties.

(Geerbt von Freezable)
WritePreamble()

Stellt sicher, dass das Freezable nicht fixiert ist und dass über einen gültigen Threadkontext darauf zugegriffen wird.Verifies that the Freezable is not frozen and that it is being accessed from a valid threading context. Vererber von Freezable sollten diese Methode am Anfang jeder API aufrufen, die Datenmember schreibt, bei denen es sich nicht um Abhängigkeitseigenschaften handelt.Freezable inheritors should call this method at the beginning of any API that writes to data members that are not dependency properties.

(Geerbt von Freezable)

Ereignisse

Changed

Tritt auf, wenn Freezable oder ein darin enthaltenes Objekt geändert wird.Occurs when the Freezable or an object it contains is modified.

(Geerbt von Freezable)

Sicherheit

UIPermission
Vollzugriff auf Benutzeroberflächen Ressourcen.for full access to UI resources. Zugehörige Enumeration:AllWindowsAssociated enumeration: AllWindows

Gilt für:

Siehe auch