C# MethodDefinition.GetFullName方法代码示例

	public bool IsSecurityCritical (MethodDefinition method)
	{
		string entry = method.GetFullName ();
		if (critical.Contains (entry))
			return true;

		TypeDefinition type = method.DeclaringType;
		if (!IsSecurityCritical (type))
			return false;

		switch (method.Name) {
		// e.g. everything we override from System.Object (which is transparent)
		case "Equals":
			return (method.Parameters.Count != 1 || method.Parameters [0].ParameterType.FullName != "System.Object");
		case "Finalize":
		case "GetHashCode":
		case "ToString":
			return method.HasParameters;
		// e.g. some transparent interfaces, like IDisposable (implicit or explicit)
		// downgrade some SC into SSC to respect the override/inheritance rules
		case "System.IDisposable.Dispose":
		case "Dispose":
			return method.HasParameters;
		default:
			return true;
		}
	}

	static void MarkAsSafeCritical (MethodDefinition method)
	{
		AssemblyDefinition ad = method.DeclaringType.Module.Assembly;
		List<string> list = methods [ad];
		string m = method.GetFullName ();
		if (!list.Contains (m))
			list.Add (m);
	}

//.........这里部分代码省略.........
		// skip signature check for visible API (we get them from find-sc)
		if (!sc && !method.IsVisible ()) {
			TypeReference rtype = method.ReturnType;
			if (!CheckType (rtype)) {
				sc = true;
				comment = String.Format ("using '{0}' as return type", rtype.FullName);
			}
		}

		// check if this method implements an interface where the corresponding member
		// is [SecurityCritical]
		TypeDefinition type = method.DeclaringType;
		if (!sc && type.HasInterfaces) {
			foreach (TypeReference intf in type.Interfaces) {
				TypeDefinition td = intf.Resolve ();
				if (td == null || !td.HasMethods)
					continue;
				foreach (MethodDefinition im in td.GetMethods ()) {
					if (im.IsSecurityCritical ()) {
						if (Compare (method, im)) {
							sc = true;
							comment = String.Format ("implements '{0}'.", im);
						}
					}
				}
			}
		}

		// if we're overriding a [SecurityCritical] method then we must be one too! or
		// if we are [SecurityCritical] then the base method needs to be too!
		if (method.IsVirtual && !method.IsAbstract) {
			TypeReference tr = method.DeclaringType.BaseType;
			if (tr != null) {
				TypeDefinition td = tr.Resolve ();
				if (td != null) {
					foreach (MethodDefinition bm in td.GetMethods ()) {
						if (Compare (method, bm)) {
							if (!sc) {
								if (bm.IsSecurityCritical ()) {
									sc = true;
									comment = String.Format ("overrides '{0}'.", bm);
								}
							} else {
								if (!bm.IsSecurityCritical ()) {
									string bms = bm.ToString ();
									if (!methods.ContainsKey (bms)) {
										comment = String.Format ("Promoting {0}base method to [SecurityCritical] because of '{1}'.", 
											bm.IsVisible () ? "[VISIBLE] " : String.Empty, method);
										methods.Add (bms, comment);
									}
								}
							}							
						}
					}
				}
			}
		} else {
			// note: we don't want to break the override rules above (resulting in TypeLoadException)
			// an icall that is NOT part of the visible API is considered as critical (like a p/invoke)
			if (method.IsInternalCall && !method.IsVisible ()) {
				sc = true;
				comment = "internal call";
			}
		}

		if (sc) {
			// note: add a warning on visible API since adding [SecurityCritical]
			// on "new" visible API would introduce incompatibility (so this needs
			// to be reviewed).
			if (method.IsVisible ())
				comment = "[VISIBLE] " + comment;
			methods.Add (method.GetFullName (), comment);
		}

		// if this method is [SecurityCritical] (already or because we determined it should be)
		// and implements an interface then some interface members may needs to be [SecurityCritical] 
		// too or a TypeLoadException will be thrown 
		// e.g. AppDomain.add_AssemblyResolve versus _AppDomain
		if (sc || method.IsSecurityCritical ()) {
			if (type.HasInterfaces) {
				foreach (TypeReference intf in type.Interfaces) {
					TypeDefinition td = intf.Resolve ();
					if (td == null || !td.HasMethods)
						continue;
					foreach (MethodDefinition im in td.GetMethods ()) {
						// note: in this case we don't care if the method is indirectly critical (e.g.via its type)
						if (Compare (method, im) && !type.IsSecurityCritical ()) {
							string ims = im.GetFullName ();
							// only add this if it's not something we already found before
							if (!methods.ContainsKey (ims)) {
								comment = String.Format ("Promoting {0}interface member to [SecurityCritical] because of '{1}'.", 
									im.IsVisible () ? "[VISIBLE] " : String.Empty, method);
								methods.Add (ims, comment);
							}
						}
					}
				}
			}
		}
	}