• there is an application that needs to change some of its visual characteristics dynamically during run time
• the application uses a custom control library
• other applications/modules should use the same themeing mechanism
• other applications will use the same control library

• create a static class to hold the string keys for the resources I want to define dynamically
• create a shared resources dictionary in the controls theme, using those keys
• use the shared dictionary in the controls theme
• create another shared resources dictionary in the applications, or use only the ones already defined in the control library
• use the application shared dictionaries in the application styles
• programatically add/remove resources directly in Application.Current.Resources to override the already defined resources

• Suspend analysis and regain swiftness of typing
• Write your fingers off, since you already know what to type and even Intellisense feels like slowing you down
• Resume the analysis and get all the R# goodness

private string getImageFilter()
{
  StringBuilder sb=new StringBuilder();
  ImageCodecInfo[] codecs = ImageCodecInfo.GetImageEncoders();
  foreach (ImageCodecInfo info in codecs)
  {
    if (sb.Length > 0)
      sb.Append(";");
    sb.Append(info.FilenameExtension);
  }
  return sb.ToString();
}

filter = string.Format(
     "Image Files({0})|{0}|All files (*.*)|*.*",
     getImageFilter())

' Declarations that should go at the beginning of your code file
' ==========================
Const BlockSize = 32768
Const UNIQUE_NAME = &H0

Private Declare Function GetTempPathA Lib "kernel32" _
   (ByVal nBufferLength As Long, _
    ByVal lpBuffer As String) As Long
    
Private Declare Function GetTempFileNameA Lib "kernel32" _
    (ByVal lpszPath As String, ByVal lpPrefixString As String, _
     ByVal wUnique As Long, ByVal lpTempFileName As String) _
     As Long
' ==========================

' Get a temporary file name
Public Function GetTempFileName() As String

   Dim sTmp    As String
   Dim sTmp2   As String

   sTmp2 = GetTempPath
   sTmp = Space(Len(sTmp2) + 256)
   Call GetTempFileNameA(sTmp2, "", UNIQUE_NAME, sTmp)
   GetTempFileName = Left$(sTmp, InStr(sTmp, Chr$(0)) - 1)

End Function

' Get a temporary file path in the temporary files folder
Private Function GetTempPath() As String
  
   Dim sTmp       As String
   Dim i          As Integer

   i = GetTempPathA(0, "")
   sTmp = Space(i)

   Call GetTempPathA(i, sTmp)
   GetTempPath = AddBackslash(Left$(sTmp, i - 1))

End Function

' Add a trailing backslash is not already there
Private Function AddBackslash(s As String) As String

   If Len(s) > 0 Then
      If Right$(s, 1) <> "\" Then
         AddBackslash = s + "\"
      Else
         AddBackslash = s
      End If
   Else
      AddBackslash = "\"
   End If

End Function

' Write binary data from a recordset into a temporary file and return the file name
Function WriteBLOBToFile(T As DAO.Recordset, sField As String)
    Dim NumBlocks As Integer, DestFile As Integer, i As Integer
    Dim FileLength As Long, LeftOver As Long
    Dim FileData() As Byte
    Dim RetVal As Variant
 
    On Error GoTo Err_WriteBLOB
 
    ' Get the size of the field.
    FileLength = T(sField).FieldSize()
    If FileLength = 0 Then
        WriteBLOBToFile = Null
        Exit Function
    End If
    
    'read Package format
    Dim pos As Integer
    pos = 70 ' Go to position 70
    Do ' read a string that ends in a 0 byte
        FileData = T(sField).GetChunk(pos, 1)
        pos = pos + 1
    Loop Until FileData(0) = 0
    Do ' read a string that ends in a 0 byte
        FileData = T(sField).GetChunk(pos, 1)
        pos = pos + 1
    Loop Until FileData(0) = 0
    pos = pos + 8 ' ignore 8 bytes
    Do ' read a string that ends in a 0 byte
        FileData = T(sField).GetChunk(pos, 1)
        pos = pos + 1
    Loop Until FileData(0) = 0
    ' Get the original file size
    FileData = T(sField).GetChunk(pos, 4)
    FileLength = CLng(FileData(3)) * 256 * 256 * 256 + _
       CLng(FileData(2)) * 256 * 256 + _
       CLng(FileData(1)) * 256 + CLng(FileData(0))
    ' Read the original file data from the current position
    pos = pos + 4
 
    ' Calculate number of blocks to write and leftover bytes.
    NumBlocks = FileLength \ BlockSize
    LeftOver = FileLength Mod BlockSize
 
    ' Get a temporary file name
    Dim Destination As String
    Destination = GetTempFileName()
    
    ' Remove any existing destination file.
    DestFile = FreeFile
    Open Destination For Output As DestFile
    Close DestFile
 
    ' Open the destination file.
    Open Destination For Binary As DestFile
 
    ' SysCmd is used to manipulate the status bar meter.
    RetVal = SysCmd(acSysCmdInitMeter, "Writing BLOB", FileLength / 1000)
 
    ' Write the leftover data to the output file.
    FileData = T(sField).GetChunk(pos, LeftOver)
    Put DestFile, , FileData
 
    ' Update the status bar meter.
    RetVal = SysCmd(acSysCmdUpdateMeter, LeftOver / 1000)
 
    ' Write the remaining blocks of data to the output file.
    For i = 1 To NumBlocks
        ' Reads a chunk and writes it to output file.
        FileData = T(sField).GetChunk(pos + (i - 1) * BlockSize _
           + LeftOver, BlockSize)
        Put DestFile, , FileData
 
        RetVal = SysCmd(acSysCmdUpdateMeter, _
        ((i - 1) * BlockSize + LeftOver) / 1000)
    Next i
 
    ' Terminates function
    RetVal = SysCmd(acSysCmdRemoveMeter)
    Close DestFile
    WriteBLOBToFile = Destination
    Exit Function
 
Err_WriteBLOB:
    WriteBLOBToFile = Null
    Exit Function
 
End Function

Dim id As String
id = DLookup("ID", "MyTableQueryWithFormCriteria", "")
Dim rs As DAO.Recordset
Set rs = CurrentDb.OpenRecordset("SELECT Picture FROM MyTable WHERE ID=" & id)
Dim filename As String
filename = Nz(WriteBLOBToFile(rs, "Picture"), "")
imgMyImage.Picture = filename

1. A 0x40 (64) byte header
2. A 4 byte length
3. A 2 byte (version?) field
4. A string (characters ended with a 0 byte)
5. Another string
6. 8 bytes that I cared not to decode
7. Another string
8. The size of the packaged file (the original) in a 4 byte UInt32
9. The data in the original file
10. Some other rubbish that I ignored

Action 15:34:48: FetchDatabasesAction. 
Action start 15:34:48: FetchDatabasesAction.
MSI (c) (A0:14) [15:34:48:172]: Invoking remote custom action. DLL: C:\DOCUME~1\siderite\LOCALS~1\Temp\MSI21CF.tmp, Entrypoint: FetchDatabases
MSI (c) (A0:68) [15:34:48:204]: Cloaking enabled.
MSI (c) (A0:68) [15:34:48:219]: Attempting to enable all disabled privileges before calling Install on Server
MSI (c) (A0:68) [15:34:48:251]: Connected to service for CA interface.
Action ended 15:34:48: FetchDatabasesAction. Return value 3.
DEBUG: Error 2896:  Executing action FetchDatabasesAction failed.
The installer has encountered an unexpected error installing this package. This may indicate a problem with this package. The error code is 2896. The arguments are: FetchDatabasesAction, , 
Action ended 15:34:48: WelcomeDlg. Return value 3.
MSI (c) (A0:3C) [15:34:48:516]: Doing action: FatalError

<startup>
  <supportedRuntime version="v2.0.50727"/>
</startup>

<startup>
  <!--<supportedRuntime version="v2.0.50727"/>-->
  <supportedRuntime version="v4.0.30319.1"/>
</startup>

<startup useLegacyV2RuntimeActivationPolicy="true">
  <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
  <supportedRuntime version="v2.0.50727" />
</startup>

Update: Thanks to Tim Fischer from Tangible, I got to solve all the problems described in the post below using VolatileAssembly and macros like $(SolutionDir) or $(ProjectDir).

When T4 (Text Template Transformation Toolkit) appeared as a third party toolkit that you could install on Visual Studio 2008, I thought to myself that it is a cool concept, but I didn't get to actually use it. Now it is included in Visual Studio 2010 and I had the opportunity to use it in a project.

The idea is to automatically create code classes and other files directly in Visual Studio, integrated so that the files are generated when saving the template. All in all a wonderful idea... but it doesn't work. Well, I may be exaggerating a bit, but my beginning experience has been off putting. I did manage to solve all the problems, though, and this is what this blog post is about.

First of all, there is the issue of intellisense. I am using ReSharper with my Visual Studio, so the expectations for the computer knowing what I am doing are pretty high. In the .tt (the default extension for T4) files you don't have any. The solution for this is to use the Tangible T4 editor (I think they were going for a fifth T here) that comes as a Visual Studio addon for VS2008 and VS2010. Fortunately, there is a free version. Unfortunately, it doesn't do intellisense on your own libraries unless you buy the priced one. Also, the intellisense is years behind the one provided by ReSharper or even the default Visual Studio one and the actions one can do automatically on code in a T4 template are pretty limited.

The second problem was when trying to link to an assembly using a relative path to the .tt file. The Assembly directive supports either the name of an assembly loaded in the GAC or a rooted path. Fortunately, the VS2010 version of the T4 engine supports macros like $(SolutionDir). I don't know if it supports all Visual Studio build macros in the link, but the path ones are certainly there.

Here is how you use it. Instead of

<#@ Assembly Name="Siderite.Contract.dll" #>

use

<#@ Assembly Name="$(SolutionDir)/Assemblies/Siderite.Contract.dll" #>

The third problem was that using an assembly directive locked the assembly used until you either reopened the solution or renamed the assembly file. That proved very limiting when using assemblies that needed compiling in the same solution.

This can be solved by installing the T4 Toolbox and using the VolatileAssembly directive. Actually, on the link above from Oleg Sych you can also find a bit advising using the T4 toolbox VolatileAssembly directive in the Assembly Locking section.

Here is how you use it. Instead of

<#@ Assembly Name="$(SolutionDir)/Assemblies/Siderite.Contract.dll" #>

use

<#@ VolatileAssembly 
processor="T4Toolbox.VolatileAssemblyProcessor"
name="$(SolutionDir)/Assemblies/Siderite.Contract.dll" #>

As you can see you need to specify the processor (the VolatileAssemblyProcessor would have been installed by the T4 Toolbox) and you can use macros to get to a relative rooted path.

So thanks to the eforts of Oleg and Tim here, we can actually use T4. It would have been terribly akward to work with the solution in the obsolete section below. The Tangible guys have a learning T4 section on their site as well. I guess that using the resources there would have spared me from a day and a half wasted on this.

The following is obsolete due to the solutions described above, but it is still an informative read and may provide solutions for similar problems.

var path=Host.ResolvePath("../Assemblies/Work/Siderite.Contract.dll");

<#@ template  debug="true" hostSpecific="true" #>
<#@ output extension=".cs" #>
<#@ Assembly Name="System.Core.dll" #>
<#@ Assembly Name="System.Windows.Forms.dll" #>
<#@ import namespace="System" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Diagnostics" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Collections" #>
<#@ import namespace="System.Collections.Generic" #> 
<#@ import namespace="System.Reflection" #>
<#@ include file="AssemblyLoader.ttinclude" #>
<#
    // resolve the relative path for the Contract assembly
        string path=Host.ResolvePath("../Assemblies/Work/Siderite.Contract.dll");
        // create a loader in another appdomain
        AssemblyLoader loader=AssemblyLoader.
      CreateInNewDomain("Template generation domain",Path.GetDirectoryName(path));
        // load the Contract assembly in the appdomain
        loader.LoadAssembly(path);
        // get the type we need to use reflection on in order to generate code
        Type type=loader.GetType("Siderite.Contract.IDataServiceFacade");
        // unload the appdomain and exit.
        AssemblyLoader.Unload(loader);
#> 
using System;
using System.ServiceModel;
using System.Reflection;
using System.ServiceModel.Channels;
using Siderite.Configuration;

namespace Siderite.Proxy
{
  // code of the generated class comes here
  // with <# code #> and <#= value #> tags in it
  // using the type variable from the Contract library to get the information I want
}

<#+
class AssemblyLoader : MarshalByRefObject
  {
    private Assembly _assembly;

    public AppDomain Domain
    {
      get;
      private set;
    }

    public override object InitializeLifetimeService()
    {
      return null;
    }

    public void LoadAssembly(string path)
    {
      _assembly = Assembly.Load(AssemblyName.GetAssemblyName(path));
    }

    public Type GetType(string typeName)
    {
      return _assembly.GetType(typeName);
    }

    public static AssemblyLoader CreateInNewDomain(string domainName, string applicationBase)
    {
        AppDomainSetup setup=new AppDomainSetup{ApplicationBase=applicationBase};
      var ad = AppDomain.CreateDomain(domainName,null,setup);

      // Loader lives in another AppDomain
      AssemblyLoader loader = (AssemblyLoader)ad.CreateInstanceAndUnwrap(
        typeof(AssemblyLoader).Assembly.FullName,
        typeof(AssemblyLoader).FullName);
      loader.Domain = ad;

      return loader;
    }

    public static void Unload(AssemblyLoader loader)
    {
      AppDomain.Unload(loader.Domain);
    }
  }

#>

Tips And Tricks:
Problem: the T4 generated file has some unexplained empty lines before the start of the text.
Solution: Remove any spaces from the end of lines. Amazingly so, some white space at the end of some of the lines were translated as empty lines in the resulting .tt.

Problem: The code is not aligned properly
Solution: Well, it should be obvious, but empty spaces before the T4 tags are translated as empty spaces in the resulting .tt file. In other words, stuff like <# ... should not be preceded by any indenting. It will make the template look a bit funny, but the resulting template will look ok. If you dislike the way the intending looks in the template, move the indent space in the tag, where it will be treated as empty space in the T4 code.

void DoSomething(object o) {
  Console.WriteLine("I'm an object");
}

void DoSomething(int o) {
  Console.WriteLine("I'm an int");
}

void Test() {
  int i=1;
  object o=i;
  DoSomething(i);
  DoSomething(o);
}

void DoSomething(object o) {
  Console.WriteLine("I'm an object");
}

void DoSomething(int o) {
  Console.WriteLine("I'm an int");
}

void Test() {
  int i=1;
  object o=i;
  dynamic d=o;
  DoSomething(i);
  DoSomething(o);
  DoSomething(d);
}

• The base class from which all classes that determine behavior inherit (object if nothing specific)
• The routing method that receives at least a base class parameter
• The behavior methods that have as a parameter the subclasses of the base type
• The pattern implementation checker class

• The new behavior is encapsulated in methods in a static class
• The routing method receives as the first parameter the base type for the classes that should determine behavior
• The only code in the routing method is calling the private behavior method(s) using the same parameters as itself, except the first which is cast to dynamic
• The behavior methods usually are private methods having the same name as the routing methods, but ending in "handle"
• The routing method is decorated with [DynamicPattern("nameOfTheBehaviorMethods")]
• The routing method is decorated with [DynamicPatternIgnore(typeof(subClassToIgnore))] which tells the checker which classes do not need behavior implementations
• The static class containing the pattern has a static constructor that calls a method to check the implementation of the pattern
• The checker method is decorated with [Conditional("DEBUG")] so that it doesn't hinder the functionality of the program with slow reflection checks
• The checker method calls PatternChecker.CheckImplementation(typeof(staticClass)) or PatternChecker.CheckImplementation(typeof(class).Assembly)

public static class RequestHandler
{

static RequestHandler()
{
  checkDynamicPattern();
}

[Conditional("DEBUG")]
private static void checkDynamicPattern()
{
  PatternChecker.CheckImplementation(typeof(RequestHandler));
}

[DynamicPattern("getObjectsHandle")]
[DynamicPatternIgnore(typeof(BaseDeleteRequest))]
[DynamicPatternIgnore(typeof(DeleteUsersRequest))]
[DynamicPatternIgnore(typeof(DeleteCategoriesRequest))]
[DynamicPatternIgnore(typeof(DeleteDataRequest))]
[DynamicPatternIgnore(typeof(DeleteApplicationsRequest))]
[DynamicPatternIgnore(typeof(GetEntityRequest))]
[DynamicPatternIgnore(typeof(BaseObjectActionRequest))]
[DynamicPatternIgnore(typeof(GetEntitiesRequest))]
[DynamicPatternIgnore(typeof(GetEntityByIdRequest))]
[DynamicPatternIgnore(typeof(BatchOperationRequest))]
public static BaseEntitiesResponse GetObjects(BaseRequest request, Coordinator coordinator)
{
  return getObjectsHandle((dynamic)request, coordinator);
}

private static BaseEntitiesResponse getObjectsHandle(BaseRequest request, Coordinator coordinator)
{
  throw new ArgumentException("Cannot find a suitable getObjects method for type of request " +
                              request.GetType());
}

private static BaseEntitiesResponse getObjectsHandle(GetApplicationRequest request,
                                             Coordinator coordinator)
{
  DataObject entity = coordinator.ApplicationManager.GetObject(request.Id,
                                                               request.IncludeOptions);
  return getEntitiesResponse(entity);
}

var custom=obj as ICustom<T>;

checkIfCustom(obj);

private void checkIfCustom(object obj) {
  dynamicCheckIfCustom((dynamic)obj);
}

private void dynamicCheckIfCustom(object obj) {
  //do nothing
}

private void dynamicCheckIfCustom<T>(ICustom<T> iCustom) {
  doSomethingWith(iCustom);
}

• Clear the database
• Insert new items in the database
• Select the items from the database, with and without related items

protected virtual void RaisePostBackEvent(string eventArgument)
{
  base.ValidateEvent(this.UniqueID, eventArgument);
  if (base.IsEnabled)
  {
    if (base._adapter != null)
    {
      IPostBackEventHandler handler = 
                       base._adapter as IPostBackEventHandler;
      if (handler != null)
      {
        handler.RaisePostBackEvent(eventArgument);
      }
    }
    else ...