C# TypeMirror.GetMethods方法代码示例

 public ExpandedProperty(TypeMirror typeMirror, StackFrame frame, LocalVariable localVariable)
 {
     this.frame = frame;
     this.localVariable = localVariable;
     var properties = typeMirror.GetProperties().Cast<Mirror>();
     var methods = typeMirror.GetMethods().Cast<Mirror>();
     var fields = typeMirror.GetFields().Cast<Mirror>();
     var children = properties.Concat(methods).Concat(fields);
     allProperties = children.ToList();
 }

		Location GetLocFromType (TypeMirror type, string file, int line)
		{
			Location target_loc = null;
			foreach (MethodMirror m in type.GetMethods ()) {
				foreach (Location l in m.Locations) {
					if (PathComparer.Compare (PathToFileName (l.SourceFile), file) == 0 && l.LineNumber == line) {
						target_loc = l;
						break;
					}
				}
				if (target_loc != null)
					break;
			}
	
			return target_loc;
		}

		Location GetLocFromType (TypeMirror type, string file, int line, out bool genericMethod, out bool insideTypeRange)
		{
			Location target_loc = null;
			bool fuzzy = true;
			
			insideTypeRange = false;
			genericMethod = false;
			
			//Console.WriteLine ("Trying to resolve {0}:{1} in type {2}", file, line, type.Name);
			foreach (MethodMirror method in type.GetMethods ()) {
				int rangeFirstLine = int.MaxValue;
				int rangeLastLine = -1;
				
				foreach (Location location in method.Locations) {
					string srcFile = location.SourceFile;
					
					//Console.WriteLine ("\tExamining {0}:{1}...", srcFile, location.LineNumber);
					
					if (srcFile != null && PathComparer.Compare (PathToFileName (NormalizePath (srcFile)), file) == 0) {
						if (location.LineNumber < rangeFirstLine)
							rangeFirstLine = location.LineNumber;
						
						if (location.LineNumber > rangeLastLine)
							rangeLastLine = location.LineNumber;
						
						if (line >= rangeFirstLine && line <= rangeLastLine)
							insideTypeRange = true;
						
						// If we are inserting a breakpoint in line L, but L+1 has the same IL offset as L,
						// pick the L+1 location, since that's where the debugger is going to stop.
						if (location.LineNumber >= line && line >= rangeFirstLine) {
							if (target_loc != null) {
								if (location.LineNumber > line) {
									if (target_loc.LineNumber - line > location.LineNumber - line) {
										// Grab the location closest to the requested line
										//Console.WriteLine ("\t\tLocation is closest match");
										target_loc = location;
									} else if (location.ILOffset == target_loc.ILOffset) {
										// Grab the last location with the same ILOffset
										//Console.WriteLine ("\t\tLocation has same ILOffset");
										target_loc = location;
									}
								} else {
									// Line number matches exactly
									//Console.WriteLine ("\t\tLocation matches exactly.");
									target_loc = location;
									fuzzy = false;
								}
							} else {
								//Console.WriteLine ("\t\tLocation is first possible match");
								fuzzy = location.LineNumber != line;
								target_loc = location;
							}
						}
					} else {
						rangeFirstLine = int.MaxValue;
						rangeLastLine = -1;
					}
				}
				
				if (target_loc != null) {
					genericMethod = IsGenericMethod (method);
					
					// If we got a fuzzy match, then we need to make sure that there isn't a better
					// match in another method (e.g. code might have been extracted out into another
					// method by the compiler.
					if (!fuzzy)
						return target_loc;
				}
			}
			
			if (target_loc != null && fuzzy && CheckBetterMatch (type, file, line, target_loc)) {
				insideTypeRange = false;
				return null;
			}
			
			return target_loc;
		}

		Location GetLocFromType (TypeMirror type, string file, int line, out bool genericMethod, out bool insideTypeRange)
		{
			Location target_loc = null;
			bool fuzzy = true;
			
			insideTypeRange = false;
			genericMethod = false;
			
			//Console.WriteLine ("Trying to resolve {0}:{1} in type {2}", file, line, type.Name);
			foreach (MethodMirror method in type.GetMethods ()) {
				int rangeFirstLine = int.MaxValue;
				int rangeLastLine = -1;
				
				foreach (Location location in method.Locations) {
					string srcFile = location.SourceFile;
					
					//Console.WriteLine ("\tExamining {0}:{1}...", srcFile, location.LineNumber);

					if (srcFile != null && PathsAreEqual (PathToFileName (NormalizePath (srcFile)), file)) {
						if (location.LineNumber < rangeFirstLine)
							rangeFirstLine = location.LineNumber;
						
						if (location.LineNumber > rangeLastLine)
							rangeLastLine = location.LineNumber;
						
						if (line >= rangeFirstLine && line <= rangeLastLine)
							insideTypeRange = true;

						if (location.LineNumber >= line && line >= rangeFirstLine) {
							if (target_loc != null) {
								if (location.LineNumber > line) {
									if (target_loc.LineNumber - line > location.LineNumber - line) {
										// Grab the location closest to the requested line
										//Console.WriteLine ("\t\tLocation is closest match. (ILOffset = 0x{0:x5})", location.ILOffset);
										target_loc = location;
									}
								} else if (target_loc.LineNumber != line) {
									// Previous match was a fuzzy match, but now we've found an exact line match
									//Console.WriteLine ("\t\tLocation is exact line match. (ILOffset = 0x{0:x5})", location.ILOffset);
									target_loc = location;
									fuzzy = false;
								} else if (location.ILOffset < target_loc.ILOffset) {
									// Line number matches exactly, but has an earlier ILOffset
									//Console.WriteLine ("\t\tLocation has an earlier ILOffset. (ILOffset = 0x{0:x5})", location.ILOffset);
									target_loc = location;
									fuzzy = false;
								}
							} else {
								//Console.WriteLine ("\t\tLocation is first possible match. (ILOffset = 0x{0:x5})", location.ILOffset);
								fuzzy = location.LineNumber != line;
								target_loc = location;
							}
						}
					} else {
						rangeFirstLine = int.MaxValue;
						rangeLastLine = -1;
					}
				}
				
				if (target_loc != null) {
					genericMethod = IsGenericMethod (method);
					
					// If we got a fuzzy match, then we need to make sure that there isn't a better
					// match in another method (e.g. code might have been extracted out into another
					// method by the compiler.
					if (!fuzzy)
						return target_loc;
				}
			}
			
			if (target_loc != null && fuzzy && CheckBetterMatch (type, file, line, target_loc)) {
				insideTypeRange = false;
				return null;
			}
			
			return target_loc;
		}

		void ResolveBreakpoints (TypeMirror type)
		{
			var resolved = new List<BreakInfo> ();
			string typeName = type.FullName;
			Location loc;
			
			ProcessType (type);
			
			// First, resolve FunctionBreakpoints
			foreach (var bi in pending_bes.Where (b => b.BreakEvent is FunctionBreakpoint)) {
				var bp = (FunctionBreakpoint) bi.BreakEvent;
				int dot = bp.FunctionName.LastIndexOf ('.');
				string ftypeName = bp.FunctionName.Substring (0, dot);
				
				if (ftypeName == typeName) {
					string methodName = bp.FunctionName.Substring (dot + 1);
					
					if (vm.Version.AtLeast (2, 6)) {
						foreach (var method in type.GetMethodsByNameFlags (methodName, BindingFlags.Default, false)) {
							if (!CheckMethodParams (method, bp.ParamTypes))
								continue;
							
							loc = GetLocFromMethod (method);
							if (loc != null) {
								string paramList = bp.ParamTypes != null ? "(" + string.Join (",", bp.ParamTypes) + ")" : "";
								OnDebuggerOutput (false, string.Format ("Resolved pending breakpoint for '{0}{1}' to {2}:{3} [0x{4:x5}].\n",
								                                        bp.FunctionName, paramList, loc.SourceFile, loc.LineNumber, loc.ILOffset));
								
								if (bp.ParamTypes == null)
									bp.ParamTypes = GetParamTypes (method);
								
								bp.SetResolvedFileName (loc.SourceFile);
								ResolvePendingBreakpoint (bi, loc);
								
								// Note: if the type or method is generic, there may be more instances so don't assume we are done resolving the breakpoint
								if (!type.IsGenericType && !IsGenericMethod (method))
									resolved.Add (bi);
								break;
							}
						}
					} else {
						foreach (var method in type.GetMethods ()) {
							if (method.Name != methodName || !CheckMethodParams (method, bp.ParamTypes))
								continue;
							
							loc = GetLocFromMethod (method);
							if (loc != null) {
								string paramList = bp.ParamTypes != null ? "(" + string.Join (",", bp.ParamTypes) + ")" : "";
								OnDebuggerOutput (false, string.Format ("Resolved pending breakpoint for '{0}{1}' to {2}:{3} [0x{4:x5}].\n",
								                                        bp.FunctionName, paramList, loc.SourceFile, loc.LineNumber, loc.ILOffset));
								
								if (bp.ParamTypes == null)
									bp.ParamTypes = GetParamTypes (method);
								
								bp.SetResolvedFileName (loc.SourceFile);
								ResolvePendingBreakpoint (bi, loc);
								
								// Note: if the type or method is generic, there may be more instances so don't assume we are done resolving the breakpoint
								if (!type.IsGenericType /* && !IsGenericMethod (method)*/)
									resolved.Add (bi);
								break;
							}
						}
					}
				}
			}
			
			foreach (var be in resolved)
				pending_bes.Remove (be);
			resolved.Clear ();

			// Now resolve normal Breakpoints
			foreach (string s in type_to_source [type]) {
				foreach (var bi in pending_bes.Where (b => b.BreakEvent is Breakpoint)) {
					var bp = (Breakpoint) bi.BreakEvent;
					if (PathComparer.Compare (PathToFileName (bp.FileName), s) == 0) {
						bool insideLoadedRange;
						bool genericMethod;
						
						loc = GetLocFromType (type, s, bp.Line, out genericMethod, out insideLoadedRange);
						if (loc != null) {
							OnDebuggerOutput (false, string.Format ("Resolved pending breakpoint at '{0}:{1}' to {2} [0x{3:x5}].\n",
							                                        s, bp.Line, loc.Method.FullName, loc.ILOffset));
							ResolvePendingBreakpoint (bi, loc);
							
							// Note: if the type or method is generic, there may be more instances so don't assume we are done resolving the breakpoint
							if (!genericMethod && !type.IsGenericType)
								resolved.Add (bi);
						} else {
							if (insideLoadedRange) {
								bi.SetStatus (BreakEventStatus.Invalid, null);
							}
						}
					}
				}
				
				foreach (var be in resolved)
					pending_bes.Remove (be);
				resolved.Clear ();
			}
//.........这里部分代码省略.........

		Location GetLocFromType (TypeMirror type, string file, int line, out bool insideTypeRange)
		{
			Location target_loc = null;
			insideTypeRange = false;
			
			foreach (MethodMirror m in type.GetMethods ())
			{
				int rangeFirstLine = -1;
				int rangeLastLine = -1;
				
				foreach (Location l in m.Locations) {
					if (PathComparer.Compare (PathToFileName (l.SourceFile), file) == 0) {
						// If we are inserting a breakpoint in line L, but L+1 has the same IL offset as L,
						// pick the L+1 location, since that's where the debugger is going to stop.
						if (l.LineNumber == line) {
							if (target_loc == null)
								target_loc = l;
						}
						else if (target_loc != null) {
							if (target_loc.ILOffset == l.ILOffset)
								target_loc = l;
							else
								break;
						}
						rangeLastLine = l.LineNumber;
						if (rangeFirstLine == -1)
							rangeFirstLine = l.LineNumber;
					} else {
						if (rangeFirstLine != -1 && line >= rangeFirstLine && line <= rangeLastLine) {
							insideTypeRange = true;
							return null;
						}
						rangeFirstLine = -1;
					}
				}
				if (target_loc != null)
					break;
				if (rangeFirstLine != -1 && line >= rangeFirstLine && line <= rangeLastLine) {
					insideTypeRange = true;
					return null;
				}
			}
	
			return target_loc;
		}

		Location GetLocFromType (TypeMirror type, string file, int line)
		{
			Location target_loc = null;
			foreach (MethodMirror m in type.GetMethods ()) {
				foreach (Location l in m.Locations) {
					if (PathComparer.Compare (PathToFileName (l.SourceFile), file) == 0) {
						// If we are inserting a breakpoint in line L, but L+1 has the same IL offset as L,
						// pick the L+1 location, since that's where the debugger is going to stop.
						if (l.LineNumber == line) {
							if (target_loc == null)
								target_loc = l;
						}
						else if (target_loc != null) {
							if (target_loc.ILOffset == l.ILOffset)
								target_loc = l;
							else
								break;
						}
					}
				}
				if (target_loc != null)
					break;
			}
	
			return target_loc;
		}

		Location GetLocFromType (TypeMirror type, string file, int line)
		{
			Location target_loc = null;
			foreach (MethodMirror m in type.GetMethods ()) {
				foreach (Location l in m.Locations) {
					if (l.SourceFile == file && l.LineNumber == line) {
						target_loc = l;
						break;
						}
				}
				if (target_loc != null)
					break;
			}
	
			return target_loc;
		}

        void MarkType( TypeMirror t )
        {
            MarkAssembly( t.Assembly );

            if ( loadedTypes.Contains( t.FullName ) ) return;

            Log("adding matched type {0}",t.FullName);

            loadedTypes.Add( t.FullName );

            var meths = t.GetMethods ();
            // make a record for all methods defined by this type
            foreach (var m in meths) {
                CodeRecord rec;
                if (!records.TryGetValue (m.FullName, out rec)) {
                    Log("adding matched method {0}",m.FullName);
                    rec = new CodeRecord () { 
                        ClassName = m.DeclaringType.CSharpName,
                        Assembly = m.DeclaringType.Assembly.GetName().FullName,
                        Name = m.Name,
                        FullMethodName = m.FullName,
                        SourceFile = m.SourceFile,
                    };
                    rec.AddLines( m.LineNumbers.ToArray() );
                    
                    if (!bps.ContainsKey (m.FullName)) {
                        bps [m.FullName] = new List<BreakPoint> ();
                        // add a break on each line
                        Log("adding {0} breakpoints", m.Locations.Count);
                        foreach (var l in m.Locations) {
                            var bp = VirtualMachine.CreateBreakpointRequest (l);
                            var b = new BreakPoint () { Location = l, Record = rec, Request = bp };
                            bps [m.FullName].Add (b);
                            rbps [bp] = b;
                            bp.Enabled = true;
                        }
                    }
                    
                    records.Add (m.FullName, rec);
                    DataStore.RegisterMethod (rec);
                } 
            }



        }