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!

SQL Code Snippet: Anzeigen aller durch Fremdschlüssel abhängigen Tabellen

Mit diesem MS SQL-Script ist es möglich zu einer gegebenen Tabelle alle Tabellen zu finden, von denen diese durch Foreign Key Constraints abhängig ist.

declare @TableName nvarchar(50)='TestTable2'
declare @SchemaName nvarchar(10)='dbo'

 select schRef.name+'.'+referenced.name from sys.foreign_keys fk
 join sys.tables referenced on referenced.object_id = fk.referenced_object_id
 join sys.tables base on base.object_id = fk.parent_object_id
 join sys.schemas schBase on schBase.schema_id = base.schema_id
 join sys.schemas schRef on schRef.schema_id = referenced.schema_id
 where base.name=@TableName and schBase.name=@SchemaName

um das ganze jetzt auch noch vollständig ausgeben zu können (inkl. Column), wäre folgendes der Code:

declare @TableName nvarchar(50)='TestTable2'
declare @SchemaName nvarchar(10)='dbo'

  select 
 schRef.name+'.'+referenced.name  ReferencedTable
 , colRef.name      ReferencedColumn
 , schBase.name+'.'+base.name  BaseTable
 ,colBase.name      BaseColumn
 from sys.foreign_keys fk
  -- ref table
 join sys.tables referenced on referenced.object_id = fk.referenced_object_id
 join sys.schemas schRef on schRef.schema_id = referenced.schema_id
 
 -- base table
 join sys.tables base on base.object_id = fk.parent_object_id
 join sys.schemas schBase on schBase.schema_id = base.schema_id
 
 -- columns
 join sys.foreign_key_columns fkc on fkc.constraint_object_id = fk.object_id
 
 join sys.all_columns colBase on colBase.column_id = fkc.parent_column_id and colBase.object_id = base.object_id
 join sys.all_columns colRef on colRef.column_id = fkc.referenced_column_id and colRef.object_id = referenced.object_id


 where base.name=@TableName and schBase.name=@SchemaName

Code Snippet: Thread sicherer Zugriff auf WPF-Control

Motivation

Verwendet man in WPF konsequent das MVVM-Modell, so greift man immer auf das ViewModel zu, anstatt direkt mit irgendwelchen GUI-Elementen zu interagieren. Da der Zugriff auf das ViewModel wiederum threadunabhängig ist, kommt man eigentlich nie (oder eher selten) in die Lage folgenden Code einzusetzen. Aber wie immer bestätigen Ausnahmen die Regel - mir fällt zwar spontan kein einfacher Anwendungsfall ein, aber in der täglichen Praxis habe ich diesen Code schon einige male verwendet:

// nehmen wir an, wir haben eine TextBox und wollen threadsicher den Text verändern
 class ThreadSafeTextBox : TextBox
    {
        public void SetTextThreadSafe(string text)
        {
                // prüft, ob der aktuelle Thread dem Dispatcher 
                // dieses Controls zugeordnet ist
                if (this.Dispatcher.CheckAccess())
                {
                    // Ist dies der Fall, können wir den Text einfach setzen.
                    // Man sollte beachten, dass man sich jetzt in dem 
                    // Dispatcher Thread befindet, man sollte hier also nur 
                    // "schnell" auf die GUI zugreifen. Alles was lange dauert
                    // und nichts direkt mit der GUI zu un hat, gehört hier nicht rein!
                    base.Text = text;
                }
                else
                {
                    // anderenfalls müssen wir den Dispatcher "invoken"
                    this.Dispatcher.Invoke(new Action(
                        () =>
                        {
                            // jetzt können wir sicher auf den Text zugreifen
                            SetTextThreadSafe(text);
                        })
                        );
                }
            }
        }
    }