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.

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…

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.")

        }

    }

}

Zunächst fügt man seinem Outlook Add-In Projekt ein Benutzersteuerelement hinzu welches die Registerkarte die man später im Optionen-Dialog haben möchte darstellt. Ich habe dieses in diesem Beispiel ctlOptionen genannt. Wichtig ist, dass man die erste Zeile (” … ComVisible(true)”) hinzufügt, da das Steuerelement ansonsten nicht als ActiveX COM Element sichtbar ist. (Dies war übrigens auch mein großes Problem, aber da muss man erst einmal ohne Fehlermeldung drauf kommen… Hier habe ich endlich die Lösung gefunden.)

Ausserdem habe ich hier eine Methode gefunden um das PropertyPageSite Objekt zu bekommen welches man braucht um das Optionen Formular durch aufrufen des OnStatusChange Ereignisses darüber zu benachrichtigen, dass sich etwas in den Optionen geändert hat. Es sollte beachtet werden, dass in diesem Beispiel beim Ändern von Einstellungen die isDirty-Variable über die entsprechende Eigenschaft auf true gesetzt werden muss, damit das Optionen-Formular benachrichtigt wird.

[System.Runtime.InteropServices.ComVisible(true)]
public partial class ctlOptionen : UserControl,
    Microsoft.Office.Interop.Outlook.PropertyPage
{
    private bool isDirty = false;
    private Microsoft.Office.Interop.Outlook.PropertyPageSite site;

    public ctlOptionen()
    {
        InitializeComponent();
    }

    #region PropertyPageSite Objekt holen
    /// <summary>
    /// Hier wird die entpsrechende PropertyPageSite geholt, bei der das OnStatusChange()
    /// Ereignis ausgelöst wird um das Optionen-Formular zu benachrichtigen, dass etwas
    /// geändert wurde.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void ctlOptionen_Load(object sender, EventArgs e)
    {
        Type type = typeof(UserControl);
        Type oleType = type.Assembly.GetType(
            "System.Windows.Forms.UnsafeNativeMethods+IOleObject");
        if (oleType == null) throw new InvalidOperationException(
            "Could not get 'System.Windows.Forms.UnsafeNativeMethods+IOleObject'.");

        System.Reflection.MethodInfo method =
            oleType.GetMethod("GetClientSite");
        if (method == null) throw new InvalidOperationException(
            "Could not get method 'IOleObject.GetClientSite'.");

        site = method.Invoke(this, null) as
            Microsoft.Office.Interop.Outlook.PropertyPageSite;
    }
    #endregion

    #region PropertyPage Member

    /// <summary>
    /// Wird aufgerufen wenn die gemachten Änderungen gespeichert werden sollen 
    /// (Klick auf OK bzw. Übernehmen)
    /// </summary>
    public void Apply()
    {
    }
    /// <summary>
    /// Gibt true zurück, wenn die Optionen der Seite sich geändert haben. 
    /// Wird von Outlook benutzt um zu entscheiden ob der Übernehmen-Button aktiviert ist.
    /// Beim setzen wird hier das Optionen-Formular benachrichtigt, dass sich etwas 
    /// geändert hat.
    /// </summary>
    [Browsable(false)]
    public bool Dirty
    {
        get { return isDirty; }
        set
        {
            if (isDirty != value)
            {
                isDirty = value;
                if (site != null) site.OnStatusChange();
            }
        }
    }

    /// <summary>
    /// Hier kann man eine Hilfedatei angeben die mit dieser Seite verknüpft ist.
    /// </summary>
    /// <param name="HelpFile"></param>
    /// <param name="HelpContext"></param>
    public void GetPageInfo(ref string HelpFile, ref int HelpContext)
    {
    }

    #endregion
}

Als nächstes fügt man einen Ereignishandler (Das ist tatsächlich die deutsche Übersetzung laut MSDN…) für das OptionPagesAdd-Event hinzu. Dieses Ereignis wird jedes mal angestoßen wenn der Optionen-Dialog geöffnet wird. Dieser kann gut in der ThisAddIn_Startup Methode der ThisAddIn-Klasse untergebracht werden.

Application.OptionsPagesAdd += new Microsoft.Office.Interop.Outlook
    .ApplicationEvents_11_OptionsPagesAddEventHandler
        (Application_OptionsPagesAdd);

Dementsprechend wird auch die Methode erstellt welche dann nichts anderes tut als die Registerkarte hinzuzufügen.

void Application_OptionsPagesAdd
    (Microsoft.Office.Interop.Outlook.PropertyPages Pages)
{
    Pages.Add(new ctlOptionen(), "Meine Optionen");
}

1. Zunächst muss man wissen was man sucht. Was WMI alles zur Verfügung stellt kann man hier in der msdn nachlesen.
2. Dann baut man einen string zusammen der die Form einer SQL-Query hat.
3. Als nächstes benutzt man einen ManagementObjectSearcher um die Daten zu suchen. Dieser gibt eine Collection mit den gefundenen ManagementObject-Objekten zurück. Über diese kann man mit dem Namen gewünschten Eigenschaft zugreifen.

Hier ein Beispiel um den Namen, die ID und die MAC-Adresse aller Netzwerkkarten (virtuell oder nicht) in einer MessageBox anzeigen zu lassen:

string query = "SELECT * FROM Win32_NetworkAdapter WHERE NetConnectionID IS NOT null";
ManagementObjectSearcher sucher = new ManagementObjectSearcher(query);

string s = "";
foreach (ManagementObject m in sucher.Get())
{
    // NetConnectionID Name der Karte wie in der Systemsteuerung
    // DeviceID ID HardwareID wie in der Registry
    s += m["NetConnectionID"] +
        " ID " + m["DeviceID"] +
        " MAC " + m["MACAddress"] + "\n";
}

MessageBox.Show(s);