project contents can now reference other project contents (greatly reducing loading times/memory consumption). XmlDocumentation is now loaded & cached (greatly increasing loading times/memory consumption).

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@33 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/BackendBindings/CSharpBinding/Project/CSharpBinding.csproj

@@ -12,6 +12,9 @@
     <NoConfig>False</NoConfig>
     <RunPostBuildEvent>OnSuccessfulBuild</RunPostBuildEvent>
     <OutputType>Library</OutputType>
+    <AssemblyOriginatorKeyFile />
+    <AssemblyKeyProviderName />
+    <AssemblyOriginatorKeyMode>File</AssemblyOriginatorKeyMode>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>True</DebugSymbols>

src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj

@@ -618,6 +618,8 @@
     <Compile Include="Src\TextEditor\XmlFormattingStrategy.cs" />
     <Compile Include="Src\Services\Tasks\TaskEventHandler.cs" />
     <Compile Include="Src\Project\AbstractProject.cs" />
+    <Compile Include="Src\Dom\XmlDoc.cs" />
+    <Compile Include="Src\Services\ParserService\ProjectContentRegistry.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\Libraries\DockPanel_Src\WinFormsUI\WinFormsUI.csproj">
@@ -642,4 +644,4 @@
     </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSHARP.Targets" />
-</Project>
+</Project>

src/Main/Base/Project/Src/Dom/IDecoration.cs

@@ -20,7 +20,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get;
 		}
 		
-		string Documentation {
+		string DocumentationTag {
 			get;
 		}
 

src/Main/Base/Project/Src/Dom/Implementations/AbstractClass.cs

@@ -31,6 +31,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 		List<IEvent>    events       = null;
 		List<IIndexer>  indexer      = null;
 		
+		public override string DocumentationTag {
+			get {
+				return "T:" + this.FullyQualifiedName;
+			}
+		}
+		
 		public abstract ICompilationUnit CompilationUnit {
 			get;
 		}

src/Main/Base/Project/Src/Dom/Implementations/AbstractDecoration.cs

@@ -14,11 +14,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 	[Serializable]
 	public abstract class AbstractDecoration : MarshalByRefObject, IDecoration
 	{
-		protected ModifierEnum               modifiers     = ModifierEnum.None;
+		protected ModifierEnum            modifiers     = ModifierEnum.None;
 		protected List<IAttributeSection> attributes    = null;
-		string documentation = null;
-//		int    documentationHash = -1;
-//		public static Hashtable documentationHashtable = new Hashtable();
 		
 		object userData = null;
 		
@@ -46,24 +43,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 
-		public string Documentation {
-			get {
-				if (documentation == null) {
-					return String.Empty;
-				}
-				return documentation;
-//				if (documentationHash == -1) {
-//					return String.Empty;
-//				}
-//				return (string)documentationHashtable[documentationHash];
-			}
-			set {
-				documentation = value;
-//				documentationHash = value.GetHashCode();
-//				if (documentationHashtable[documentationHash] == null) {
-//					documentationHashtable[documentationHash] = value;
-//				}
-			}
+		public abstract string DocumentationTag {
+			get;
 		}
 		
 		public bool IsAbstract {

src/Main/Base/Project/Src/Dom/Implementations/AbstractEvent.cs

@@ -17,6 +17,12 @@ namespace ICSharpCode.SharpDevelop.Dom {
 		protected IMethod          removeMethod;
 		protected IMethod          raiseMethod;
 		
+		public override string DocumentationTag {
+			get {
+				return "E:" + this.FullyQualifiedName;
+			}
+		}
+		
 		public virtual IRegion BodyRegion {
 			get {
 				return bodyRegion;

src/Main/Base/Project/Src/Dom/Implementations/AbstractField.cs

@@ -11,6 +11,12 @@ namespace ICSharpCode.SharpDevelop.Dom {
 	[Serializable]
 	public abstract class AbstractField : AbstractMember, IField
 	{
+		public override string DocumentationTag {
+			get {
+				return "F:" + this.FullyQualifiedName;
+			}
+		}
+		
 		public virtual int CompareTo(IField field) 
 		{
 			int cmp;

src/Main/Base/Project/Src/Dom/Implementations/AbstractIndexer.cs

@@ -17,6 +17,13 @@ namespace ICSharpCode.SharpDevelop.Dom
 		protected IRegion             setterRegion;
 		List<IParameter> parameters;
 		
+		public override string DocumentationTag {
+			get {
+				return "P:" + this.FullyQualifiedName;
+			}
+		}
+		
+		
 		public virtual IRegion BodyRegion {
 			get {
 				return bodyRegion;

src/Main/Base/Project/Src/Dom/Implementations/AbstractMethod.cs

@@ -16,7 +16,13 @@ namespace ICSharpCode.SharpDevelop.Dom
 		protected IRegion bodyRegion;
 		
 		List<IParameter> parameters = null;
-
+		
+		public override string DocumentationTag {
+			get {
+				return "M:" + this.FullyQualifiedName;
+			}
+		}
+		
 		public virtual IRegion BodyRegion {
 			get {
 				return bodyRegion;

src/Main/Base/Project/Src/Dom/Implementations/AbstractNamedEntity.cs

@@ -33,6 +33,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		public override string DocumentationTag {
+			get {
+				return FullyQualifiedName;
+			}
+		}
 		
 		public string Name {
 			get {

src/Main/Base/Project/Src/Dom/Implementations/AbstractProperty.cs

@@ -22,6 +22,12 @@ namespace ICSharpCode.SharpDevelop.Dom {
 		protected IMethod     setterMethod;
 		List<IParameter> parameters = null;
 		
+		public override string DocumentationTag {
+			get {
+				return "P:" + this.FullyQualifiedName;
+			}
+		}
+		
 		public virtual IRegion BodyRegion {
 			get {
 				return bodyRegion;

src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs

@@ -17,9 +17,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 	public class ReflectionClass : AbstractClass
 	{
 		Type type;
-		Hashtable xmlComments;
 		
-		BindingFlags flags = BindingFlags.Instance  | 
+		BindingFlags flags = BindingFlags.Instance  |
 		                     BindingFlags.Static    | 
 		                     BindingFlags.NonPublic |
 		                     BindingFlags.DeclaredOnly |
@@ -29,7 +28,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get {
 				List<IClass> innerClasses = new List<IClass>();
 				foreach (Type nestedType in type.GetNestedTypes(flags)) {
-					innerClasses.Add(new ReflectionClass(nestedType, xmlComments));
+					innerClasses.Add(new ReflectionClass(nestedType));
 				}
 				return innerClasses;
 			}
@@ -39,7 +38,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get {
 				List<IField> fields = new List<IField>();
 				foreach (FieldInfo field in type.GetFields(flags)) {
-					IField newField = new ReflectionField(field, xmlComments);
+					IField newField = new ReflectionField(field);
 					if (!newField.IsInternal) {
 						fields.Add(newField);
 					}
@@ -59,7 +58,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 						p = propertyInfo.GetIndexParameters();
 					} catch (Exception) {}
 					if (p == null || p.Length == 0) {
-						properties.Add(new ReflectionProperty(propertyInfo, xmlComments));
+						properties.Add(new ReflectionProperty(propertyInfo));
 					}
 				}
 				
@@ -78,7 +77,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 						p = propertyInfo.GetIndexParameters();
 					} catch (Exception) {}
 					if (p != null && p.Length != 0) {
-						indexer.Add(new ReflectionIndexer(propertyInfo, xmlComments));
+						indexer.Add(new ReflectionIndexer(propertyInfo));
 					}
 				}
 				
@@ -91,7 +90,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 				List<IMethod> methods = new List<IMethod>();
 				
 				foreach (ConstructorInfo constructorInfo in type.GetConstructors(flags)) {
-					IMethod newMethod = new ReflectionMethod(constructorInfo, xmlComments);
+					IMethod newMethod = new ReflectionMethod(constructorInfo);
 					if (!newMethod.IsInternal) {
 						methods.Add(newMethod);
 					}
@@ -99,7 +98,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 				
 				foreach (MethodInfo methodInfo in type.GetMethods(flags)) {
 					if (!methodInfo.IsSpecialName) {
-						IMethod newMethod = new ReflectionMethod(methodInfo, xmlComments);
+						IMethod newMethod = new ReflectionMethod(methodInfo);
 						if (!newMethod.IsInternal) {
 							methods.Add(newMethod);
 						}
@@ -114,7 +113,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 				List<IEvent> events = new List<IEvent>();
 				
 				foreach (EventInfo eventInfo in type.GetEvents(flags)) {
-					IEvent newEvent = new ReflectionEvent(eventInfo, xmlComments);
+					IEvent newEvent = new ReflectionEvent(eventInfo);
 					
 					if (!newEvent.IsInternal) {
 						events.Add(newEvent);
@@ -124,8 +123,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		
-		
 		/// <value>
 		/// A reflection class doesn't have a compilation unit (because
 		/// it is not parsed the information is gathered using reflection)
@@ -141,25 +138,22 @@ namespace ICSharpCode.SharpDevelop.Dom
 			return type.IsSubclassOf(typeof(Delegate)) && type != typeof(MulticastDelegate);
 		}
 		
-		public ReflectionClass(Type type, Hashtable xmlComments)
+		public override string DocumentationTag {
+			get {
+				return "T:" + type.FullName;
+			}
+		}
+		
+		public ReflectionClass(Type type)
 		{
 			this.type = type;
-			this.xmlComments = xmlComments;
-			FullyQualifiedName = type.FullName;
-			if (xmlComments != null) {
-				XmlNode node = xmlComments["T:" + FullyQualifiedName] as XmlNode;
-				if (node != null) {
-					Documentation = node.InnerXml;
-				}
-			}
-			
-			FullyQualifiedName = FullyQualifiedName.Replace("+", ".");
+			FullyQualifiedName = type.FullName.Replace("+", ".");
 			
 			// set classtype
 			if (IsDelegate(type)) {
 				classType = ClassType.Delegate;
 				MethodInfo invoke          = type.GetMethod("Invoke");
-				ReflectionMethod newMethod = new ReflectionMethod(invoke, null);
+				ReflectionMethod newMethod = new ReflectionMethod(invoke);
 				Methods.Add(newMethod);
 			} else if (type.IsInterface) {
 				classType = ClassType.Interface;

src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionEvent.cs

@@ -24,18 +24,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		public ReflectionEvent(EventInfo eventInfo, Hashtable xmlComments)
+		public ReflectionEvent(EventInfo eventInfo)
 		{
 			this.eventInfo = eventInfo;
 			FullyQualifiedName = String.Concat(eventInfo.DeclaringType.FullName, ".", eventInfo.Name);
 			
-			if (xmlComments != null) {
-				XmlNode node = xmlComments["E:" + FullyQualifiedName] as XmlNode;
-				if (node != null) {
-					Documentation = node.InnerXml;
-				}
-			}
-			
 			// get modifiers
 			MethodInfo methodBase = null;
 			try {

src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionField.cs

@@ -24,18 +24,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		public ReflectionField(FieldInfo fieldInfo, Hashtable xmlComments)
+		public ReflectionField(FieldInfo fieldInfo)
 		{
 			this.fieldInfo = fieldInfo;
 			System.Diagnostics.Debug.Assert(fieldInfo != null);
 			FullyQualifiedName = String.Concat(fieldInfo.DeclaringType.FullName, ".", fieldInfo.Name);
 			
-			if (xmlComments != null) {
-				XmlNode node = xmlComments["F:" + FullyQualifiedName] as XmlNode;
-				if (node != null) {
-					Documentation = node.InnerXml;
-				}
-			}
 			if (fieldInfo.IsInitOnly) {
 				modifiers |= ModifierEnum.Readonly;
 			}

src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionIndexer.cs

@@ -30,7 +30,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get {
 				List<IParameter> parameters = new List<IParameter>();
 				foreach (ParameterInfo parameterInfo in propertyInfo.GetIndexParameters()) {
-					Parameters.Add(new ReflectionParameter(parameterInfo, null));
+					Parameters.Add(new ReflectionParameter(parameterInfo));
 				}
 				return parameters;
 			}
@@ -52,7 +52,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			return propertyName.ToString();
 		}
 		
-		public ReflectionIndexer(PropertyInfo propertyInfo, Hashtable xmlComments)
+		public ReflectionIndexer(PropertyInfo propertyInfo)
 		{
 			this.propertyInfo = propertyInfo;
 			// indexers does have the same name as the object that declare the indexers
@@ -71,14 +71,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 				setterRegion = null;
 			}
 			
-			XmlNode node = null;
-			if (xmlComments != null) {
-				node = xmlComments["P:" + FullyQualifiedName] as XmlNode;
-				if (node != null) {
-					Documentation = node.InnerXml;
-				}
-			}
-			
 			MethodInfo methodBase = null;
 			try {
 				methodBase = propertyInfo.GetGetMethod(true);

src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs

@@ -40,7 +40,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get {
 				List<IParameter> parameters = new List<IParameter>();
 				foreach (ParameterInfo paramInfo in methodBase.GetParameters()) {
-					parameters.Add(new ReflectionParameter(paramInfo, null));
+					parameters.Add(new ReflectionParameter(paramInfo));
 				}
 				return parameters;
 			}
@@ -65,7 +65,13 @@ namespace ICSharpCode.SharpDevelop.Dom
 			return propertyName.ToString();
 		}
 		
-		public ReflectionMethod(MethodBase methodBase, Hashtable xmlComments)
+		public override string DocumentationTag {
+			get {
+				return "M:" + FullyQualifiedName + GetParamList(methodBase);
+			}
+		}
+		
+		public ReflectionMethod(MethodBase methodBase)
 		{
 			this.methodBase = methodBase;
 			string name = methodBase.Name;
@@ -75,15 +81,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 			FullyQualifiedName = methodBase.DeclaringType.FullName + "." + name;
 			
-			XmlNode node = null;
-			
-			if (xmlComments != null) {
-				node = xmlComments["M:" + FullyQualifiedName + GetParamList(methodBase)] as XmlNode;
-				if (node != null) {
-					Documentation = node.InnerXml;
-				}
-			}
-			
 			modifiers = ModifierEnum.None;
 			if (methodBase.IsStatic) {
 				modifiers |= ModifierEnum.Static;

src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs

@@ -22,7 +22,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		public ReflectionParameter(ParameterInfo parameterInfo, XmlNode methodNode)
+		public ReflectionParameter(ParameterInfo parameterInfo)
 		{
 			this.parameterInfo = parameterInfo;
 			Name       = parameterInfo.Name;
@@ -41,13 +41,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 			if (type.Name.EndsWith("&")) {
 				modifier |= ParameterModifier.Ref;
 			}
-			
-			if (methodNode != null) {
-				XmlNode paramDocu = methodNode.SelectSingleNode("member[@name='" + parameterInfo.Name + "']");
-				if (paramDocu != null) {
-					Documentation = paramDocu.InnerXml;
-				}
-			}
 		}
 	}
 }

src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionProperty.cs

@@ -23,7 +23,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			set {
 			}
 		}
-		public ReflectionProperty(PropertyInfo propertyInfo, Hashtable xmlComments)
+		public ReflectionProperty(PropertyInfo propertyInfo)
 		{
 			this.propertyInfo = propertyInfo;
 			FullyQualifiedName = String.Concat(propertyInfo.DeclaringType.FullName, ".", propertyInfo.Name);
@@ -41,13 +41,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 				setterRegion = null;
 			}
 			
-			if (xmlComments != null) {
-				XmlNode node = xmlComments["P:" + FullyQualifiedName] as XmlNode;
-				if (node != null) {
-					Documentation = node.InnerXml;
-				}
-			}
-			
 			MethodInfo methodBase = null;
 			try {
 				methodBase = propertyInfo.GetGetMethod(true);

src/Main/Base/Project/Src/Dom/XmlDoc.cs

@@ -0,0 +1,68 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace ICSharpCode.SharpDevelop.Dom
+{
+	/// <summary>
+	/// Description of XmlDoc.
+	/// </summary>
+	public class XmlDoc
+	{
+		Dictionary<string, string> xmlDescription = new Dictionary<string, string>();
+		
+		public Dictionary<string, string> XmlDescription {
+			get {
+				return xmlDescription;
+			}
+		}
+		public XmlDoc()
+		{
+		}
+		
+		void ReadMembersSection(XmlTextReader reader)
+		{
+			while (reader.Read()) {
+				switch (reader.NodeType) {
+					case XmlNodeType.EndElement:
+						if (reader.LocalName == "members") {
+							return;
+						}
+						break;
+					case XmlNodeType.Element:
+						if (reader.LocalName == "member") {
+							string memberAttr = reader.GetAttribute(0);
+							string innerXml   = reader.ReadInnerXml();
+							xmlDescription[memberAttr] = innerXml;
+						}
+						break;
+				}
+			}
+		}
+		
+		public static XmlDoc Load(TextReader textReader)
+		{
+			XmlDoc newXmlDoc = new XmlDoc();
+			using (XmlTextReader reader = new XmlTextReader(textReader)) {
+				while (reader.Read()) {
+					if (reader.IsStartElement()) {
+						switch (reader.LocalName) {
+							case "members":
+								newXmlDoc.ReadMembersSection(reader);
+								break;
+						}
+					}
+				}
+			}
+			return newXmlDoc;
+		}
+		
+		public static XmlDoc Load(string fileName)
+		{
+			using (TextReader textReader = File.OpenText(fileName)) {
+				return Load(textReader);
+			}
+		}
+	}
+}

src/Main/Base/Project/Src/Gui/Pads/ClassBrowser/Nodes/ReferenceFolderNode.cs

@@ -97,7 +97,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 				Nodes.Clear();
 				foreach (Type type in assembly.GetTypes()) {
 					if (!type.FullName.StartsWith("<") && type.IsPublic) {
-						IClass c = new ReflectionClass(type, null);
+						IClass c = new ReflectionClass(type);
 						TreeNode node = GetNodeByPath(c.Namespace, true);
 						new ClassNode(item.Project, c).AddTo(node);
 					}

src/Main/Base/Project/Src/Services/AmbienceService/AmbienceReflectionDecorator.cs

@@ -94,32 +94,32 @@ namespace ICSharpCode.Core
 		
 		public string Convert(Type type)
 		{
-			return conv.Convert(new ReflectionClass(type, null));
+			return conv.Convert(new ReflectionClass(type));
 		}
 		
 		public string Convert(FieldInfo field)
 		{
-			return conv.Convert(new ReflectionField(field, null));
+			return conv.Convert(new ReflectionField(field));
 		}
 		
 		public string Convert(PropertyInfo property)
 		{
-			return conv.Convert(new ReflectionProperty(property, null));
+			return conv.Convert(new ReflectionProperty(property));
 		}
 		
 		public string Convert(EventInfo e)
 		{
-			return conv.Convert(new ReflectionEvent(e, null));
+			return conv.Convert(new ReflectionEvent(e));
 		}
 		
 		public string Convert(MethodBase m)
 		{
-			return conv.Convert(new ReflectionMethod(m, null));
+			return conv.Convert(new ReflectionMethod(m));
 		}
 		
 		public string Convert(ParameterInfo param)
 		{
-			return conv.Convert(new ReflectionParameter(param, null));
+			return conv.Convert(new ReflectionParameter(param));
 		}
 		
 		public ArrayList LinkArrayList {

src/Main/Base/Project/Src/Services/ParserService/CaseSensitiveProjectContent.cs

@@ -24,31 +24,83 @@ namespace ICSharpCode.Core
 {
 	public class CaseSensitiveProjectContent : IProjectContent
 	{
-		List<Assembly>             references        = new List<Assembly>();
-		Dictionary<string, IClass> classes           = new Dictionary<string, IClass>();
-		Hashtable                  namespaces        = new Hashtable();
+		List<IProjectContent>      referencedContents = new List<IProjectContent>();
 		
+		Dictionary<string, IClass> classes            = new Dictionary<string, IClass>();
+		Hashtable                  namespaces         = new Hashtable();
+		XmlDoc                     xmlDoc             = new XmlDoc();
+		
+		public XmlDoc XmlDoc {
+			get {
+				return xmlDoc;
+			}
+		}
+
 		public ICollection<IClass> Classes {
 			get {
 				return classes.Values;
 			}
 		}
 		
+		public string GetXmlDocumentation(string memberTag)
+		{
+			if (xmlDoc.XmlDescription.ContainsKey(memberTag)) {
+				return xmlDoc.XmlDescription[memberTag];
+			}
+			foreach (IProjectContent referencedContent in referencedContents) {
+				if (referencedContent.XmlDoc.XmlDescription.ContainsKey(memberTag)) {
+					return referencedContent.XmlDoc.XmlDescription[memberTag];
+				}
+			}
+			return null;
+		}
+		
+		static string LookupLocalizedXmlDoc(string fileName)
+		{
+			string xmlFileName         = Path.ChangeExtension(fileName, ".xml");
+			string localizedXmlDocFile = FileUtility.Combine(System.IO.Path.GetDirectoryName(fileName), Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName, System.IO.Path.GetFileName(xmlFileName));
+			if (File.Exists(localizedXmlDocFile)) {
+				return localizedXmlDocFile;
+			}
+			if (File.Exists(xmlFileName)) {
+				return xmlFileName;
+			}
+			return null;
+		}
+		
+		public static IProjectContent Create(Assembly assembly)
+		{
+			CaseSensitiveProjectContent newProjectContent = new CaseSensitiveProjectContent();
+			foreach (Type type in assembly.GetTypes()) {
+				if (!type.FullName.StartsWith("<") && type.IsPublic) {
+					newProjectContent.AddClassToNamespaceList(new ReflectionClass(type));
+				}
+			}
+			string fileName = LookupLocalizedXmlDoc(assembly.Location);
+			// Not found -> look in runtime directory.
+			if (fileName == null) {
+				string runtimeDirectory = System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory();
+				fileName = LookupLocalizedXmlDoc(Path.Combine(runtimeDirectory, Path.GetFileName(assembly.Location)));
+			}
+			
+			if (fileName != null) {
+				Console.WriteLine("load xmldoc: " + fileName);
+				newProjectContent.xmlDoc = XmlDoc.Load(fileName);
+			}
+			
+			return newProjectContent;
+		}
+		
 		public static IProjectContent Create(IProject project)
 		{
 			CaseSensitiveProjectContent newProjectContent = new CaseSensitiveProjectContent();
-			newProjectContent.references.Add(typeof(object).Assembly);
+			newProjectContent.referencedContents.Add(ProjectContentRegistry.GetMscorlibContent());
 			foreach (ProjectItem item in project.Items) {
 				switch (item.ItemType) {
 					case ItemType.Reference:
-						try {
-							newProjectContent.references.Add(Assembly.ReflectionOnlyLoadFrom(item.FileName));
-						} catch (Exception) {
-							try {
-								newProjectContent.references.Add(Assembly.LoadWithPartialName(item.Include));
-							} catch (Exception e) {
-								Console.WriteLine("Can't load assembly '{0}' : " + e.Message, item.Include);
-							}
+						IProjectContent referencedContent = ProjectContentRegistry.GetProjectContentForReference(item as ReferenceProjectItem);
+						if (referencedContent != null) {
+							newProjectContent.referencedContents.Add(referencedContent);
 						}
 						break;
 					case ItemType.Compile:
@@ -57,16 +109,6 @@ namespace ICSharpCode.Core
 						break;
 				}
 			}
-			DateTime now = DateTime.Now;
-			foreach (Assembly asm in newProjectContent.references) {
-				try {
-					foreach (Type type in asm.GetTypes()) {
-						if (!type.FullName.StartsWith("<") && type.IsPublic) {
-							newProjectContent.AddClassToNamespaceList(new ReflectionClass(type, null));
-						}
-					}
-				} catch (Exception) {}
-			}
 			
 			return newProjectContent;
 		}
@@ -140,6 +182,14 @@ namespace ICSharpCode.Core
 				return classes[typeName];
 			}
 			
+			// Search in references:
+			foreach (IProjectContent content in referencedContents) {
+				IClass classFromContent = content.GetClass(typeName);
+				if (classFromContent != null) {
+					return classFromContent;
+				}
+			}
+			
 			// not found -> maybe nested type -> trying to find class that contains this one.
 			int lastIndex = typeName.LastIndexOf('.');
 			if (lastIndex > 0) {
@@ -161,37 +211,47 @@ namespace ICSharpCode.Core
 		{
 //			Console.WriteLine("GetNamespaceList({0})", subNameSpace);
 			System.Diagnostics.Debug.Assert(subNameSpace != null);
+			List<string> namespaceList = new List<string>();
+			
+			
+			foreach (IProjectContent content in referencedContents) {
+				string[] referencedNamespaces = content.GetNamespaceList(subNameSpace);
+				if (referencedNamespaces != null) {
+					namespaceList.AddRange(referencedNamespaces);
+				}
+			}
 			
 			string[] path = subNameSpace.Split('.');
 			Hashtable cur = namespaces;
-			
 			if (subNameSpace.Length > 0) {
 				for (int i = 0; i < path.Length; ++i) {
 					if (!(cur[path[i]] is Hashtable)) {
-						return null;
+						return namespaceList.ToArray();
 					}
 					cur = (Hashtable)cur[path[i]];
 				}
 			}
 			
-			ArrayList namespaceList = new ArrayList();
 			foreach (DictionaryEntry entry in cur) {
 				if (entry.Value is Hashtable && entry.Key.ToString().Length > 0) {
-					namespaceList.Add(entry.Key);
+					namespaceList.Add(entry.Key.ToString());
 				}
 			}
-			
-			return (string[])namespaceList.ToArray(typeof(string));
+			return namespaceList.ToArray();
 		}
 		
 		public ArrayList GetNamespaceContents(string subNameSpace)
 		{
-//			Console.WriteLine("GetNamespaceContents({0})", subNameSpace);
 			ArrayList namespaceList = new ArrayList();
 			if (subNameSpace == null) {
 				return namespaceList;
 			}
 			
+			foreach (IProjectContent content in referencedContents) {
+				ArrayList referencedNamespaceContents = content.GetNamespaceContents(subNameSpace);
+				namespaceList.AddRange(referencedNamespaceContents.ToArray());
+			}
+			
 			string[] path = subNameSpace.Split('.');
 			Hashtable cur = namespaces;
 			
@@ -202,7 +262,6 @@ namespace ICSharpCode.Core
 							namespaceList.Add(entry.Key);
 						}
 					}
-					
 					return namespaceList;
 				}
 				cur = (Hashtable)cur[path[i]];
@@ -215,7 +274,6 @@ namespace ICSharpCode.Core
 					namespaceList.Add(entry.Value);
 				}
 			}
-			
 			return namespaceList;
 		}
 		
@@ -225,6 +283,13 @@ namespace ICSharpCode.Core
 			if (name == null) {
 				return false;
 			}
+			
+			foreach (IProjectContent content in referencedContents) {
+				if (content.NamespaceExists(name)) {
+					return true;
+				}
+			}
+			
 			string[] path = name.Split('.');
 			Hashtable cur = namespaces;
 			for (int i = 0; i < path.Length; ++i) {
@@ -664,30 +729,3 @@ namespace ICSharpCode.Core
 		
 	}
 }
-
-
-//readonly static string[] assemblyList = {
-//			"Microsoft.VisualBasic",
-//			"Microsoft.JScript",
-//			"mscorlib",
-//			"System.Data",
-//			"System.Design",
-//			"System.DirectoryServices",
-//			"System.Drawing.Design",
-//			"System.Drawing",
-//			"System.EnterpriseServices",
-//			"System.Management",
-//			"System.Messaging",
-//			"System.Runtime.Remoting",
-//			"System.Runtime.Serialization.Formatters.Soap",
-//
-//			"System.Security",
-//			"System.ServiceProcess",
-//			"System.Web.Services",
-//			"System.Web",
-//			"System.Windows.Forms",
-//			"System",
-//			"System.XML"
-//		};
-//		
-//		

src/Main/Base/Project/Src/Services/ParserService/IProjectContent.cs

@@ -24,10 +24,15 @@ namespace ICSharpCode.Core
 {
 	public interface IProjectContent
 	{
+		XmlDoc XmlDoc {
+			get;
+		}
 		ICollection<IClass> Classes {
 			get;
 		}
 		
+		string GetXmlDocumentation(string memberTag);
+		
 		Hashtable AddClassToNamespaceList(IClass addClass);
 		void UpdateCompilationUnit(ICompilationUnit oldUnit, ICompilationUnit parserOutput, string fileName, bool updateCommentTags);
 		IClass GetClass(string typeName);

src/Main/Base/Project/Src/Services/ParserService/ProjectContentRegistry.cs

@@ -0,0 +1,73 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Formatters;
+using System.Runtime.Serialization.Formatters.Binary;
+using System.Security;
+using System.Security.Permissions;
+using System.Security.Policy;
+using System.Xml;
+using System.Text;
+
+using ICSharpCode.Core;
+using ICSharpCode.SharpDevelop.Project;
+using ICSharpCode.SharpDevelop.Gui;
+using ICSharpCode.SharpDevelop.Dom;
+
+namespace ICSharpCode.Core
+{
+	public class ProjectContentRegistry
+	{
+		static Dictionary<string, IProjectContent> contents = new Dictionary<string, IProjectContent>();
+		
+		public static IProjectContent GetMscorlibContent()
+		{
+			if (contents.ContainsKey("mscorlib")) {
+				return contents["mscorlib"];
+			}
+			contents["mscorlib"] = CaseSensitiveProjectContent.Create(typeof(object).Assembly);
+			return contents["mscorlib"];
+		}
+		
+		public static IProjectContent GetProjectContentForReference(ReferenceProjectItem item)
+		{
+			if (contents.ContainsKey(item.FileName)) {
+				Console.WriteLine("Get Content for : " + item.FileName);
+				return contents[item.FileName];
+			}
+			if (contents.ContainsKey(item.Include)) {
+				Console.WriteLine("Get Content for : " + item.Include);
+				return contents[item.Include];
+			}
+			Assembly assembly = null;
+			
+			try {
+				assembly = Assembly.ReflectionOnlyLoadFrom(item.FileName);
+				Console.WriteLine(assembly.Location);
+				if (assembly != null) {
+					contents[item.FileName] = CaseSensitiveProjectContent.Create(assembly);
+					return contents[item.FileName];
+				}
+			} catch (Exception) {
+				try {
+					assembly = Assembly.LoadWithPartialName(item.Include);
+					Console.WriteLine(assembly.Location);
+					if (assembly != null) {
+						contents[item.Include] = CaseSensitiveProjectContent.Create(assembly);
+						return contents[item.Include];
+					}
+				} catch (Exception e) {
+					Console.WriteLine("Can't load assembly '{0}' : " + e.Message, item.Include);
+				}
+			}
+			
+			return null;
+		}
+	}
+}

src/Main/Base/Project/Src/TextEditor/Gui/Editor/CompletionWindow/CodeCompletionData.cs

@@ -70,10 +70,12 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 //					description = ambience.Convert(ParserService.GetClass(c.FullyQualifiedName));
 //					c = null;
 //				}
-				
+				if (documentation == null) {
+					return "";
+				}
 				// don't give a description string, if no documentation or description is provided
 				if (description.Length + documentation.Length == 0) {
-					return null;
+					return "";
 				}
 				if (!convertedDocumentation) {
 					convertedDocumentation = true;
@@ -99,7 +101,6 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 		
 		public CodeCompletionData(string s, int imageIndex)
 		{
-			
 			ambience = AmbienceService.CurrentAmbience;
 			description = documentation = String.Empty;
 			text = s;
@@ -109,7 +110,6 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 		
 		public CodeCompletionData(IClass c)
 		{
-			
 			ambience = AmbienceService.CurrentAmbience;
 			// save class (for the delegate description shortcut
 			this.c = c;
@@ -119,7 +119,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedNames | ConversionFlags.ShowReturnType | ConversionFlags.ShowModifiers;
 //			Console.WriteLine("Convert : " + c);
 			description = ambience.Convert(c);
-			documentation = c.Documentation;
+			documentation = ParserService.CurrentProjectContent.GetXmlDocumentation(c.DocumentationTag);
 		}
 		
 		public CodeCompletionData(IMethod method)
@@ -131,7 +131,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			text        = method.Name;
 			description = ambience.Convert(method);
 			completionString = method.Name;
-			documentation = method.Documentation;
+			documentation = ParserService.CurrentProjectContent.GetXmlDocumentation(method.DocumentationTag);
 		}
 		
 		public CodeCompletionData(IField field)
@@ -143,7 +143,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			text        = field.Name;
 			description = ambience.Convert(field);
 			completionString = field.Name;
-			documentation = field.Documentation;
+			documentation = ParserService.CurrentProjectContent.GetXmlDocumentation(field.DocumentationTag);
 		}
 		
 		public CodeCompletionData(IProperty property)
@@ -155,7 +155,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			text        = property.Name;
 			description = ambience.Convert(property);
 			completionString = property.Name;
-			documentation = property.Documentation;
+			documentation = ParserService.CurrentProjectContent.GetXmlDocumentation(property.DocumentationTag);
 		}
 		
 		public CodeCompletionData(IEvent e)
@@ -167,7 +167,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			text        = e.Name;
 			description = ambience.Convert(e);
 			completionString = e.Name;
-			documentation = e.Documentation;
+			documentation = ParserService.CurrentProjectContent.GetXmlDocumentation(e.DocumentationTag);
 		}
 		
 		public void InsertAction(TextEditorControl control)

src/Main/Base/Project/Src/TextEditor/Gui/Editor/CompletionWindow/CodeCompletionDataProvider.cs

@@ -166,7 +166,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			return (ICompletionData[])completionData.ToArray(typeof(ICompletionData));
 		}
 		
-		void AddResolveResults(ICollection list) 
+		void AddResolveResults(ICollection list)
 		{
 			if (list == null) {
 				return;

src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/IndexerInsightDataProvider.cs

@@ -41,9 +41,10 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			IIndexer method = methods[number];
 			IAmbience conv = AmbienceService.CurrentAmbience;
 			conv.ConversionFlags = ConversionFlags.StandardConversionFlags;
+			string documentation = ParserService.CurrentProjectContent.GetXmlDocumentation(method.DocumentationTag);
 			return conv.Convert(method) + 
 			       "\n" + 
-			       CodeCompletionData.GetDocumentation(method.Documentation); // new (by G.B.)
+			       CodeCompletionData.GetDocumentation(documentation); // new (by G.B.)
 		}
 		
 		int initialOffset;

src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/MethodInsightDataProvider.cs

@@ -44,9 +44,10 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			IMethod method = methods[number];
 			IAmbience conv = AmbienceService.CurrentAmbience;
 			conv.ConversionFlags = ConversionFlags.StandardConversionFlags;
+			string documentation = ParserService.CurrentProjectContent.GetXmlDocumentation(method.DocumentationTag);
 			return conv.Convert(method) + 
 			       "\n" + 
-			       CodeCompletionData.GetDocumentation(method.Documentation); // new (by G.B.)
+			       CodeCompletionData.GetDocumentation(documentation); // new (by G.B.)
 		}
 		
 		int initialOffset;
@@ -115,11 +116,11 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 						}
 					}
 					
-					// take out old method, when it isn't documented.
-					if (method.Documentation == null || method.Documentation.Length == 0) {
-						methods.Remove(method);
-						return false;
-					}
+//					// take out old method, when it isn't documented.
+//					if (method.Documentation == null || method.Documentation.Length == 0) {
+//						methods.Remove(method);
+//						return false;
+//					}
 					return true;
 				}
 			}