The Architect
aka "DotNetMastermind"

WPF Login UserControl ähnlich wie die Windows 8 Anmeldemaske

Auf der CodeProject Website habe ich kürzlich einen Artikel veröffentlicht, welcher die Implementierung eines interessanten WPF Benutzersteuerelementes detalliert beschreibt. Dieses WPF Benutzersteuerelement (WPF Control) kann sehr einfach als Login-Overlay für eigene WPF-Anwendungen (ab. NET 3.5) verwendet werden. Es ähnelt der Windows 8 Anmeldemaske sehr und verhält sich auch nahezu identisch wie die Windows 8 Anmeldemaske.

Hier sind einige Screenshots des Benutzersteuerelementes :

Der vollständige Artikel ist verfügbar unter : http://www.codeproject.com/Articles/498253/Smart-WPF-Login-Overlay-Windows-8-Style (nur in Englisch)

Der Quellcode sowie eine Demo können unter dem angegebenen Link auch heruntergeladen werden. In der Demo ist ein Beispiel enthalten, wie das Benutzersteuerelement für eine "deutsche" Anwendung angepasst werden kann (siehe auch die obigen Screenshots).

EDIT : Bei dem UserControl mit den deutschen Texten muss folgende Eigenschaft noch gesetzt werden FullSpan="On" (hatte ich versäumt … sorry). Und nicht wundern, dass das UserControl Transparent ist : Dies habe ich bewusst so implementiert, um zu zeigen, dass die Hintergrundfarbe des Root Fensters automatisch adaptiert wird, wenn auf dem UserControl keine Hintergrundfarbe gesetzt wurde.

Improved Windows 8 PasswordBox Style for WPF

Regarding to the following blog post http://dotnet-forum.de/blogs/thearchitect/archive/2012/11/06/windows-8-passwordbox-style-for-wpf.aspx i have furthermore improved the PasswordBox Style to look more similar to the Windows 8 PasswordBox. And again I did not use the VisualStateManager Class, so it is possible to use this style also with the .Net Framework 3.0 / 3.5 (and not only with the .Net Framework 4.0).

Here is how it looks like now :

This is the new corresponding style (Win8PasswordBoxStyle) :

<Style x:Key="Win8PasswordBoxStyle" TargetType="{x:Type PasswordBox}" BasedOn="{StaticResource {x:Type PasswordBox}}">

    <Setter Property="Foreground" Value="{StaticResource {x:Static SystemColors.ControlTextBrushKey}}"/>

    <Setter Property="Background" Value="{StaticResource {x:Static SystemColors.WindowBrushKey}}"/>

    <Setter Property="BorderBrush" Value="{StaticResource TextBoxBorder}"/>

    <Setter Property="FontFamily" Value="Times New Roman"/>

    <Setter Property="PasswordChar" Value="●"/>

    <Setter Property="KeyboardNavigation.TabNavigation" Value="None"/>

    <Setter Property="BorderThickness" Value="1"/>

    <Setter Property="HorizontalContentAlignment" Value="Left"/>

    <Setter Property="VerticalContentAlignment" Value="Center"/>

    <Setter Property="Padding" Value="1"/>

    <Setter Property="FocusVisualStyle" Value="{x:Null}"/>

    <Setter Property="AllowDrop" Value="true"/>

    <Setter Property="Template">

        <Setter.Value>

            <ControlTemplate TargetType="{x:Type PasswordBox}">

                <Border x:Name="OuterBorder"

                          BorderBrush="{TemplateBinding BorderBrush}"

                          BorderThickness="{TemplateBinding BorderThickness}"

                          Background="{TemplateBinding Background}"

                          SnapsToDevicePixels="true">

                    <Grid VerticalAlignment="Center">

                        <Grid.ColumnDefinitions>

                            <ColumnDefinition />

                            <ColumnDefinition Width="Auto" />

                        </Grid.ColumnDefinitions>

                        <ScrollViewer x:Name="PART_ContentHost" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />

                        <TextBox x:Name="RevealedPassword"

                                    Text="{TemplateBinding ap:PasswordBoxBinding.Password}"

                                    VerticalAlignment="{TemplateBinding VerticalContentAlignment}"

                                    VerticalContentAlignment="Center"

                                    Padding="{TemplateBinding Padding}"

                                    Margin="{TemplateBinding Padding}"

                                    Background="{TemplateBinding Background}"

                                    Visibility="Hidden" BorderThickness="0" IsReadOnly="True" FontFamily="Segoe UI" />

                        <TextBlock x:Name="TextBoxHint"

                                      Text="Enter password"

                                      Padding="{TemplateBinding Padding}"

                                      Background="Transparent"

                                      Cursor="IBeam" Margin="2" FontFamily="Segoe UI" Foreground="#FFB5B5B5"

                                      VerticalAlignment="{TemplateBinding VerticalContentAlignment}"

                                  Visibility="{Binding ElementName=RevealedPassword, Path=Text, Converter={StaticResource StringToOppositeVisibilityConverter}}" />

                        <Button x:Name="RevealButton"

                                  Grid.Column="1" SnapsToDevicePixels="True"

                                  Style="{StaticResource RevealButtonStyle}"

                              Visibility="{Binding ElementName=RevealedPassword, Path=Text, Converter={StaticResource StringToVisibilityConverter}}">

                        </Button>

                    </Grid>

                </Border>

                <ControlTemplate.Triggers>

                    <Trigger Property="IsEnabled" Value="false">

                    <Setter Property="Background" TargetName="OuterBorder" Value="{StaticResource {x:Static SystemColors.ControlBrushKey}}" />

                        <Setter Property="Foreground" Value="{StaticResource {x:Static SystemColors.GrayTextBrushKey}}" />

                        <Setter Property="Opacity" TargetName="RevealButton" Value="0.5" />

                        <Setter Property="Text" TargetName="TextBoxHint" Value="{}{disabled} "/>

                    </Trigger>

                    <DataTrigger Binding="{Binding ElementName=RevealButton, Path=IsPressed}" Value="True">

                        <Setter TargetName="RevealedPassword" Property="Visibility" Value="Visible" />

                    </DataTrigger>

                </ControlTemplate.Triggers>

            </ControlTemplate>

        </Setter.Value>

    </Setter>

</Style>

… and this is the corresponding RevealButton-Style :

<Style x:Key="RevealButtonStyle" TargetType="{x:Type Button}">

    <Setter Property="Template">

        <Setter.Value>

            <ControlTemplate TargetType="{x:Type Button}">

                <Grid>

                    <Border x:Name="PasswordRevealGlyphBorder" Background="Transparent" Margin="1,1,3,1"

                                BorderThickness="{TemplateBinding BorderThickness}">

                        <TextBlock x:Name="GlyphElement" Foreground="Black" VerticalAlignment="Center" HorizontalAlignment="Center"

                                        Text="&#xE052;" FontFamily="Segoe UI Symbol" Margin="3,0"

                                        FontSize="{TemplateBinding FontSize}" />

                    </Border>

                </Grid>

                <ControlTemplate.Triggers>

                    <DataTrigger Binding="{Binding ElementName=GlyphElement, Path=IsMouseOver}" Value="True">

                        <Setter TargetName="PasswordRevealGlyphBorder" Property="Background" Value="Gainsboro" />

                    </DataTrigger>

                    <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsPressed}" Value="True">

                        <Setter TargetName="PasswordRevealGlyphBorder" Property="Background" Value="Black" />

                        <Setter TargetName="GlyphElement" Property="Foreground" Value="White" />

                    </DataTrigger>

                </ControlTemplate.Triggers>

            </ControlTemplate>

        </Setter.Value>

    </Setter>

</Style>

 

Windows 8 PasswordBox Style for WPF

EDIT : Check out the improved style here http://dotnet-forum.de/blogs/thearchitect/archive/2012/11/13/improved-windows-8-passwordbox-style-for-wpf.aspx

For everybody who is interested in a PasswordBox similar to the Windows 8 Login PasswordBox I have implemented a XAML-Style (available for WPF-Applications).

Here is how it looks like :

This is the corresponding style :

<Style x:Key="SmartPasswordBoxStyle" TargetType="{x:Type PasswordBox}" BasedOn="{StaticResource {x:Type PasswordBox}}">

    <Setter Property="Foreground" Value="{StaticResource {x:Static SystemColors.ControlTextBrushKey}}"/>

    <Setter Property="Background" Value="{StaticResource {x:Static SystemColors.WindowBrushKey}}"/>

    <Setter Property="BorderBrush" Value="{StaticResource TextBoxBorder}"/>

    <Setter Property="FontFamily" Value="Times New Roman"/>

    <Setter Property="PasswordChar" Value="●"/>

    <Setter Property="KeyboardNavigation.TabNavigation" Value="None"/>

    <Setter Property="BorderThickness" Value="1"/>

    <Setter Property="HorizontalContentAlignment" Value="Left"/>

    <Setter Property="VerticalContentAlignment" Value="Center"/>

    <Setter Property="Padding" Value="1"/>

    <Setter Property="FocusVisualStyle" Value="{x:Null}"/>

    <Setter Property="AllowDrop" Value="true"/>

    <Setter Property="Template">

        <Setter.Value>

            <ControlTemplate TargetType="{x:Type PasswordBox}">

                <Border x:Name="OuterBorder"

                          BorderBrush="{TemplateBinding BorderBrush}"

                          BorderThickness="{TemplateBinding BorderThickness}"

                          Background="{TemplateBinding Background}"

                          SnapsToDevicePixels="true">

                    <Grid VerticalAlignment="Center">

                        <Grid.ColumnDefinitions>

                            <ColumnDefinition />

                            <ColumnDefinition Width="Auto" />

                        </Grid.ColumnDefinitions>

                        <ScrollViewer x:Name="PART_ContentHost" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />

                        <TextBox x:Name="RevealedPassword"

                                    Text="{TemplateBinding ap:PasswordBoxBinding.Password}"

                                    VerticalAlignment="{TemplateBinding VerticalContentAlignment}"

                                    VerticalContentAlignment="Center"

                                    Padding="{TemplateBinding Padding}"

                                    Margin="{TemplateBinding Padding}"

                                    Background="{TemplateBinding Background}"

                                    Visibility="Hidden" BorderThickness="0" IsReadOnly="True" FontFamily="Segoe UI" />

                        <TextBlock x:Name="TextBoxHint"

                                      Text="Enter password"

                                      Padding="{TemplateBinding Padding}"

                                      Background="Transparent"

                                      Cursor="IBeam" Margin="2" FontFamily="Segoe UI" Foreground="#FFB5B5B5"

                                      VerticalAlignment="{TemplateBinding VerticalContentAlignment}"

                                      Visibility="{Binding ElementName=RevealedPassword, Path=Text,

                                                    Converter={StaticResource StringToOppositeVisibilityConverter}}" />

                        <Border x:Name="PasswordRevealImageBorder" Grid.Column="1" Margin="0,1,3,1"

                              Visibility="{Binding ElementName=RevealedPassword, Path=Text, Converter={StaticResource StringToVisibilityConverter}}">

                            <Image x:Name="PasswordRevealImage"

                                     Source="../../CommonImages/PasswordEyeBlack.png" Margin="2" />

                        </Border>

                    </Grid>

                </Border>

                <ControlTemplate.Triggers>

                    <Trigger Property="IsEnabled" Value="false">

                    <Setter Property="Background" TargetName="OuterBorder" Value="{StaticResource {x:Static SystemColors.ControlBrushKey}}"/>

                        <Setter Property="Foreground" Value="{StaticResource {x:Static SystemColors.GrayTextBrushKey}}"/>

                        <Setter Property="Opacity" TargetName="PasswordRevealImageBorder" Value="0.5"/>

                        <Setter Property="Text" TargetName="TextBoxHint" Value="{}{disabled}"/>

                    </Trigger>

                    <DataTrigger Binding="{Binding ElementName=PasswordRevealImage, Path=IsMouseOver}" Value="True">

                        <Setter TargetName="PasswordRevealImageBorder" Property="Background" Value="Gainsboro" />

                    </DataTrigger>

                    <EventTrigger RoutedEvent="Image.MouseDown" SourceName="PasswordRevealImage">

                        <BeginStoryboard Storyboard="{StaticResource ShowPassword}"/>

                    </EventTrigger>

                    <EventTrigger RoutedEvent="Image.MouseUp" SourceName="PasswordRevealImage">

                        <BeginStoryboard Storyboard="{StaticResource HidePasswordAndChangeBorderColor}"/>

                    </EventTrigger>

                    <EventTrigger RoutedEvent="Image.MouseLeave" SourceName="PasswordRevealImage">

                        <BeginStoryboard Storyboard="{StaticResource HidePassword}"/>

                    </EventTrigger>

                </ControlTemplate.Triggers>

            </ControlTemplate>

        </Setter.Value>

    </Setter>

</Style>

As you can see you need a special AttachedProperty, some custom Storyboards an some Converters. So you have to reference the WPFSmartLibraryLight to make this working.

To give you an insight into the power of the WPFSmartLibrary I have put a link to a sample application at the end of this post including the demonstration of many cool functions. It is about a smart login dialog with almost no code behind (100% MVVM).

This sample application gives you a good overview to the following topics :

Login functionality with smart animations without code behind, except the following (needed) code behind :

    InitializeComponent();

    this.ViewModel = new LoginViewModel();

    this.DataContext = this.ViewModel;

=> Also no code behind for the animation needed (solved with AttachedProperties)

• SmartButtons
• SmartBackgroundBrushes
• WindowKeysHandling
• TextBoxBaseManager
• PasswordBoxManager
• BoolToBrushConverter
• BoolToVisibilityConverter
• TextBoxBaseAnimation
• VisibilityAnimation
• PasswordBoxBinding
• Validation Templates
• and this everything in one small demo …

Die optimale Implementierung des INotifyPropertyChanged - Interfaces

Es existieren viele unterschiedliche Implementierungen des INotifyPropertyChanged - Interfaces.

Ausgehend von der allgemein bekannten Standard-Implementierung werden in diesem Beitrag die gängigsten Implementierungen analysiert sowie die Vor- und Nachteile aufgelistet. Zusätzlich wird eine eigene Implementierung, welche bereits in diversen größeren dotNet-Projekten verwendet wurde, vorgestellt. Außerdem kann am Ende des Beitrages eine ViewModelBase-Klasse (C#-Datei welche alle Implementierungen enthält) heruntergeladen werden. Diese darf darüber hinaus auch in eigenen Projekten verwendet werden.

[1] Die Verwendung der typischen Standard-Implementierung

public string someProperty;
public string SomeProperty
{
    get { return someProperty; }
    set
    {
        if (someProperty != value)
        {
            someProperty = value;
            RaisePropertyChangedEvent( "SomeProperty" );
        }
    }
}

Nachteile

1. Der übergebene String-Parameter wird bei der Eingabe nicht überprüft wird und man kann sich somit unbemerkt vertippen => mögliche Fehlerquelle
2. Bei einer Änderung des Bezeichners könnte man vergessen den String-Parameter mit anzupassen, dies würde auch unbemerkt bleiben => mögliche Fehlerquelle
3. Es muss immer ein extra Feld als "Datenspeicher" implementiert werden
4. Das PropertyChanged-Event muss manuell gefeuert werden

[2] Die Verwendung einer verbesserten Standard-Implementierung

Hierbei wird zusätzlich überprüft, ob eine Eigenschaft mit der Bezeichnung des übergebenen String-Parameters existiert :

[Conditional( "DEBUG" )]

private void checkPropertyName(string propertyName)

{

    PropertyDescriptor propertyDescriptor = TypeDescriptor.GetProperties( this )[propertyName];

    if (propertyDescriptor == null)

    {

        string message = string.Format( null, "The property with the propertyName '{0}' doesn't exist.", propertyName );

        Debug.Fail( message );

    }

}

Nachteile

1. Alle Nachteile der Standardlösung, jedoch mit kleinen Unterschied, dass beim Debuggen festgestellt werden kann, ob eine Eigenschaft mit dem übergebenen Bezeichner auch wirklich existiert

[3] Die Verwendung einer nochmals verbesserten Standard-Implementierung

Hierbei wird der Parameter als Lambda-Expression übergeben :

public string someProperty;

public string SomeProperty

{

    get { return someProperty; }

    set

    {

        if (someProperty != value)

        {

            someProperty = value;

            RaisePropertyChangedEvent( () => SomeProperty );

        }

    }

}

Vorteile

1. Die in den ersten beiden Implementierungen genannten Nachteile als mögliche Fehlerquellen fallen nun weg, weil der Bezeichner in der Lambda Expression eine existierende Eigenschaft sein muss, da ansonsten die IDE (Visual Studio) bzw. spätestens der Compiler feststellen würde, dass eine Eigenschaft mit diesem Bezeichner nicht existiert
2. Bei einer Änderung des Bezeichners und der automatischen Änderung durch die IDE (Visual Studio) wird der Parameter auch mit angepasst

Nachteile

1. Es muss immer ein extra Feld als "Datenspeicher" implementiert werden
2. Das PropertyChanged-Event muss manuell gefeuert werden

[4] Die Verwendung einer optimalen Standard-Implementierung

Hierbei wird das Event ohne der Übergabe eines Parameters gefeuert (identisch zu der Vorgehensweise im dotNet-Framework 4.5 bzw. C# 5.0) :

public string someProperty;

public string SomeProperty

{

    get { return someProperty; }

    set

    {

        if (someProperty != value)

        {

            someProperty = value;

            RaisePropertyChangedEvent();

        }

    }

}

Implementierung

protected void RaisePropertyChangedEvent()

{

    // Get the call stack

    StackTrace stackTrace = new StackTrace();

    // Get the calling method name

    string callingMethodName = stackTrace.GetFrame( 1 ).GetMethod().Name;

    // Check if the callingMethodName contains an underscore like in "set_SomeProperty"

    if (callingMethodName.Contains( "_" ))

    {

        // Extract the property name

        string propertyName = callingMethodName.Split( '_' )[1];

        if (this.PropertyChanged != null && propertyName != String.Empty)

        {

            this.PropertyChanged( this, new PropertyChangedEventArgs( propertyName ) );

        }

    }

}

Vorteile

1. Die in den ersten beiden Implementierungen genannten Nachteile als mögliche Fehlerquellen fallen nun weg, da kein Parameter mehr übergeben werden muss
2. Eine Änderung des Bezeichners wirkt sich auch nicht problematisch aus, da wie gesagt kein Parameter übergeben wird

Nachteile

[5] Die (meiner Meinung nach) optimale Implementierung

Hierbei wird jede Property auf die gleiche Weise, wie die zu den DependencyProperties gehörenden CLR-Wrapper implementiert. Bei den (zu den DependencyProperties) gehörenden CLR-Wrappern wird durch die Verwendung der Methoden GetValue bzw. SetValue das Property-System des .NET-Frameworks aktiv und führt diverse Evaluierungen im Hintergrund durch. Eine identische Vorgehensweise habe ich für eine optimale Implementierung des INotifyPropertyChanged-Interfaces verwendet.

Die Verwendung

public string SomeProperty

{

    get { return GetValue( () => SomeProperty ); }

    set { SetValue( () => SomeProperty, value ); }

}

Vorteile

1. Die in den ersten beiden Standard-Implementierungen genannten Nachteile als mögliche Fehlerquellen fallen nun weg, weil der Bezeichner in der Lambda Expression eine existierende Eigenschaft sein muss, da ansonsten die IDE (Visual Studio) bzw. spätestens der Compiler feststellen würde, dass eine Eigenschaft mit diesem Bezeichner nicht existiert
2. Bei einer Änderung des Bezeichners und der automatischen Änderung durch die IDE (Visual Studio) wird der Parameter auch mit angepasst
3. Ein extra Feld als "Datenspeicher" muss nicht mehr implementiert werden, da die Werte der einzelnen Eigenschaften automatische in einem Dictionary der ViewModelBase-Klasse verwaltet werden
4. Das Event muss nicht mehr manuell gefeuert werden, da dieses automatisch in der SetValue-Methode der ViewModelBase-Klasse erfolgt
5. Im Gegensatz zu den DependencyProperties des .NET-Frameworks muss der Rückgabewert der GetValue-Methode nicht mehr gecastet werden, da der Rückgabewert typensicher aus der Lambda-Expression ermittelt wird

Nachteile

1. KEINE

Da die (meiner Ansicht nach) optimale Implementierung ähnlich der Implementierung von DependencyProperties funktioniert, ist eine noch bessere Konsistenz in der Code Basis gewährleistet.

Implementierung

public abstract class ViewModelBase : INotifyPropertyChanged

{

    #region < INotifyPropertyChanged > Members

    /// <summary>

    /// Is connected to a method which handle changes to a property (located in the WPF Data Binding Engine)

    /// </summary>

    public event PropertyChangedEventHandler PropertyChanged;

    /// <summary>

    /// Raise the [PropertyChanged] event

    /// </summary>

    /// <param name="propertyName">The name of the property</param>

    protected void OnPropertyChanged(string propertyName)

    {

        if (this.PropertyChanged != null)

        {

            this.PropertyChanged( this, new PropertyChangedEventArgs( propertyName ) );

        }

    }

    #endregion

    private Dictionary<string, object> propertyValueStorage;

    #region Constructor

    public ViewModelBase()

    {

        this.propertyValueStorage = new Dictionary<string, object>();

    }

    #endregion

    /// <summary>

    /// Set the value of the property and raise the [PropertyChanged] event

    /// (only if the saved value and the new value are not equal)

    /// </summary>

    /// <typeparam name="T">The property type</typeparam>

    /// <param name="property">The property as a lambda expression</param>

    /// <param name="value">The new value of the property</param>

    protected void SetValue<T>(Expression<Func<T>> property, T value)

    {

        LambdaExpression lambdaExpression = property as LambdaExpression;

        if (lambdaExpression == null)

        {

            throw new ArgumentException( "Invalid lambda expression", "Lambda expression return value can't be null" );

        }

        string propertyName = this.getPropertyName( lambdaExpression );

        T storedValue = this.getValue<T>( propertyName );

        if (!object.Equals( storedValue, value ))

        {

            this.propertyValueStorage[propertyName] = value;

            this.OnPropertyChanged( propertyName );

        }

    }

    /// <summary>

    /// Get the value of the property

    /// </summary>

    /// <typeparam name="T">The property type</typeparam>

    /// <param name="property">The property as a lambda expression</param>

    /// <returns>The value of the given property (or the default value)</returns>

    protected T GetValue<T>(Expression<Func<T>> property)

    {

        LambdaExpression lambdaExpression = property as LambdaExpression;

        if (lambdaExpression == null)

        {

            throw new ArgumentException( "Invalid lambda expression", "Lambda expression return value can't be null" );

        }

        string propertyName = this.getPropertyName( lambdaExpression );

        return getValue<T>( propertyName );

    }

    /// <summary>

    /// Try to get the value from the internal dictionary of the given property name

    /// </summary>

    /// <typeparam name="T">The property type</typeparam>

    /// <param name="propertyName">The name of the property</param>

    /// <returns>Retrieve the value from the internal dictionary</returns>

    private T getValue<T>(string propertyName)

    {

        object value;

        if (propertyValueStorage.TryGetValue( propertyName, out value ))

        {

            return (T)value;

        }

        else

        {

            return default( T );

        }

    }

    /// <summary>

    /// Extract the property name from a lambda expression

    /// </summary>

    /// <param name="lambdaExpression">The lambda expression with the property</param>

    /// <returns>The extracted property name</returns>

    private string getPropertyName(LambdaExpression lambdaExpression)

    {

        MemberExpression memberExpression;

        if (lambdaExpression.Body is UnaryExpression)

        {

            var unaryExpression = lambdaExpression.Body as UnaryExpression;

            memberExpression = unaryExpression.Operand as MemberExpression;

        }

        else

        {

            memberExpression = lambdaExpression.Body as MemberExpression;

        }

        return memberExpression.Member.Name;

    }

}

Die ViewModelBase-Klasse kann man sich hier herunterladen :

  ViewModelBase.zip



Falls euch der Artikel gefallen sollte, dann bitte "kicken" :

Gloweffekt in .NET 4.0 (BitmapEffect-Klasse)

<OuterGlowBitmapEffect GlowColor="White" GlowSize="10" />

<DropShadowEffect ShadowDepth="0" Color="White" BlurRadius="30" RenderingBias="Quality"/>

Der Effekt ist nahezu identisch, auch wenn geringfügige optische Abweichungen bestehen.

Screenshots der Beispielapplikation :




Bei Fragen und Anregungen schreibt mir doch einfach einen Kommentar oder eine PN.

Die Beispielapplikation könnt ihr euch hier herunterladen :

Silverlight Applikation pausieren ohne dass der Browser „einfriert“

private void SLThreadSleep( int TimeoutInMilliseconds )
{
    // Storyboard für eine Pause von x Millisekunden erzeugen ...
    Storyboard SleepStoryboard = new Storyboard();
    DoubleAnimation SleepDuration = new DoubleAnimation() { Duration = TimeSpan.FromMilliseconds( TimeoutInMilliseconds ), From = 1, To = 1 };
    SleepStoryboard.Children.Add( SleepDuration );
    Storyboard.SetTarget( SleepDuration, LayoutRoot );
    Storyboard.SetTargetProperty( SleepDuration, new PropertyPath( "(UIElement.Opacity)" ) );
    SleepStoryboard.Completed += new EventHandler( (ds, de) =>
        {
        // Master Grid und gesamten Inhalt wieder aktivieren
        LayoutRoot.IsHitTestVisible = true;
        // Das Rücksetzen des Buttontextes ist nur für die Beispielapplikation gedacht
        btnSleep2.Content = "SL App 5 Sekunden pausieren (mit Storyboard)";
        } );
    SleepStoryboard.Begin();
}

TextBlock animiert ein- und ausblenden

public static void AddSmartFadingAnimation( this TextBlock TextBlockToAnimate,
                                            List<string> FadingTextList,
                                            double TextPromptDuration,
                                            double FadingSpeed )

List<string> TextList = new List<string>();
for( int i = 0; i < 10; i++ )
  TextList.Add( "Einzublendender Text Nr. " + i );

tblFadingInfo.AddSmartFadingAnimation( TextList, 1000, 1500 );

Silverlight 4 Templates für WP7 Apps

<Tasks>
<DefaultTask  Name ="_default" NavigationPage="Page1.xaml"/>
</Tasks>

RootFrame.UriMapper = Resources["UriMapper"] as UriMapper;

Windows Phone 7 Entwicklung “Best Practice“

<UserControl … Height="768" Width="480" FontFamily="Segoe UI"
FontSize="20" Foreground="White">

<Application.Resources>
<!-- Dies sind Nachbildungen der Standard WP7-Systemressourcen -->
<Style x:Key="PhoneTextNormalStyle" TargetType="TextBlock">
<Setter Property="FontFamily" Value="Segoe UI"/>
<Setter Property="Foreground" Value="White"/>
<Setter Property="FontSize" Value="20"/>
</Style>

<Style x:Key="PhoneTextTitle1Style" TargetType="TextBlock">
<Setter Property="FontFamily" Value="Segoe UI Light"/>
<Setter Property="Foreground" Value="White"/>
<Setter Property="FontSize" Value="72"/>
</Style>

<Style x:Key="PhoneTextTitle2Style" TargetType="TextBlock">
<Setter Property="FontFamily" Value="Segoe UI Light"/>
<Setter Property="Foreground" Value="White"/>
<Setter Property="FontSize" Value="32"/>
</Style>
</Application.Resources>

<TextBlock x:Name="ApplicationTitle" Text="Name der App"
Style="{StaticResource PhoneTextNormalStyle}"/>