Codeausschnitte im Visual Studio einbinden

Codeausschnitte kennt bestimmt jeder, ich habe ja hier in meinem Blog schon viele gepostet, die man einfach ausschneiden und in sein eigenes Programm übernehmen kann. Dabei handelt es sich meist um ganze Klassen oder komplexe Funktionen. Während des Programmierens verwendet man oft viel kleinere Codeausschnitte immer und immer wieder. Mit Hilfe der IntelliSense-Technlogie, sind diese Snippets auch recht schnell runter getippt. Beispiele gibt es viele: ein try-catch-finally-Blöcke, if-else, Properties, you name it... Und viele von uns verwenden auch die Snippet-Funktion im Visual Studio - Gibt man zum Beispiel "propfull" mit folgendem Tabulator ein, wird automatisch eine Vorlage für ein Property erstellt:

|  |

\ /

Jetzt muss man nur noch die markierten Bezeichner eingeben (Variablentyp, Feldname, Propertyname) und man hat ein Property erstellt. Das ist ja schön und gut, und auch nützlich. Aber selbst sowas machen? Oft wird die Antwort sein "Brauch ich jetzt nicht", "Da muss ich mich erst einarbeiten, da hab ich keine Zeit für".. Aber als Softwareentwickler sollten wir es doch besser wissen: Investiert man einmal ein wenig mehr Zeit, kann man in Zukunft "faul" sein.

Ich möchte Euch am Beispiel eines Snippets für ein ViewModelProperty kurz zeigen, wie es funktioniert. Zu erst benötigen wir das Code Snippet als C# Code:

private string _testField;

/// <summary>
/// gets / sets  TestProperty
/// </summary>
public string TestProperty
{
  get { 
      return _testField; 
  }
  set {
      if (value != _testField)
      {
        _testField = value;
        OnPropertyChanged(() => TestProperty);
      }
  }
}

So weit, so gut. Nachdem wir festgelegt haben, dass die Bezeichnung für das snippet propvm sein soll, müssen wir jetzt definieren, welche Teile des Codes vom Benutzer eingegeben werden, diese müssen wir dann durch ein Literal mit der Syntax $ID$ ersetzen. In unserem Fall sind das die Teile "string", "_testField" und "TestProperty":

private $type$ $field$;

/// <summary>
/// gets / sets  $property$
/// </summary>
public $type$ $property$
{
  get { 
      return $field$; 
  }
  set {
      if (value != $field$)
      {
        $field$= value;
        OnPropertyChanged(() => $property$);
      }
  }
}

Das war schon fast alles, jetzt müssen wir das ganze nur noch in das snippet-Xml-Format einfügen, ein paar Metadaten dazu und fertig sind wir. Wichtig dabei ist, dass wir jedes Literal, das wir verwenden im Xml auch deklarieren und mit einem netten Tooltip für den Anwender versehen. Das fertige Snippet sieht dann also so aus:

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
 <CodeSnippet Format="1.0.0">
  <Header>
   <Title>propvm</Title>
   <Shortcut>propvm</Shortcut>
   <Description>Codeausschnitt für eine ViewModel-Eigenschaft inkl. dem dahinter liegenden Feld</Description>
   <Author>Thomas Kison</Author>
   <SnippetTypes>
    <SnippetType>Expansion</SnippetType>
   </SnippetTypes>
  </Header>
  <Snippet>
   <Declarations>
    <Literal>
     <ID>type</ID>
     <ToolTip>Eigenschaftentyp</ToolTip>
     <Default>string</Default>
    </Literal>
    <Literal>
     <ID>property</ID>
     <ToolTip>Eigenschaftenname</ToolTip>
     <Default>MyProperty</Default>
    </Literal>
    <Literal>
     <ID>field</ID>
     <ToolTip>Die Variable hinter dieser Eigenschaft</ToolTip>
     <Default>_myVar</Default>
    </Literal>
   </Declarations>
   <Code Language="csharp">
        <![CDATA[private $type$ $field$;

/// <summary>
/// gets / sets  $property$
/// </summary>
public $type$ $property$
{
  get { 
      return $field$; 
  }
  set {
      if (value != $field$)
      {
        $field$= value;
        OnPropertyChanged(() => $property$);
      }
  }
}
 $end$]]>
   </Code>
  </Snippet>
 </CodeSnippet>
</CodeSnippets>

Jetzt müssen wir Visual Studio nur noch mitteilen, dass es dieses Script gibt. Das geht recht einfach, wir legen es in unser "Snippet-Verzeichnis" von Visual Studio. Den genauen Pfad finden wir unter Extras > Codeausschnitt-Manager unter dem Ordner My Code Snippets

Viel Spaß mit Euren eigenen Visual Studio Snippets!

Code Snippet: ViewModelBase

Oft benötige ich eine Implementierung der ViewModelBase-Klasse, dann muss ich diese entweder aus anderen Projekten kopieren, oder googeln. Jetzt muss ich das nicht mehr, denn ich merk sie mir einfach hier:

// parts of this code is based upon the article : http://msdn.microsoft.com/de-de/magazine/dd419663.aspx#id0090051
class ViewModelBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    /// <summary>
    /// raises the PropertyChanged event with the given string parameter
    /// </summary>
    /// <param name="propertyName">name of the property, that has changed</param>
    protected virtual void OnPropertyChanged(string propertyName)
    {
        // just to avoid wrong Event-Calls (only in debug mode)
        this.VerifyPropertyName(propertyName);

        // call the event handler
        PropertyChangedEventHandler handler = this.PropertyChanged;
        if (handler != null)
        {
            var e = new PropertyChangedEventArgs(propertyName);
            handler(this, e);
        }
    }

    /// <summary>
    /// raises the PropertyChanged-event, with the name of the property that is given by the lambda expression
    /// </summary>
    /// <typeparam name="Tprop">type parameter of the given property, to be ignored</typeparam>
    /// <param name="property">the lambda expression f.e.: "() => TestProperty"</param>
    protected virtual void OnPropertyChanged<Tprop>(Expression<Func<Tprop>> property)
    {
        // cast as LambdaExpression
        LambdaExpression lambda_exp = (LambdaExpression)property;
        if (lambda_exp != null) 
        {
            MemberExpression member_exp = (MemberExpression)lambda_exp.Body;
            if (member_exp != null)
            {
                OnPropertyChanged(member_exp.Member.Name);
                return;
            }
        }
        Debug.Fail("No correct LambdaExpression provided for OnPropertyChanged.");
    }

    [Conditional("DEBUG")]
    [DebuggerStepThrough]
    public void VerifyPropertyName(string propertyName)
    {
        // Verify that the property name matches a real,  
        // public, instance property on this object.
        if (TypeDescriptor.GetProperties(this)[propertyName] == null)
        {
            string msg = "Invalid property name: " + propertyName;
            Debug.Fail(msg);
        }
    }
}