Entdeckt habe ich das ganze bei einem Projekt in dem ich eine neue Instanz eines Fensters erstellt habe, ohne es zu öffnen (über die Gründe will ich jetzt mal nichts sagen – ich weiß, dass das an sich ne blöde Idee ist…). Nachdem ich das Programm gestartet habe, konnte ich zwar alle Fenster schließen, aber der Prozess lief immer weiter.

Nach etwas debuggen habe ich dann herausgefunden, dass immer noch eine Referenz zum Fenster vorhanden ist, obwohl dieses gar nicht mehr existiert. Dadurch kann das Programm natürlich nicht beendet werden, da es denkt, das noch irgendwo ein Fenster offen ist.

Die Referenz zum Fenster in der WindowCollection der Anwendung wird scheinbar dann entfernt, wenn Window.Close() aufgerufen wird.

Ein sehr interessantes Phänomen, auf das man erst mal kommen muss…

Update:

Nachdem ich dafür einen Bug bei Microsoft Connect erstellt habe, kam nun die Antwort, dass das Verhalten “bei Design” ist. Komisch, ist aber so…

Zitat:

This behavior is probably by design. Application has a property called “ShutdownMode” that has a default value of OnLastWindowClose. Creating a window is sufficient to register it for keeping the application alive, even if it is never shown.
Depending on your scenario another value for ShutdownMode may be appropriate.
Hope that helps,

1. Zunächst erzeugt man in Visual Studio ein entsprechendes Projekt mit der Vorlage WPF-Benutzersteuerelementbibliothek.
2. In diesem Projekt kann man das automatisch erzeugte UserControl1 guten Gewissens entfernen (wir wollen ja ein WPF-Steuerelement erstellen).
3. Dafür muss man unser WPF-Steuerelement hinzufügen. (Einfügen –> neues Element –> Benutzersteuerelement)
4. Jetzt geht es darum, aus dem Usercontrol ein Steuerelement zu machen, welches von der Standard-TextBox erbt, damit man die ganzen Standard Geschichten schon fertig hat. Dazu einfach im XAML-Code UserControl durch TextBox ersetzen, und alle Attribute außer den namespaces und dem Klassennamen entfernen, so dass es in etwa so ausschaut:

   <TextBox x:Class="Denis.WPF_Controls.MaskedTextBoxWPF"
       xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   />

   Dadurch sagen wir einfach, dass wir ein Steuerelement erzeugen dass von TextBox erbt. Da es ja auch noch eine entsprechende CodeDatei gibt müssen wir dort ebenfalls sagen, dass wir nicht mehr die partielle Klasse UserControl erweitern, sondern Textbox:

   public partial class MaskedTextBoxWPF : UserControl
   //ersetzen durch
   public partial class MaskedTextBoxWPF : TextBox

5. Jetzt brauchen wir noch ein paar Events die wir behandeln um abzufangen wenn Text eingegeben, gelöscht und eingefügt (copy/paste) wird. Dazu einfach den XAML-Code so erweitern:

   <TextBox x:Class="Denis.WPF_Controls.MaskedTextBoxWPF"
       xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
       DataObject.Pasting="TextBox_Pasting"
       PreviewTextInput="TextBox_PreviewTextInput"
       KeyDown="TextBox_KeyDown"
   />

6. Als erstes brauchen wir eine Klassen-Variable, welche den MaskedTextBoxProvider enthält (wofür ein Verweis auf SystemComponentModel benötigt wird). Diese wird dann im Konstruktor mit einer Standardmaske gefüllt und dann initialisiert:

   MaskedTextProvider mktProvider;
   
   public MaskedTextBoxWPF()
   {
       InitializeComponent();
       mktProvider = new MaskedTextProvider("???");
   }

7. Außerdem geben wir die Mask-Eigenschaft nach außen weiter, lassen die im Designer bearbeiten und geben auch ne kleine Doku für das Bearbeiten im Designer an:

   [Browsable(true)]
   [DesignOnly(true)]
   [Description("0 Ziffer - erforderlich; 9 Ziffer oder Leerzeichen - opt.;" +
             "L Buchstabe - erforderlich; ? Buchstabe - opt.")]
   public string Mask
   {
     get
     {
         return mktProvider.Mask;
     }
     set
     {
         mktProvider = new MaskedTextProvider(value);
         Text = "";
     }
   }

8. Als letztes müssen wir noch die Events mit Code füllen.Im PreviewTextInput-Ereignis prüfen wir, ob der Buschstabe hinzugefügt werden darf und brechen ggf. ab.Im Pasting-Ereignis machen wir das selbe mit eingefügtem Text und das KeyDown-Ereignis ist dafür da den Text im MaskedTextBoxProvider aktuell zu halten (falls z.B. was gelöscht wird).

   private void TextBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
   {
     if (mktProvider.Add(e.Text) == false)
     {
         e.Handled = true;
     }
   }
   
   private void TextBox_Pasting(object sender, DataObjectPastingEventArgs e)
   {
     if (e.DataObject.GetDataPresent(typeof(String)))
     {
         String text = (String)e.DataObject.GetData(typeof(String));
         if (mktProvider.Add(text) == false)
         {
             e.CancelCommand();
         }
     }
     else e.CancelCommand();
   }
   
   private void TextBox_KeyDown(object sender, KeyEventArgs e)
   {
     mktProvider.Clear();
     mktProvider.Add(Text);
   }

So, das war’s schon. Man könnte das ganze noch etwas schöner machen, indem man wie bei WinForms die Eingabemaske anzeigt, aber die Funktionalität ist vorhanden und kann so benutzt werden.

Es reicht in XAML den Graphen zu deklarieren und ihn dann über die DataSource zu füllen. Falls man so wie ich mehrere Datenreihen dynamisch hinzufügen will kann man einfach eine entsprechende Series per Code hinzufügen und dann über die Itemsource die Datenquelle binden.

Hier mal ein Beispiel-Graph für ein Balkendiagram, welches Daten Monatsweise anzeigt (dafür ist auch die Formatierung gedacht). Dieser enthält immer eine “lineare” Achse, welche einen normalen Liniengraphen darstellt – ich habe Sie explizit definiert, damit der mindest-Wert immer auf 0 steht und nicht automatisch angepasst wird..

<chartingToolkit:Chart Name="chart1">
   <chartingToolkit:Chart.Axes>
      <chartingToolkit:DateTimeAxis
         Orientation="X" Location="Bottom"
         IntervalType="Months" Interval="1">
         <chartingToolkit:DateTimeAxis.AxisLabelStyle>
            <Style TargetType="chartingToolkit:DateTimeAxisLabel">
               <Setter Property="StringFormat" Value="{}{0:MM-yy}"/>
            </Style>
         </chartingToolkit:DateTimeAxis.AxisLabelStyle>
      </chartingToolkit:DateTimeAxis>
      <chartingToolkit:LinearAxis Orientation="Y"
         Location="Left" Minimum="0"
         ShowGridLines="True" />
   </chartingToolkit:Chart.Axes>
</chartingToolkit:Chart>

der dann ohne Daten so ausschaut:

Um diesem dann dynamisch mehr “Series”, also weitere z.B. Balken/Linien hinzuzufügen kann reicht dann dieser Code. Durch das setzen von Title wird der entsprechende Titel in der legende angezeigt.

ColumnSeries serie = new ColumnSeries();
// Alternativ z.B.
// LineSeries serie = new LineSeries();
serie.Title = "Titel für Legende";
serie.DependentValuePath = "Y-Wert-komponente";
serie.IndependentValuePath = "X-Wert-komponente";
serie.ItemsSource = daten;
// chart1, weil ich dem Chart im XAML
// diesen kreativen Namen spendiert habe,
chart1.Series.Add(serie);

Eine Sache, welche schon als bug reported wurde ist allerdings, dass momentan ein Graph mit einer DateTimeAxis und einer ColumnSeries keine Daten anzeigt, wenn nur ein Datum in der Liste für die Itemsource vorhanden ist. Dies liegt daran, dass mit Hilfe zumindest eines anderen Balkens versucht wird, die Breite für den Balken zu berechnen. Das wird aber im nächsten Release gefixt werden.

Die Klasse SystemState in Microsoft.WindowsMobile.Status nimmt einem in der Hinsicht jegliche Arbeit ab. Zunächst muss man also den entsprechenden Verweis im Projekt einfügen und kann dann sehr einfach den Status prüfen. Diese Zeile prüft z.B. ob ActiveSync gerade etwas macht:

   1: if(SystemState.ActiveSyncStatus == ActiveSyncStatus.Synchronizing)

   2: {

   3:     MessageBox.Show("Synching!");

   4: }

Mit der SystemState Klasse kann man einiges machen und in der Hinsicht lohnt es sich wirklich mal die Doku durchzuschauen um zu sehen was einem da alles zur Verfügung steht. Ich werde dort jetzt auf jeden Fall öfter rein schauen…

Letztendlich habe ich herausgefunden, dass es daran liegt, dass man die Replikations-Komponente zum Komprimieren braucht. Interessanterweise wird diese im Emulator beim Debuggen direkt mit installiert, wohingegen diese auf dem Gerät natürlich nicht standardmäßig bei ist.

Um diese zu installieren kann man die “sqlce.repl.wce5.armv4i.cab” im folgenden Verzeichnis benutzen.

C:\Program Files\Microsoft SQL Server Compact Edition\v3.5\Devices\
wce500\armv4i

Anschließend kann mit diesen Zeilen die Datenbank komprimiert werden:

   1: engine = new SqlCeEngine("ConnectionString");

   2: engine.Shrink();

Eine Sache auf die man dabei achten sollte ist, dass es Probleme geben kann, wenn die Datenbank-Datei in einem mit Activesync synchronisierten Verzeichnis liegt – dann kann es sein, dass die Datei durch ActiveSync gesperrt ist. Die Lösung für dieses Problem kommt im nächsten Post

The project File "...Projekt.csproj" is not valid.
Das importierte Projekt C:\Microsoft.CSharp.targets wurde nicht gefunden.
...

Mit ein wenig Glück konnte ich die Lösung finden: das Service Pack 1 für Expression Blend installieren! Nachdem ich das installiert hatte, funktioniert alles wunderbar. Jetzt wird animiert!

Leider wird LINQ-2-SQLCE zwar unterstützt, aber nicht schön wie bei den großen SQL Servern. Hier habe ich nun eine Lösung gefunden wie das doch geht.

Der generierte Connectionstring hat das Format:

Data Source=|DataDirectory|Pfad

Bei diesem Format bezeichnet “|Datadirectory|” einen Platzhalter der während der Ausführung ersetzt wird. Dies ist z.B. dann der Fall, wenn die Anwendung per ClickOnce verteilt wird und die Datenbankdatei durch das Setup im automatisch angelegten Daten-Verzeichnis abgelegt wird. Wenn man diesen verwendet, sollte man keinen absoluten, sondern nur einen relativen Pfad angeben.

Will man einen absoluten Pfad (wie z.B. ein Verzeichnis einer Netzwerkfreigabe im Format \\Computer\Freigabe\Verzeichnis) kann man dieses Format verwenden:

Data Source=Pfad

So einfach kann es gehen…

Vor kurzem ist AnkhSVN 2.0 erschienen was eine wesentlich bessere Integration bietet, da es als natives SCC für Visual Studio implementiert wurde. Soweit ich es nach ein paar Tagen testen beurteilen kann hat es sich nicht nur insofern verbessert als dass Outlook-Plugin Projekte nun ohne Probleme damit verwaltet werden können. Die weiteren Pluspunkte sind:

• subjektive Beschleunigung des Eincheck-Vorgangs
• Bessere Integration (eigenes Ausgabe-Fenster)
• schönere Symbole

Falls mir noch mehr Punkte einfallen werde ich Sie hinzufügen. Ich werde noch eins der größeren Nachteile testen müssen: Die Zusammenarbeit von mehreren Personen an einem einzigen Projekt. Bisher wurde dabei irgendwann die Projektdatei beschädigt wenn z.B. unterschiedliche Leute gleichzeitig Formulare in ein Projekt eingefügt haben.

Hier eine Übersetzung in C#:

using System;

using System.Windows.Forms;

using System.Runtime.InteropServices;

using System.Drawing;

class Helper

{

    private struct RECT

    {

        public int Left;

        public int Top;

        public int Right;

        public int Bottom;

    }

    private const int DT_CALCRECT = 1024;

    private const int DT_CENTER = 1;

    private const int DT_LEFT = 0;

    private const int DT_RIGHT = 2;

    private const int DT_TOP = 0;

    private const int DT_WORDBREAK = 16;

    [DllImport("coredll.dll", CharSet = CharSet.Unicode,

        SetLastError = true)]

    private static extern int DeleteObject(IntPtr hObject);

    [DllImport("coredll.dll", CharSet = CharSet.Unicode,

        SetLastError = true)]

    private static extern int DrawText(IntPtr hdc, string lpStr,

        int nCount, ref RECT lpRect, int wFormat);

    [DllImport("coredll.dll", CharSet = CharSet.Unicode,

        SetLastError = true)]

    private static extern IntPtr SelectObject(IntPtr hdc,

        IntPtr hObject);

    /// <summary>

    /// Ändert die Höhe des Labels so, dass der Inhalt genau 

    /// reinpasst.

    /// </summary>

    /// <param name="label">Label dessen Höhe angepasst werden soll.

    /// </param>

    public static void AutoSizeLabelHeight(Label label)

    {

        RECT uRECT = new RECT();

        try

        {

            /*****************************************************

            * Create a Graphics object. We need a Graphics object 

            * so we can get a handle to a Device Context to be used

            * later in the DrawText API. However the Label control 

            * in CF2.0 does not support the CreateGraphics method,

            * so create the Graphics object from the form on which 

            * the Label is located.

            * Note: This can cause an exception when this routine 

            * is called from a Form's Resize event. Probably because

            * the form is not fully initialised and the Resize event

            * may be called one or more times during form

            * initialisation. Therefore, the entire routine is wrapped

            * in a Try/Catch block.

            *****************************************************/

            Graphics objGraphics = label.TopLevelControl.CreateGraphics();

            // Get the handle to the Device Context of the Graphics object

            IntPtr hDc = objGraphics.GetHdc();

            {

                // Get the handle to the Font of the Label

                IntPtr hFont = label.Font.ToHfont();

                // Apply the Font to the Graphics object

                IntPtr hFontOld = SelectObject(hDc, hFont);

                // Set the initial size of the Rect

                uRECT.Right = label.Width - 2;

                // Build the base format

                int lFormat = DT_CALCRECT | DT_WORDBREAK | DT_TOP;

                /*****************************************************

                 * Adjust the format to the Label's text alignment.

                 * Note: This probably isn't necessary as the horizontal 

                 * alignment of text shouldn't affect the text

                 * height calculation. But just in case...

                 *****************************************************/

                switch (label.TextAlign)

                {

                    case ContentAlignment.TopLeft:

                        lFormat = lFormat | DT_LEFT;

                        break;

                    case ContentAlignment.TopCenter:

                        lFormat = lFormat | DT_CENTER;

                        break;

                    case ContentAlignment.TopRight:

                        lFormat = lFormat | DT_RIGHT;

                        break;

                }

                // Calculate the Rect of the text

                if (DrawText(hDc, label.Text, -1, ref uRECT, lFormat)

                    != 0)

                {

                    // Success

                    // Apply the new height to the label

                    label.Height = uRECT.Bottom + 2;

                }

                // Cleanup

                // Set the Font of the Graphics object back to original

                SelectObject(hDc, hFontOld);

                // Delete the handle to the Font of the Label

                DeleteObject(hFont);

            }

            // Clean up the Graphics object

            objGraphics.Dispose();

        }

        catch

        {

            // Do nothing

            //Debug.WriteLine("AutoSizeLabelHeight failed.")

        }

    }

}