After hours and hours of searching between a coworker and I as to why an assembly version forwarding in this dll hell we’ve caused ourself wasn’t working in one project and it was in another, we explored every possibility we could think of:

1. Manually searching assemblies for manual loads
2. Searching the CLR for the location of runtime forwarding programatically (and failed)
3. Copying and pasting the exact same text from seperate configuration files known to be working in hopes of success
4. Sacrificing a kitten

All to no avail. After searching, and searching more I finaally ran across this awesome Microsoft Social post where someone mentioned that the configuration element having an xmlns would cause runtime to be ignored. Surely, this couldn’t be the case, but a quick test proved it to in fact be a solution.

So, to summarize:

Bad:

Good:

New one to me…

                if (nhType.IsCollectionType)
                {
                    object propertyValue = propertyInfo.GetValue(unproxiedObject, null);
                    if (propertyValue == null)
                        continue;
                    if (propertyValue is PersistentBag)
                    {
                        PersistentBag holder = (PersistentBag)propertyValue;
                        for (int j = 0; j < holder.Count; j++)
                        {
                            holder[j] = holder[j].UnproxyObjectTree(sessionFactory, maxDepth - 1);
                        }

                        propertyInfo.SetValue(
                            unproxiedObject,
                            holder,
                            null);
                    }
                    else if (propertyValue is ISet)
                    {
                        ISet holder = (ISet)propertyValue;
                        ArrayList tempcoll = new ArrayList();
                        foreach (object o in (IEnumerable)propertyValue)
                        {
                            tempcoll.Add(o);
                        }
                        for (int j = 0; j < tempcoll.Count; j++)
                        {
                            tempcoll[j] = tempcoll[j].UnproxyObjectTree(sessionFactory, maxDepth - 1);
                        }
                        holder.Clear();
                        holder.AddAll(tempcoll);
                        propertyInfo.SetValue(
                            unproxiedObject,
                            holder,
                            null);
                    }
                    continue;
                }

Of course we come into the issue of thread locking, and of course Invoke must be used. We’re in .NET 3.5, might as well get some of the benefits of the latest framework, right? Well, turned out to be a bit more confusing than I first thought.

Ex:

      delegate bool GetBoolDelegate();
      int GetBoolValue()
      {
         if (!InvokeRequired)
            return (bool)vart.SelectedIndex;
         else
            return (bool)Invoke(new GetBoolDelegate(GetBoolValue), null);
      }

The pre 2.0 way of doing things, move along and try:

            bool regchecked = (bool)this.Invoke(
                  delegate()
                  {
                     return chkRegression.Checked;
                  }
               );

Which gives the following error:

Cannot convert anonymous method to type ‘System.Delegate’ because it is not a delegate type

There are several ways around this, the easiest is:

      public delegate bool MethodBoolInvoke();
            bool regchecked = (bool)this.Invoke(
                  (MethodBoolInvoke)delegate()
                  {
                     return chkRegression.Checked;
                  }
               );

And, the final simple example of invoking for general items:

this.Invoke( (MethodInvoker)delegate() {this.Cursor = Cursors.WaitCursor; });

Alas, MSDN has a solution:

http://msdn.microsoft.com/en-us/library/f1z20s6z.aspx

Just keep in mind it will overwrite some other format settings if you have them set.

Cute except that without that table being able to be accessed no requests would technically go through. The workaround? Simply do small units of work at a time:

WHILE 1=1
BEGIN
      DELETE  TOP (1000)
      FROM    [db].[dbo].[table]
      WHERE  Expires < @now;

      IF @@rowcount = 0 BREAK;
END

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Threading;
using System.IO;

namespace t
{
   class Program
   {

      static void Main(string[] args)
      {

         Program.ProcessChecker.Proc();
         Console.ReadLine();
      }

      static class ProcessChecker
      {

         internal static class NativeMethods
         {
            [DllImport("user32.dll")]
            public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);

            [DllImport("user32.dll")]
            public static extern bool SetForegroundWindow(IntPtr hWnd);

            [DllImport("user32.dll")]
            public static extern bool EnumWindows(EnumWindowsProcDel lpEnumFunc,
                Int32 lParam);

            [DllImport("user32.dll")]
            public static extern uint GetWindowThreadProcessId(IntPtr hWnd,
                ref Int32 lpdwProcessId);

            [DllImport("user32.dll")]
            public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString,
                Int32 nMaxCount);

            [DllImport("user32.dll")]
            public static extern bool SetWindowText(IntPtr hWnd, string lpString);

            [DllImport("user32.dll")]
            public static extern int GetFocus();

            [DllImport("user32.dll")]
            public static extern bool AttachThreadInput(uint idAttach, uint idAttachTo, bool fAttach);

            [DllImport("kernel32.dll")]
            public static extern uint GetCurrentThreadId();

            [DllImport("user32.dll")]
            public static extern uint GetWindowThreadProcessId(int hWnd, int ProcessId);

            [DllImport("user32.dll")]
            public static extern int GetForegroundWindow();

            [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)]
            public static extern int SendMessage(int hWnd, int Msg, int wParam, StringBuilder lParam);

            [DllImport("user32.dll", CharSet = CharSet.Auto)]
            public static extern int GetClassName(IntPtr hWnd, StringBuilder lpClassName, int nMaxCount);

            [DllImport("user32.dll", SetLastError = true)]
            public static extern IntPtr GetWindow(IntPtr hWnd, uint uCmd);

            public enum GetWindow_Cmd : uint
            {
               GW_HWNDFIRST = 0,
               GW_HWNDLAST = 1,
               GW_HWNDNEXT = 2,
               GW_HWNDPREV = 3,
               GW_OWNER = 4,
               GW_CHILD = 5,
               GW_ENABLEDPOPUP = 6
            }

            public const int SW_SHOWNORMAL = 1;
         }
         const int WM_SETTEXT = 12;
         const int WM_GETTEXT = 13;
         public delegate bool EnumWindowsProcDel(IntPtr hWnd, Int32 lParam);

         static private bool EnumWindowsProc(IntPtr hWnd, Int32 lParam)
         {
            int processId = 0;
            uint remoteThreadId = NativeMethods.GetWindowThreadProcessId(hWnd, ref processId);
            StringBuilder WindowText = new StringBuilder(5000);

            NativeMethods.GetWindowText(hWnd, WindowText, 5000);
            StringBuilder v_szbTest2 = new StringBuilder(99);
            NativeMethods.GetClassName(hWnd, v_szbTest2, 99);
            if (WindowText.ToString().Equals("Save As") && processId.Equals(lParam))
            {
               uint currentThreadId = NativeMethods.GetCurrentThreadId();
               NativeMethods.AttachThreadInput(remoteThreadId, currentThreadId, true);

               IntPtr i = IntPtr.Zero;
               i = NativeMethods.GetWindow(hWnd, (uint)NativeMethods.GetWindow_Cmd.GW_CHILD);
               for (; i.ToInt32() > 0; )
               {

                  i = NativeMethods.GetWindow(i, (uint)NativeMethods.GetWindow_Cmd.GW_HWNDNEXT);
                  StringBuilder v_szbTest3 = new StringBuilder(99);
                  NativeMethods.GetClassName(i, v_szbTest3, 99);

                  StringBuilder builder = new StringBuilder(500);
                  builder.Append("c:\\Hey look a text.xls");
                  if (v_szbTest3.ToString().Equals("ComboBoxEx32"))
                  {
                     NativeMethods.SendMessage(i.ToInt32(), WM_SETTEXT, builder.Capacity, builder);
                  }
                  StringBuilder v_szbText = new StringBuilder(256);
                  NativeMethods.GetWindowText(i, v_szbText, 256);
                  if (v_szbTest3.ToString().Equals("Button") && v_szbText.ToString().Equals("&Save"))
                  {
                     //Save!
                     var BM_CLICK = 0xf5;
                     NativeMethods.SendMessage(i.ToInt32(), BM_CLICK, 0, builder);
                     NativeMethods.AttachThreadInput(remoteThreadId, currentThreadId, false);
                     //Lets wait till we can access the file.

                     while (true)
                     {
                        try
                        {
                           FileStream fso = File.Open(builder.ToString() + ".xls", FileMode.Open, FileAccess.Write);
                           fso.Close();
                           //kill our proc
                           Process moc = Process.GetProcessById(lParam);
                           moc.Kill();
                           return true;
                        }
                        catch (IOException x)
                        {
                           Console.WriteLine(x);
                           Thread.Sleep(10);
                        }
                     }

                  }

               }

            }
            return true;
         }

         static public bool Proc()
         {

            Process[] v_oProcs = Process.GetProcesses();
            foreach (Process proc in v_oProcs)
            {
               if (proc.ProcessName.Equals("Moc"))
               {
                  NativeMethods.EnumWindows(new EnumWindowsProcDel(EnumWindowsProc),
                      proc.Id);
                  return false;
               }
            }
            return true;
         }
      }

      #region EnumWindows
      /// 
      /// EnumWindows wrapper for .NET
      /// 
      public class EnumWindows
      {
         #region Delegates
         private delegate int EnumWindowsProc(IntPtr hwnd, int lParam);
         #endregion

         #region UnManagedMethods
         private class UnManagedMethods
         {
            [DllImport("user32")]
            public extern static int EnumWindows(
                EnumWindowsProc lpEnumFunc,
                int lParam);
            [DllImport("user32")]
            public extern static int EnumChildWindows(
                IntPtr hWndParent,
                EnumWindowsProc lpEnumFunc,
                int lParam);
         }
         #endregion

         #region Member Variables
         private List<IntPtr> items = null;
         #endregion

         /// 
         /// Returns the collection of windows returned by
         /// GetWindows
         /// 
         public List<IntPtr> Items
         {
            get
            {
               return this.items;
            }
         }

         /// 
         /// Gets all top level windows on the system.
         /// 
         public void GetWindows()
         {
            this.items = new List<IntPtr>();
            UnManagedMethods.EnumWindows(
                new EnumWindowsProc(this.WindowEnum),
                0);
         }

         /// 
         /// Gets all child windows of the specified window
         /// 
         /// Window Handle to get children for
         public void GetWindows(
             IntPtr hWndParent)
         {
            this.items = new List<IntPtr>();
            UnManagedMethods.EnumChildWindows(
                hWndParent,
                new EnumWindowsProc(this.WindowEnum),
                0);
         }

         #region EnumWindows callback
         /// 
         /// The enum Windows callback.
         /// 
         /// Window Handle
         /// Application defined value
         /// 1 to continue enumeration, 0 to stop
         private int WindowEnum(
             IntPtr hWnd,
             int lParam)
         {
            if (this.OnWindowEnum(hWnd))
            {
               return 1;
            }
            else
            {
               return 0;
            }
         }
         #endregion

         /// 
         /// Called whenever a new window is about to be added
         /// by the Window enumeration called from GetWindows.
         /// If overriding this function, return true to continue
         /// enumeration or false to stop.  If you do not call
         /// the base implementation the Items collection will
         /// be empty.
         /// 
         /// Window handle to add
         /// True to continue enumeration, False to stop
         protected virtual bool OnWindowEnum(
             IntPtr hWnd)
         {
            items.Add(hWnd);
            return true;
         }

         #region Constructor, Dispose
         public EnumWindows()
         {
            // nothing to do
         }
         #endregion
      }
      #endregion EnumWindows

   }

}

SELECT E.ID, E.Field, r.Field2 from EntitySet AS E INNER JOIN Entity2Set AS r ON r.Entity = E

Which creates our flattened list of Entities for us based on the defined relationship.

Secondly: EntityDataSource and 1-1 relationships/child objects/picklists. This is much easier to do via the Entity framework and is simply defined via the “Include” parameter.

Ex:

   <asp:EntityDataSource ID="x_EntityDataSource" runat="server"
      ConnectionString="name=DataEntities"
      DefaultContainerName="DataEntities" Where="it.ID = @EntityID"
      EntitySetName="EntitySet" EnableUpdate="True" Include="SubEntity">
      <WhereParameters>
         <asp:QueryStringParameter Name="EntityId" QueryStringField="ID" Type="Int32" />
      </WhereParameters>
   </asp:EntityDataSource>

Which provides us with the Entity, and a secondary child Entity which is an FK relationship to a single value.
And, lastly some great posts from the Microsoft team:
http://blogs.msdn.com/diego/archive/2008/05/13/entitydatasource-to-wrap-or-not-to-wrap.aspx
http://blogs.msdn.com/diego/archive/2008/05/24/entitydatasource-s-flattening-of-complex-type-properties.aspx

http://blogs.msdn.com/zlatkom/archive/2007/07/10/entity-sql.aspx

         ResourceReader v_oReader = new ResourceReader(typeof(T).Assembly.GetManifestResourceStream(typeof(T).FullName + "DataSource.resources"));
         try
         {
            foreach (DictionaryEntry entry in v_oReader)
            {
               if (entry.Value.ToString().Equals(p_szDisplayValue))
               {
                  return (T)(Enum.Parse(typeof(T), entry.Key.ToString()));
               }
            }
            throw new ApplicationException(String.Format("Unable to match value for '{0}'.", p_szDisplayValue ));
         }
         finally
         {
            v_oReader.Close();
            v_oReader = null;
         }

Where T is the Enum, and this code assumes that the embedded resx file is stored at Namespace.EnumDataSource.resources