reflectioninfoview.cs

全功能c#编译器

						
			noDoc:
			
			ret += "<br>";
			ret += GetInType(info.DeclaringType);
			ret += "<br><br>";
			ret += GetInAsm(info.DeclaringType.Assembly);
			
			return ret;			
		}
		
		string GetPropInfo(PropertyInfo info)
		{
			string ret = "";
			MethodInfo mi = null;
			
			if (info.CanRead) mi = info.GetGetMethod(true);
			if (mi == null && info.CanWrite) mi = info.GetSetMethod(true);
			if (mi == null) goto nomod;
			if (mi.IsPublic) ret += "public ";
 			if (mi.IsFamily || mi.IsFamilyAndAssembly || mi.IsFamilyOrAssembly) ret += "protected ";
			if (mi.IsAssembly || mi.IsFamilyAndAssembly || mi.IsFamilyOrAssembly) ret += "internal ";
			if (mi.IsPrivate) ret += "private ";
			if (mi.IsStatic) ret += "static ";
			if (mi.IsVirtual && !mi.IsFinal) ret += "virtual ";
			if (mi.IsAbstract) ret += "abstract ";
			nomod:
			if (info.CanRead && !info.CanWrite) ret += "readonly ";
			if (!info.CanRead && info.CanWrite) ret += "writeonly ";
			ret += GetTypeRef(info.PropertyType);
			ret += " " + info.Name + " (";
			ret += GetParameters(info);
			ret += ")<br><br>" + RT("Attributes") + "<br>";
			ret += GetCustomAttribs(info);
			
			IClass c = parserService.GetClass(info.DeclaringType.FullName);
			if(c == null) goto noDoc;
			foreach(IProperty p in c.Properties) {
				if(p.Name == info.Name) {
					ret += "<br>" + RT("Documentation") + "<br>" + GetDocumentation(p.Documentation) + "<br>";
					break;
				}
			}
						
			noDoc:
			
			ret += "<br>";
			ret += GetInType(info.DeclaringType);
			ret += "<br>";
			ret += GetInAsm(info.DeclaringType.Assembly);
			
			return ret;
		}
		
		bool IsSameSig(IMethod p, MethodBase info)
		{
			ParameterInfo[] pis = info.GetParameters();
			if (p.Parameters.Count != pis.Length) return false;
			
			for(int j = 0; j < pis.Length; j++) {
				IReturnType pi = new ReflectionReturnType(pis[j].ParameterType);
				IParameter ip = p.Parameters[j];
				if (pi.FullyQualifiedName != ip.ReturnType.FullyQualifiedName) return false;
			}
			
			return true;
		}
		
		string GetTypeInfo(Type type)
		{
			string t = "";
			
			if(type.IsPublic)    t += "public ";
			if(type.IsNestedPrivate) t += "private ";
			if(type.IsNotPublic || type.IsNestedAssembly || type.IsNestedFamANDAssem || type.IsNestedFamORAssem)  t += "internal ";
			if(type.IsNestedFamily || type.IsNestedFamORAssem || type.IsNestedFamANDAssem) t += "protected ";
			if(type.IsAbstract)  t += "abstract ";
			if(type.IsSealed)    t += "sealed ";
			
			if(type.IsValueType && type.IsEnum) {
				t += "enum ";
			} else if(type.IsValueType) {
				t += "struct ";
			} else if(type.IsInterface) {
				t += "interface ";
			} else if(type.IsSubclassOf(typeof(System.Delegate))) {
				t += "delegate ";
			} else {
				t += "class ";
			}
						
			if (type.IsSubclassOf(typeof(System.Delegate))) {
				try {
					if (type.GetMethod("Invoke").ReturnType == typeof(void)) {
						t += "void";
					} else {
						t += GetTypeRef(type.GetMethod("Invoke").ReturnType);
					}
				} catch {}
				t += " " + type.FullName + " (";
				try {
					t += GetParameters(type.GetMethod("Invoke"));
				} catch {}
				t += ")";
			} else {
				
				t += type.FullName;
				
			}
			
			t += "<br><br>" + RT("BaseTypes") + "<br>";
			t += GetBaseTypes(type);
			
			t += "<br>" + RT("Attributes") + "<br>";
			t += GetCustomAttribs(type);
			
			IClass c = parserService.GetClass(type.FullName);
			if(c == null) goto noDoc;
			t += "<br>" + RT("Documentation") + "<br>" + GetDocumentation(c.Documentation) + "<br>";
			
			noDoc:
			
			if (type.Namespace == null || type.Namespace == "") goto inAsm;
			t += "<br>";
			t += GetInNS(type.Assembly, type.Namespace);
			
			inAsm:
			t += "<br><br>";
			t += GetInAsm(type.Assembly);
			
			return t;
		}
		
		string GetResInfo(Assembly asm, string name)
		{
			long size = 0;
			try {
				Stream str = asm.GetManifestResourceStream(name);
				size = str.Length;
				str.Close();
			} catch {}
			
			string text = String.Format(RT("ResInfo"), name, size);
			text += GetInAsm(asm);
			
			text += "<br><br>";
			text += ln(references.Add(new SaveResLink(asm, name)), RT("SaveRes"));
			
			return text;
		}
		
		string GetCustomAttribs(ICustomAttributeProvider ca)
		{
			string text = "";
			
			object[] objs;
			
			objs = ca.GetCustomAttributes(true);
			foreach(object obj in objs) {
				Type type = obj.GetType();
				text += ln(references.Add(type), type.FullName);
				text += " (";
				
				PropertyInfo[] pis = type.GetProperties();
				int cp = 1;
				foreach(PropertyInfo pi in pis) {
					try {
						object val = pi.GetValue(obj, null);
						if (val is string) {
							text += (cp == 1 ? "" : ", ") + pi.Name + " = \"" + val.ToString() + "\"";							
						} else if (val is ValueType) {
							text += (cp == 1 ? "" : ", ") + pi.Name + " = " + val.ToString();
						}
					} catch {}
					cp++;
				}
				text += ")<br>";
			}
			
			return text;
		}
		
		string GetBaseTypes(Type type)
		{
			string text = "";
			
			if (type.BaseType == null) goto interf;
			text = ln(references.Add(type.BaseType), type.BaseType.FullName) + "<br>";
			
			interf:
			Type[] interfaces = type.GetInterfaces();
			foreach(Type interfac in interfaces) {
				text += ln(references.Add(interfac), interfac.FullName) + "<br>";
			}
			
			return text;
		}
		
		string GetParameters(MethodBase mb)
		{
			ParameterInfo[] pars = mb.GetParameters();
			return GetParameters(pars);
		}
		
		string GetParameters(PropertyInfo pi)
		{
			ParameterInfo[] pars = pi.GetIndexParameters();
			return GetParameters(pars);
		}
		
		string GetParameters(ParameterInfo[] pars)
		{
			int parc = pars.Length;
			int cpar = 1;
			
			string text = "";
			
			foreach(ParameterInfo par in pars) {
				text += "<br>&nbsp;&nbsp;&nbsp;&nbsp;";
				
				if (par.ParameterType.Name.EndsWith("&")) text += "ref ";
				if (par.IsOut) text += "out ";
				if (par.ParameterType.IsArray && par.ParameterType != typeof(Array) && Attribute.IsDefined(par, typeof(ParamArrayAttribute), true))	
					text += "params ";
				if (par.IsOptional) text += "optional ";
				
				text += GetTypeRef(par.ParameterType);
				text += " " + par.Name + (cpar == parc ? "<br>" : ",");
				
				cpar++;
			}
			
			return text;
		}
		
		string GetInAsm(Assembly asm)
		{
			string text = RT("ContainedIn") + " ";
			text += ln(references.Add(asm.GetName()), asm.GetName().Name);
			return text;
		}
		
		string GetInNS(Assembly asm, string ns)
		{
			string text = RT("Namespace") + " ";
			text += ln(references.Add(new NamespaceLink(asm, ns)), ns);
			return text;
		}
		
		string GetInType(Type type)
		{
			string text = RT("Type") + " ";
			text += ln(references.Add(type), type.FullName);
			return text;
		}
		
		string GetTypeRef(Type type)
		{
			Type reftype = null;
			
			// if array type or reference type
			if (type.FullName.EndsWith("[]")) reftype = Type.GetType(type.FullName.Substring(0, type.FullName.Length - 2));
			if (type.FullName.EndsWith("&") || type.FullName.EndsWith("*")) reftype = Type.GetType(type.FullName.Substring(0, type.FullName.Length - 1));
			if (reftype == null) reftype = type;
			
			string typefullname    = GetTypeString(type.FullName);
			string reftypefullname = GetTypeString(reftype.FullName);
			
			return ln(references.Add(reftype), reftypefullname) + typefullname.Substring(reftypefullname.Length);
		}

		void back_click(object sender, LinkLabelLinkClickedEventArgs ev)
		{
			try {
				tree.GoBack();
			} catch {}
		}
		
		class SaveResLink
		{
			public Assembly Asm;
			public string Name;
			public SaveResLink(Assembly asm, string name)
			{
				Asm  = asm;
				Name = name;
			}
		}
		
		class NamespaceLink
		{
			public Assembly Asm;
			public string Name;
			public NamespaceLink(Assembly asm, string name)
			{
				Asm  = asm;
				Name = name;
			}
		}
		
		public string GetDocumentation(string doc)
		{
			StringReader reader = new StringReader("<docroot>" + doc + "</docroot>");
			XmlTextReader xml   = new XmlTextReader(reader);
			StringBuilder ret   = new StringBuilder();
			Regex whitespace    = new Regex(@"\s+");
			
			try {
				xml.Read();
				do {
					if (xml.NodeType == XmlNodeType.Element) {
						string elname = xml.Name.ToLower();
						if (elname == "remarks") {
							ret.Append(RTD("Remarks") + "<br>");
						} else if (elname == "example") {
							ret.Append(RTD("Example") + "<br>");
						} else if (elname == "exception") {
							ret.Append(RTD("Exception") + " " + GetCref(xml["cref"]) + ":<br>");
						} else if (elname == "returns") {
							ret.Append(RTD("Returns") + " ");
						} else if (elname == "see") {
							ret.Append(GetCref(xml["cref"]) + xml["langword"]);
						} else if (elname == "seealso") {
							ret.Append(RTD("SeeAlso") + " " + GetCref(xml["cref"]) + xml["langword"]);
						} else if (elname == "paramref") {
							ret.Append(xml["name"]);
						} else if (elname == "param") {
							ret.Append(xml["name"].Trim() + ": ");
						} else if (elname == "value") {
							ret.Append(RTD("Value") + " ");
						}
					} else if (xml.NodeType == XmlNodeType.EndElement) {
						string elname = xml.Name.ToLower();
						if (elname == "para" || elname == "param") {
							ret.Append("<br>");
						}
					} else if (xml.NodeType == XmlNodeType.Text) {
						ret.Append(whitespace.Replace(xml.Value, " "));
					}
				} while(xml.Read());
			} catch {
				return doc;
			}
			return ret.ToString();
		}
		
		string GetCref(string cref)
		{
			if (cref == null) return "";
			if (cref.Length < 2) return cref;
			if (cref.Substring(1, 1) == ":") return cref.Substring(2, cref.Length - 2);
			return cref;
		}
	
		static string GetTypeString(string type)
		{
			string[,] types = new string[,] {
				{"System.Void",   "void"},
				{"System.Object", "object"},
				{"System.Boolean", "bool"},
				{"System.Byte", "byte"},
				{"System.SByte", "sbyte"},
				{"System.Char", "char"},
				{"System.Enum", "enum"},
				{"System.Int16", "short"},
				{"System.Int32", "int"},
				{"System.Int64", "long"},
				{"System.UInt16", "ushort"},
				{"System.UInt32", "uint"},
				{"System.UInt64", "ulong"},
				{"System.Single", "float"},
				{"System.Double", "double"},
				{"System.Decimal", "decimal"},
				{"System.String", "string"}
			};
			
			for (int i = 0; i < types.GetLength(0); ++i) {
				type = type.Replace(types[i, 0], types[i, 1]);
			}
			return type;
		}
		
		string RT(string ResName)
		{
			return tree.ress.GetString("ObjectBrowser.Info." + ResName);
		}
		
		string RTD(string ResName)
		{
			return tree.ress.GetString("ObjectBrowser.Info.Doc." + ResName);
		}
		
		string ln(int rnr, string text)
		{
			return "<a href='as://" + rnr.ToString() + "'>" + text + "</a>";
		}
		
		bool CreateImage(Image pv)
		{
			try {
				Bitmap b = new Bitmap(170, 170, PixelFormat.Format24bppRgb);
				
				Graphics g = Graphics.FromImage(b);
				g.FillRectangle(new SolidBrush(SystemColors.Control), 0, 0, 170, 170);
				g.InterpolationMode = InterpolationMode.NearestNeighbor;
				
				g.DrawImage(pv, 5, 5, 160, 160);
				g.FillRectangle(new SolidBrush(Color.FromArgb(220, SystemColors.Control)), 0, 0, 170, 170);
				g.Dispose();
				
				b.Save(imgPath, System.Drawing.Imaging.ImageFormat.Png);
				return true;
			} catch { return false; }
		}
		
	}
	
	public class GradientLabel : Label
	{
		protected override void OnPaintBackground(PaintEventArgs pe)
		{
			base.OnPaintBackground(pe);
			Graphics g = pe.Graphics;
			g.FillRectangle(new SolidBrush(SystemColors.Control), pe.ClipRectangle);
		
			g.FillRectangle(new LinearGradientBrush(new Point(0, 0), new Point(Width, Height),
		                                        SystemColors.ControlLightLight,
		                                        SystemColors.Control),
		                                        new Rectangle(0, 0, Width, Height));
		}
	}
		
}