Currently I’m trying to implement a reusable control for reflection in WPF. I come to the conclusion that XAML is a very easy way to achieve such an effect but it is not the ‘modern abstract’ way. So after a while I found a very nice example which operates with AttachedProperties to display a reflection (see Reflecting on Reflections).

But the author missed to copy all AttachedProperties for a Panel from the element that has reflection  to the new Panel (which is responsible for the reflection at last).

Here you can find a first and rapid implementation to gain all necessary AttachedProperties for Panels:

public static class AttachedPropertiesManager
{
private static FlowDirection FlowDirection;
private static int ZIndex;
private static Dock Dock;
private static readonly CanvasAttachedPropertiesManager CanvasAttachedProperties = new CanvasAttachedPropertiesManager();
private static readonly GridAttachedPropertiesManager GridAttachedProperties = new GridAttachedPropertiesManager();

/// <summary>
/// Saves all AttachedProperties of an element within a Panel
/// </summary>
/// <remarks>Canvas, DockPanel and Grid are the only Panel derived classes which implement AttachedProperties.</remarks>
/// <param name=“element“>Element that holds AttachedProperties</param>
Element that holds AttachedProperties public static void SaveAttachedProperties(FrameworkElement element)
{
if (element == null) throw new ArgumentNullException(„element“);
// General AttachedProperties
FlowDirection = FrameworkElement.GetFlowDirection(element);
ZIndex = Panel.GetZIndex(element);
// Canvas AttachedProperties
CanvasAttachedProperties.Top = Canvas.GetTop(element);
CanvasAttachedProperties.Bottom = Canvas.GetBottom(element);
CanvasAttachedProperties.Left = Canvas.GetLeft(element);
CanvasAttachedProperties.Right = Canvas.GetRight(element);
// DockPanel AttachedProperties
Dock = DockPanel.GetDock(element);
// Grid AttachedProperties
GridAttachedProperties.Column = Grid.GetColumn(element);
GridAttachedProperties.ColumnSpan = Grid.GetColumnSpan(element);
GridAttachedProperties.Row = Grid.GetRow(element);
GridAttachedProperties.RowSpan = Grid.GetRowSpan(element);
GridAttachedProperties.IsSharedSizeScope = Grid.GetIsSharedSizeScope(element);
}
/// <summary>
/// Restores all AttachedProperties of an element within a Panel
/// </summary>
/// <remarks>Canvas, DockPanel and Grid are the only Panel derived classes which implement AttachedProperties.</remarks>
/// <param name=“element“>Element that will implement all current AttachedProperties.</param>
Element that will implement all current AttachedProperties. public static void RestoreAttachedProperties(UIElement element)
{
if (element == null) throw new ArgumentNullException(„element“);
// General AttachedProperties
FrameworkElement.SetFlowDirection(element, FlowDirection);
Panel.SetZIndex(element, ZIndex);
// Canvas AttachedProperties
Canvas.SetTop(element, CanvasAttachedProperties.Top);
Canvas.SetBottom(element, CanvasAttachedProperties.Bottom);
Canvas.SetLeft(element, CanvasAttachedProperties.Left);
Canvas.SetRight(element, CanvasAttachedProperties.Right);
// DockPanel AttachedProperties
DockPanel.SetDock(element, Dock);
// Grid AttachedProperties
Grid.SetColumn(element, GridAttachedProperties.Column);
Grid.SetColumnSpan(element, GridAttachedProperties.ColumnSpan);
Grid.SetRow(element, GridAttachedProperties.Row);
Grid.SetRowSpan(element, GridAttachedProperties.RowSpan);
Grid.SetIsSharedSizeScope(element, GridAttachedProperties.IsSharedSizeScope);
}

public class GridAttachedPropertiesManager
{
public int Column;
public int ColumnSpan;
public int Row;
public int RowSpan;
public bool IsSharedSizeScope;
}

public class CanvasAttachedPropertiesManager
{
public double Top;
public double Bottom;
public double Left;
public double Right;
}
}

XPS is the new portable format from Microsoft. The file structure consists of several parts, which includes the text (the so called „fixed documents“) and, of course, all resources. Images and fonts are embedded in a specific folder but as a general rule fonts are obfuscated to „protect“ the copyrights of the author.

To extract the text (which is by the way a subset of XAML) all resources have to be extracted, too. But obfuscated fonts cannot be read, therefore a decryption is required.
The encryption is rather simple: The first 32 bytes are XOR with the GUID of the file (it is also documented in the MSDN). To reverse all font files repeat the exclusive disjunction with the GUID (the file name implies the GUID, thank you) and you will receive the original source (for a better understanding see: http://en.wikipedia.org/wiki/XOR).

I attached a little example. Pass the obfuscated font path and streamOut will return the deobfuscated stream. To save the stream to disc, call streamOut.Position = 0 first.

Edit 2008-10-26:
Here you can find my solution:
http://www.bremora.com/index.php/xps-font-deobfuscator

Der erste RC des WPF-Designers Expression Blend ist nun auf den Seiten von Microsoft verfügbar.

Der Download und der Key für eine 180-Tage-Testversion befinden sich hier.

EDIT:  Expression Blend ist zur Zeit nicht mehr als RC verfügbar. Stattdessen kann nun die Releaseversion 60 Tage lang getestet werden.

Eine von Microsoft dokumentiertes „Klassendiagramm“ wie für das gute alte MFC, sucht man für das .NET 3.0 Framework leider vergebens. Zwar gibt es eine struktierte Klassenbibliothek, jedoch zeigt dies noch lange nicht alle Abhängigkeiten auf.

Eine einfache Lösung zur Veranschaulichung aller Typen bietet der Klassendesigner (beliebiges Projekt öffnen -> rechte Maustaste auf eine *.cs-Datei -> Klassendiagramm anzeigen -> bestehende Klassen löschen) und der Objektbrowser (Ansicht->Objektbrowser) von Visual Studio 2005.

Anschließend die gewünschten Namespaces in der Klassendesigner ziehen. Zur Darstellung weitere Abhängigkeiten kann man mit dem Kontextmenü „Basisklasse anzeigen“ und „Abgeleitete Klassen anzeigen“ alle Verbindungen aufzeigen.

Schließlich kann das Diagramm noch als Bild gespeichert werden (Kontextmenü->Diagramm als Bild exportieren). Allerdings bleibt die Auflösung bei sehr großen Entwürfen nicht konstant, sodass das Diagramm im Bild kaum noch zu lesen ist.

Das der WPF-Designer zur Visualisierung von XAML-Dokumenten in Visual Studio 2005 sich wohl noch in einer frühen Betaphase befindet (ständige Abstürze, schlechte Performance), sollte bereits bekannt sein.

Die Frage, die sich nun aufstellt lautet: Wie kann ich diesen deaktivieren und standardmäßig lediglich den Editor laden?

Antwort:

• Auf ein XAML-Dokument in dem Projekt klicken
• Rechte Maustaste -> „Open with…“
• „XML Editor“ als default auswählen