Пример #1
0
        IEnumerator IEnumerable.GetEnumerator()
        {
            var ret = new MDbgAppDomain[m_items.Count];

            m_items.Values.CopyTo(ret, 0);
            Array.Sort(ret);
            return(ret.GetEnumerator());
        }
Пример #2
0
        internal MDbgAppDomain Register(CorDebug.CorAppDomain appDomain)
        {
            MDbgAppDomain mdbgAppDomain;

            // appdomains may get registered mutliple times if we get a fake-attach event right before a real event.
            if (!m_items.Contains(appDomain))
            {
                mdbgAppDomain = new MDbgAppDomain(m_process, appDomain, m_freeAppDomainNumber++);
                m_items.Add(appDomain, mdbgAppDomain);
                return(mdbgAppDomain);
            }
            return((MDbgAppDomain)m_items[appDomain]);
        }
Пример #3
0
 /// <summary>
 /// Allows for indexing into the Collection by appDomainNumber
 /// </summary>
 /// <param name="appDomainNumber">Which appDomainNumber to access.</param>
 /// <returns>The MDbgAppDomain with the given number.</returns>
 public MDbgAppDomain this[int appDomainNumber]
 {
     get
     {
         MDbgAppDomain appDomain = null;
         foreach (MDbgAppDomain ad in m_items.Values)
         {
             if (ad.Number == appDomainNumber)
             {
                 appDomain = ad;
                 break;
             }
         }
         return(appDomain);
     }
 }
Пример #4
0
 /// <summary>
 /// Returns an appdomain from its name.
 /// </summary>
 /// <value>
 ///     Returns null if there is no appdomain with passed-in name.
 /// </value>
 /// <exception cref="MDbgAmbiguousModuleNameException">
 /// Thrown when there are multiple appdomains with same name.
 /// </exception>
 public MDbgAppDomain this[string appDomainName]
 {
     get
     {
         MDbgAppDomain appDomain = null;
         foreach (MDbgAppDomain ad in m_items.Values)
         {
             if (String.Compare(ad.CorAppDomain.Name, appDomainName) == 0)
             {
                 if (appDomain == null)
                 {
                     appDomain = ad;
                 }
                 else
                 {
                     throw new MDbgAmbiguousModuleNameException();
                 }
             }
         }
         return(appDomain);
     }
 }
 IEnumerator IEnumerable.GetEnumerator()
 {
     var ret = new MDbgAppDomain[m_items.Count];
     m_items.Values.CopyTo(ret, 0);
     Array.Sort(ret);
     return ret.GetEnumerator();
 }
        internal MDbgAppDomain Register(CorDebug.CorAppDomain appDomain)
        {
            MDbgAppDomain mdbgAppDomain;

            // appdomains may get registered mutliple times if we get a fake-attach event right before a real event.
            if (!m_items.Contains(appDomain))
            {
                mdbgAppDomain = new MDbgAppDomain(m_process, appDomain, m_freeAppDomainNumber++);
                m_items.Add(appDomain, mdbgAppDomain);
                return mdbgAppDomain;
            }
            return (MDbgAppDomain) m_items[appDomain];
        }
        /// <summary>
        /// Returns a string that represents current frame
        /// Currently supported formats:
        /// null or empty string: returns short frame format (just frame name)
        /// "v"                 : returns long frame format (including module &amp; arguments)
        /// </summary>
        /// <param name="format">Which format to use.</param>
        /// <returns>The formatted string that represtents the current frame.</returns>
        public override string ToString(string format)
        {
            string fn;

            switch (m_frame.FrameType)
            {
            case CorFrameType.ILFrame:
                MDbgSourcePosition sl = SourcePosition;
                string             sp;

                if (sl != null)
                {
                    string filePath = sl.Path;
                    if (!Thread.m_threadMgr.m_process.m_engine.Options.ShowFullPaths)
                    {
                        filePath = Path.GetFileName(sl.Path);
                    }
                    sp = " (" + filePath + ":" + sl.Line.ToString(CultureInfo.CurrentUICulture) + ")";
                }
                else
                {
                    sp = " (source line information unavailable)";
                }

                var sbFuncName = new StringBuilder();

                MDbgModule  module = Function.Module;
                MDbgProcess proc   = Thread.m_threadMgr.m_process;


                // Get class name w/ generic args.
                CorType tClass = FunctionType;
                if (tClass != null)
                {
                    InternalUtil.PrintCorType(sbFuncName, proc, tClass);
                }

                sbFuncName.Append('.');


                // Get method name w/ generic args.
                MethodInfo mi = Function.MethodInfo;
                sbFuncName.Append(mi.Name);
                InternalUtil.AddGenericArgs(sbFuncName, proc, FunctionTypeParameters);


                string stFuncName = sbFuncName.ToString();

                if (format == "v")
                {
                    CorModule m = module.CorModule;
                    // verbose frame output
                    // in verbose output we'll print module name + arguments to the functions
                    var  sb     = new StringBuilder();
                    bool bFirst = true;
                    foreach (MDbgValue v in Function.GetArguments(this))
                    {
                        if (sb.Length != 0)
                        {
                            sb.Append(", ");
                        }
                        // skip this references
                        if (!(bFirst && v.Name == "this"))
                        {
                            sb.Append(v.Name).Append("=").Append(v.GetStringValue(0));
                        }
                        bFirst = false;
                    }

                    if (m.IsDynamic || m.IsInMemory)
                    {
                        fn = m.Name;
                    }
                    else
                    {
                        fn = Path.GetFileName(m.Name);
                    }

                    MDbgAppDomain ad = Thread.m_threadMgr.m_process.AppDomains.Lookup(m.Assembly.AppDomain);
                    fn += "#" + ad.Number
                          + "!" + stFuncName + "(" + sb + ") " + sp;
                }
                else
                {
                    fn = stFuncName + sp;
                }
                break;

            case CorFrameType.NativeFrame:
                fn = "[IL Method without Metadata]";
                break;

            case CorFrameType.InternalFrame:
                switch (m_frame.InternalFrameType)
                {
                case CorDebugInternalFrameType.STUBFRAME_NONE:
                    fn = "None";
                    break;

                case CorDebugInternalFrameType.STUBFRAME_M2U:
                    fn = "M-->U";
                    break;

                case CorDebugInternalFrameType.STUBFRAME_U2M:
                    fn = "U-->M";
                    break;

                case CorDebugInternalFrameType.STUBFRAME_APPDOMAIN_TRANSITION:
                    fn = "AD Switch";
                    break;

                case CorDebugInternalFrameType.STUBFRAME_LIGHTWEIGHT_FUNCTION:
                    fn = "LightWeight";
                    break;

                case CorDebugInternalFrameType.STUBFRAME_FUNC_EVAL:
                    fn = "FuncEval";
                    break;

                case CorDebugInternalFrameType.STUBFRAME_INTERNALCALL:
                    fn = "InternalCall";
                    break;

                default:
                    fn = "UNKNOWN";
                    break;
                }
                fn = "[Internal Frame, '" + fn + "']";
                break;

            default:
                fn = "UNKNOWN Frame Type";
                break;
            }
            return(fn);
        }