Attach to process for lazies

Attaching to a process is something that developers use very often to debug, but what happens when the process (A) you want to debug is launched from another process (B) and you want to debug is the initialization of process A, Supposing that process A can only run within the context of process B in that case the only way to start process A is to do so from process so classic F5 won't help us to debug the initialization of A.

I had this scenario at work so at first I "trained" myself to do a very fast Alt+Ctrl+P select the process and press Attach button, of course this training didn't help much, after googling a little I found this macro

  Sub AttachProcess()
        Dim process As EnvDTE.Process
 
        If Not (DTE.Debugger.DebuggedProcesses Is Nothing) Then
            For Each process In DTE.Debugger.DebuggedProcesses
                If (process.Name.IndexOf("aspnet_wp.exe") <> -1) Then
                    Exit Sub
                End If
            Next
        End If
 
        For Each process In DTE.Debugger.LocalProcesses
            If (process.Name.IndexOf("myprocess.exe") <> -1) Then
                process.Attach()
                Exit Sub
            End If
        Next
    End Sub 

but still it would have to wait for the process to start and then attach to it, so finally I created this Visual Studio add-in, which have this option.

The main idea is to wait for the process to start and then attach to it:

private AttachResult PessimisticAttach(AttachType attachType)
{
     AttachResult res = Attach(attachType);
     DateTime timeout = DateTime.Now.AddSeconds(WaitTimeout);
   
     while(res == AttachResult.NotRunning && timeout > DateTime.Now)
     {
           res = Attach(attachType);
           System.Threading.Thread.Sleep(100);
     }
     return res;
}
   
private AttachResult Attach(AttachType attachType)
{
     string engine =attachTypesMap[attachType];
     if(IsBeingDebugged())
     {
          return AttachResult.BeingDebugged;
     }
   
     Debugger2 dbg = dte.Debugger as Debugger2;
     Transport trans = dbg.Transports.Item("Default");
     Engine eng;
   
     eng = trans.Engines.Item(engine);
   
     EnvDTE80.Process2 proc = null;
   
     try
     {
          proc = dbg.GetProcesses(trans, "").Item(processName) 
              as EnvDTE80.Process2;
     }
     catch(Exception ex)
     {
          if(ex.Message.Contains("Invalid index."))
          {
              return AttachResult.NotRunning;
          }
     }
   
     proc.Attach2(eng);
     return AttachResult.Attached;
}

I wrote the add-in using Declarative Visual Studio addin buttons with icons which saved me a lot of time and pain.

You can download add in source here. 

Override WCF client settings for custom config file using DuplexChannel

WCF config files are a great thing, once you have everything configured you just need 2 or 3 lines of code and everything get parsed and you are able to consume the service. By default WCF configuration is stored in the app.config or web.config of the main application, but sometimes (as was my case) the client is in-process of another unknown application, if so the WCF config file will have to be named SomeApp.exe.config and would need to be placed in the same folder as the application. Dealing with this can make things difficult, this is when you have to create your own ChannelFactory, this way you can provide your own config file. The solution I found after doing some goggling was to inherit from ChannelFactoryand the pass the config file to the constructor

public CustomChannelFactory(string configurationPath): base(typeof(T))
{
this.configurationPath = configurationPath;
}

and the override CreateDescription method in which we set our config file. This works great, but not for my case since I was using a DuplexChannel, so when we inherith from DuplexChannelFactory we must call the base constructor with the CallBackInstance parameter, so the CreateDescription will be called before we can initialize the configurationPath member. The only solution I had in mind was make ConfigurationPath to be static member and then we initialize this before we create the instance of our CustomDuplexChannel, this solution seemed "ugly" for me at first but then I realized that the configuration can be stored in a static member since we are planning to use one configuration file for consuming all our services.

public class CustomDuplexChannelFactory<TChannel> : DuplexChannelFactory<TChannel>
 {
     public static string ConfigurationPath { get; set; }

     public CustomDuplexChannelFactory(InstanceContext callbackInstance)
         : base(callbackInstance)
     {
     }

     protected override ServiceEndpoint CreateDescription()
     {
         ServiceEndpoint serviceEndpoint = base.CreateDescription();
         if(ConfigurationPath == null || !File.Exists(ConfigurationPath))
             return base.CreateDescription();

         ExeConfigurationFileMap executionFileMap = new ExeConfigurationFileMap();
         executionFileMap.ExeConfigFilename = ConfigurationPath;

         System.Configuration.Configuration config =
             ConfigurationManager.OpenMappedExeConfiguration(
             executionFileMap, ConfigurationUserLevel.None);
         ServiceModelSectionGroup serviceModeGroup =
             ServiceModelSectionGroup.GetSectionGroup(config);

         ChannelEndpointElement selectedEndpoint = null;

         foreach(ChannelEndpointElement endpoint in serviceModeGroup.Client.Endpoints)
         {
             if(endpoint.Contract == serviceEndpoint.Contract.ConfigurationName)
             {
                 selectedEndpoint = endpoint;
                 break;
             }
         }

         if(selectedEndpoint != null)
         {
             if(serviceEndpoint.Binding == null)
             {
                 serviceEndpoint.Binding = CreateBinding(selectedEndpoint.Binding, serviceModeGroup);
             }

             if(serviceEndpoint.Address == null)
             {
                 serviceEndpoint.Address = new EndpointAddress(selectedEndpoint.Address,
                     GetIdentity(selectedEndpoint.Identity), selectedEndpoint.Headers.Headers);
             }

             if(serviceEndpoint.Behaviors.Count == 0 &&
                 !String.IsNullOrEmpty(selectedEndpoint.BehaviorConfiguration))
             {
                 AddBehaviors(selectedEndpoint.BehaviorConfiguration,
                     serviceEndpoint, serviceModeGroup);
             }

             serviceEndpoint.Name = selectedEndpoint.Contract;
         }

         return serviceEndpoint;
     }

     #region private

     private Binding CreateBinding(string bindingName, ServiceModelSectionGroup group)
     {
         BindingCollectionElement bindingElementCollection = group.Bindings[bindingName];
         if(bindingElementCollection.ConfiguredBindings.Count > 0)
         {
             IBindingConfigurationElement be = bindingElementCollection.ConfiguredBindings[0];

             Binding binding = GetBinding(be);
             if(be != null)
             {
                 be.ApplyConfiguration(binding);
             }

             return binding;
         }

         return null;
     }

     private void AddBehaviors(string behaviorConfiguration, ServiceEndpoint serviceEndpoint,
         ServiceModelSectionGroup group)
     {
         EndpointBehaviorElement behaviorElement =
             group.Behaviors.EndpointBehaviors[behaviorConfiguration];
         for(int i = 0; i < behaviorElement.Count; i++)
         {
             BehaviorExtensionElement behaviorExtension = behaviorElement[i];
             object extension = behaviorExtension.GetType().InvokeMember("CreateBehavior",
             BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance,
             null, behaviorExtension, null);
             if(extension != null)
             {
                 serviceEndpoint.Behaviors.Add((IEndpointBehavior)extension);
             }
         }
     }

     private EndpointIdentity GetIdentity(IdentityElement element)
     {
         EndpointIdentity identity = null;
         PropertyInformationCollection properties = element.ElementInformation.Properties;
         if(properties["userPrincipalName"].ValueOrigin != PropertyValueOrigin.Default)
         {
             return EndpointIdentity.CreateUpnIdentity(element.UserPrincipalName.Value);
         }
         if(properties["servicePrincipalName"].ValueOrigin != PropertyValueOrigin.Default)
         {
             return EndpointIdentity.CreateSpnIdentity(element.ServicePrincipalName.Value);
         }
         if(properties["dns"].ValueOrigin != PropertyValueOrigin.Default)
         {
             return EndpointIdentity.CreateDnsIdentity(element.Dns.Value);
         }
         if(properties["rsa"].ValueOrigin != PropertyValueOrigin.Default)
         {
             return EndpointIdentity.CreateRsaIdentity(element.Rsa.Value);
         }
         if(properties["certificate"].ValueOrigin != PropertyValueOrigin.Default)
         {
             X509Certificate2Collection supportingCertificates = new X509Certificate2Collection();
             supportingCertificates.Import(Convert.FromBase64String(element.Certificate.EncodedValue));
             if(supportingCertificates.Count == 0)
             {
                 throw new InvalidOperationException("UnableToLoadCertificateIdentity");
             }
             X509Certificate2 primaryCertificate = supportingCertificates[0];
             supportingCertificates.RemoveAt(0);
             return EndpointIdentity.CreateX509CertificateIdentity(primaryCertificate,
                 supportingCertificates);
         }

         return identity;
     }

     private Binding GetBinding(IBindingConfigurationElement configurationElement)
     {
         if(configurationElement is CustomBindingElement)
             return new CustomBinding();
         else if(configurationElement is BasicHttpBindingElement)
             return new BasicHttpBinding();
         else if(configurationElement is NetMsmqBindingElement)
             return new NetMsmqBinding();
         else if(configurationElement is NetNamedPipeBindingElement)
             return new NetNamedPipeBinding();
         else if(configurationElement is NetPeerTcpBindingElement)
             return new NetPeerTcpBinding();
         else if(configurationElement is NetTcpBindingElement)
             return new NetTcpBinding();
         else if(configurationElement is WSDualHttpBindingElement)
             return new WSDualHttpBinding();
         else if(configurationElement is WSHttpBindingElement)
             return new WSHttpBinding();
         else if(configurationElement is WSFederationHttpBindingElement)
             return new WSFederationHttpBinding();

         return null;
     }
 }