C#

string inputValue = "5.5";

double numericValue;
if (double.TryParse(inputValue, NumberStyles.Any, CultureInfo.InvariantCulture, out numericValue))
{
    // The input has been successfully converted to a number.
    // The numericValue variable contains the number.
}
else
{
    // The input could not be converted to a number.
}

Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");

addHandlerMethod2.Invoke(null, new object[] {_WeakBoundObject.Target.GetType().GetProperty(PropertyName).GetValue(_WeakBoundObject.Target), "CollectionChanged", handler });

Kenneth Haugland wrote:

but I hate reflection

public static void LocalProcesses(DTE dte)
{
    ...
    EnvDTE.Processes processes = dte.Debugger.LocalProcesses;

OriginalGriff wrote:

you want the instance that is passed in as the method parameter in the example:

Kevin Marois wrote:

What parameter? What example are you referring to?

DTE dte = (DTE)System.Runtime.InteropServices.Marshal.GetActiveObject("VisualStudio.DTE.14.0");

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using EnvDTE;

namespace MyApp
{
    public static class IISDebugAttach
    {
        public static void AttachToIIS()
        {
            // Register the IOleMessageFilter to handle any threading errors.
            MessageFilter.Register();

            DTE dte = (DTE)System.Runtime.InteropServices.Marshal.GetActiveObject("VisualStudio.DTE.14.0");

            var listProcess = new List<string>();
            listProcess.Add("iisexpress");

            var processes = dte.Debugger.LocalProcesses;

            try
            {
                foreach (Process process in processes)
                {
                    foreach (var processName in listProcess)
                    {
                        if (!string.IsNullOrEmpty(process.Name))
                        {
                            string procName = process.Name;

                            if (procName.ToLower().IndexOf(processName, StringComparison.Ordinal) != -1)
                            {
                                process.Attach();
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                int x = 1;
            }

            // Clear thread issue filter
            MessageFilter.Revoke();
        }

        public class MessageFilter : IOleMessageFilter
        {
            //
            // Class containing the IOleMessageFilter
            // thread error-handling functions.

            // Start the filter.
            public static void Register()
            {
                IOleMessageFilter newFilter = new MessageFilter();
                IOleMessageFilter oldFilter = null;
                CoRegisterMessageFilter(newFilter, out oldFilter);
            }

            // Done with the filter, close it.
            public static void Revoke()
            {
                IOleMessageFilter oldFilter = null;
                CoRegisterMessageFilter(null, out oldFilter);
            }

            //
            // IOleMessageFilter functions.
            // Handle incoming thread requests.
            int IOleMessageFilter.HandleInComingCall(int dwCallType,
              System.IntPtr hTaskCaller, int dwTickCount, System.IntPtr
              lpInterfaceInfo)
            {
                //Return the flag SERVERCALL_ISHANDLED.
                return 0;
            }

            // Thread call was rejected, so try again.
            int IOleMessageFilter.RetryRejectedCall(System.IntPtr
              hTaskCallee, int dwTickCount, int dwRejectType)
            {
                if (dwRejectType == 2)
                // flag = SERVERCALL_RETRYLATER.
                {
                    // Retry the thread call immediately if return >=0 & 
                    // <100.
                    return 99;
                }
                // Too busy; cancel call.
                return -1;
            }

            int IOleMessageFilter.MessagePending(System.IntPtr hTaskCallee,
              int dwTickCount, int dwPendingType)
            {
                //Return the flag PENDINGMSG_WAITDEFPROCESS.
                return 2;
            }

            // Implement the IOleMessageFilter interface.
            [DllImport("Ole32.dll")]
            private static extern int
              CoRegisterMessageFilter(IOleMessageFilter newFilter, out
              IOleMessageFilter oldFilter);
        }

        [ComImport(), Guid("00000016-0000-0000-C000-000000000046"),
        InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
        interface IOleMessageFilter
        {
            [PreserveSig]
            int HandleInComingCall(
                int dwCallType,
                IntPtr hTaskCaller,
                int dwTickCount,
                IntPtr lpInterfaceInfo);

            [PreserveSig]
            int RetryRejectedCall(
                IntPtr hTaskCallee,
                int dwTickCount,
                int dwRejectType);

            [PreserveSig]
            int MessagePending(
                IntPtr hTaskCallee,
                int dwTickCount,
                int dwPendingType);
        }

    }
}