Use use static readonly collection instance for empty attribute, type parameter and parameter collections.

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

src/Libraries/ICSharpCode.TextEditor/Project/ICSharpCode.TextEditor.csproj

@@ -179,6 +179,7 @@
     <EmbeddedResource Include="Resources\VBNET-Mode.xshd" />
     <EmbeddedResource Include="Resources\XML-Mode.xshd" />
     <Compile Include="Src\Document\TextBufferStrategy\PieceTableTextBufferStrategy.cs" />
+    <Compile Include="Src\Util\FileReader.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSHARP.Targets" />
 </Project>

src/Libraries/ICSharpCode.TextEditor/Project/Src/Gui/TextEditorControlBase.cs

@@ -623,39 +623,14 @@ namespace ICSharpCode.TextEditor
 				document.HighlightingStrategy = HighlightingStrategyFactory.CreateHighlightingStrategyForFile(fileName);
 			}
 			
-			using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read)) {
-				StreamReader stream;
-				if (autodetectEncoding && fs.Length > 3) {
-					// the autodetection of StreamReader is not capable of detecting the difference
-					// between ISO-8859-1 and UTF-8 without BOM.
-					int firstByte = fs.ReadByte();
-					int secondByte = fs.ReadByte();
-					switch ((firstByte << 8) | secondByte) {
-						case 0x0000: // either UTF-32 Big Endian or a binary file; use StreamReader
-						case 0xfffe: // Unicode BOM (UTF-16 LE or UTF-32 LE)
-						case 0xfeff: // UTF-16 BE BOM
-						case 0xefbb: // start of UTF-8 BOM
-							// StreamReader autodetection works
-							fs.Position = 0;
-							stream = new StreamReader(fs);
-							break;
-						default:
-							stream = AutoDetect(fs, (byte)firstByte, (byte)secondByte);
-							break;
-					}
-				} else {
-					Encoding encoding = this.Encoding;
-					if (encoding != null) {
-						stream = new StreamReader(fs, encoding);
-					} else {
-						stream = new StreamReader(fs);
-					}
-				}
-				Document.TextContent = stream.ReadToEnd();
-				if (autodetectEncoding) {
-					Encoding = stream.CurrentEncoding;
+			if (autodetectEncoding) {
+				Encoding encoding = this.Encoding;
+				Document.TextContent = Util.FileReader.ReadFileContent(fileName, ref encoding, this.TextEditorProperties.Encoding);
+				this.Encoding = encoding;
+			} else {
+				using (StreamReader reader = new StreamReader(fileName, this.Encoding)) {
+					Document.TextContent = reader.ReadToEnd();
 				}
-				stream.Close();
 			}
 			
 			this.FileName = fileName;
@@ -666,106 +641,18 @@ namespace ICSharpCode.TextEditor
 			Refresh();
 		}
 		
-		StreamReader AutoDetect(FileStream fs, byte firstByte, byte secondByte)
-		{
-			int max = (int)Math.Min(fs.Length, 500000); // look at max. 500 KB
-			const int ASCII = 0;
-			const int Error = 1;
-			const int UTF8  = 2;
-			const int UTF8Sequence = 3;
-			int state = ASCII;
-			int sequenceLength = 0;
-			byte b;
-			for (int i = 0; i < max; i++) {
-				if (i == 0) {
-					b = firstByte;
-				} else if (i == 1) {
-					b = secondByte;
-				} else {
-					b = (byte)fs.ReadByte();
-				}
-				if (b < 0x80) {
-					// normal ASCII character
-					if (state == UTF8Sequence) {
-						state = Error;
-						break;
-					}
-				} else if (b < 0xc0) {
-					// 10xxxxxx : continues UTF8 byte sequence
-					if (state == UTF8Sequence) {
-						--sequenceLength;
-						if (sequenceLength < 0) {
-							state = Error;
-							break;
-						} else if (sequenceLength == 0) {
-							state = UTF8;
-						}
-					} else {
-						state = Error;
-						break;
-					}
-				} else if (b > 0xc2 && b < 0xf5) {
-					// beginning of byte sequence
-					if (state == UTF8 || state == ASCII) {
-						state = UTF8Sequence;
-						if (b < 0xe0) {
-							sequenceLength = 1; // one more byte following
-						} else if (b < 0xf0) {
-							sequenceLength = 2; // two more bytes following
-						} else {
-							sequenceLength = 3; // three more bytes following
-						}
-					} else {
-						state = Error;
-						break;
-					}
-				} else {
-					// 0xc0, 0xc1, 0xf5 to 0xff are invalid in UTF-8 (see RFC 3629)
-					state = Error;
-					break;
-				}
-			}
-			fs.Position = 0;
-			switch (state) {
-				case ASCII:
-				case Error:
-					// when the file seems to be ASCII or non-UTF8,
-					// we read it using the user-specified encoding so it is saved again
-					// using that encoding.
-					Encoding defaultEncoding = this.TextEditorProperties.Encoding;
-					if (IsUnicode(defaultEncoding)) {
-						// the file is not Unicode, so don't read it using Unicode even if the
-						// user has choosen Unicode as the default encoding.
-						
-						// If we don't do this, SD will end up always adding a Byte Order Mark
-						// to ASCII files.
-						defaultEncoding = Encoding.Default; // use system encoding instead
-					}
-					return new StreamReader(fs, defaultEncoding);
-				default:
-					return new StreamReader(fs);
-			}
-		}
-		
 		/// <summary>
 		/// Gets if the document can be saved with the current encoding without losing data.
 		/// </summary>
 		public bool CanSaveWithCurrentEncoding()
 		{
-			if (encoding == null || IsUnicode(encoding))
+			if (encoding == null || Util.FileReader.IsUnicode(encoding))
 				return true;
 			// not a unicode codepage
 			string text = document.TextContent;
 			return encoding.GetString(encoding.GetBytes(text)) == text;
 		}
 		
-		bool IsUnicode(Encoding encoding)
-		{
-			int codepage = encoding.CodePage;
-			// return true if codepage is any UTF codepage
-			return codepage == 65001 || codepage == 65000 || codepage == 1200 || codepage == 1201;
-		}
-		
 		/// <remarks>
 		/// Saves a file given by fileName
 		/// </remarks>

src/Libraries/ICSharpCode.TextEditor/Project/Src/Util/FileReader.cs

@@ -0,0 +1,143 @@
+/*
+ * Created by SharpDevelop.
+ * User: Daniel Grunwald
+ * Date: 03.10.2005
+ * Time: 11:57
+ */
+
+using System;
+using System.IO;
+using System.Text;
+
+namespace ICSharpCode.TextEditor.Util
+{
+	/// <summary>
+	/// Class that can open text files with auto-detection of the encoding.
+	/// </summary>
+	public static class FileReader
+	{
+		public static bool IsUnicode(Encoding encoding)
+		{
+			int codepage = encoding.CodePage;
+			// return true if codepage is any UTF codepage
+			return codepage == 65001 || codepage == 65000 || codepage == 1200 || codepage == 1201;
+		}
+		
+		public static string ReadFileContent(string fileName, ref Encoding encoding, Encoding defaultEncoding)
+		{
+			using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read)) {
+				using (StreamReader reader = OpenStream(fs, encoding, defaultEncoding)) {
+					encoding = reader.CurrentEncoding;
+					return reader.ReadToEnd();
+				}
+			}
+		}
+		
+		public static StreamReader OpenStream(FileStream fs, Encoding suggestedEncoding, Encoding defaultEncoding)
+		{
+			if (fs.Length > 3) {
+				// the autodetection of StreamReader is not capable of detecting the difference
+				// between ISO-8859-1 and UTF-8 without BOM.
+				int firstByte = fs.ReadByte();
+				int secondByte = fs.ReadByte();
+				switch ((firstByte << 8) | secondByte) {
+					case 0x0000: // either UTF-32 Big Endian or a binary file; use StreamReader
+					case 0xfffe: // Unicode BOM (UTF-16 LE or UTF-32 LE)
+					case 0xfeff: // UTF-16 BE BOM
+					case 0xefbb: // start of UTF-8 BOM
+						// StreamReader autodetection works
+						fs.Position = 0;
+						return new StreamReader(fs);
+					default:
+						return AutoDetect(fs, (byte)firstByte, (byte)secondByte, defaultEncoding);
+				}
+			} else {
+				if (suggestedEncoding != null) {
+					return new StreamReader(fs, suggestedEncoding);
+				} else {
+					return new StreamReader(fs);
+				}
+			}
+		}
+		
+		static StreamReader AutoDetect(FileStream fs, byte firstByte, byte secondByte, Encoding defaultEncoding)
+		{
+			int max = (int)Math.Min(fs.Length, 500000); // look at max. 500 KB
+			const int ASCII = 0;
+			const int Error = 1;
+			const int UTF8  = 2;
+			const int UTF8Sequence = 3;
+			int state = ASCII;
+			int sequenceLength = 0;
+			byte b;
+			for (int i = 0; i < max; i++) {
+				if (i == 0) {
+					b = firstByte;
+				} else if (i == 1) {
+					b = secondByte;
+				} else {
+					b = (byte)fs.ReadByte();
+				}
+				if (b < 0x80) {
+					// normal ASCII character
+					if (state == UTF8Sequence) {
+						state = Error;
+						break;
+					}
+				} else if (b < 0xc0) {
+					// 10xxxxxx : continues UTF8 byte sequence
+					if (state == UTF8Sequence) {
+						--sequenceLength;
+						if (sequenceLength < 0) {
+							state = Error;
+							break;
+						} else if (sequenceLength == 0) {
+							state = UTF8;
+						}
+					} else {
+						state = Error;
+						break;
+					}
+				} else if (b > 0xc2 && b < 0xf5) {
+					// beginning of byte sequence
+					if (state == UTF8 || state == ASCII) {
+						state = UTF8Sequence;
+						if (b < 0xe0) {
+							sequenceLength = 1; // one more byte following
+						} else if (b < 0xf0) {
+							sequenceLength = 2; // two more bytes following
+						} else {
+							sequenceLength = 3; // three more bytes following
+						}
+					} else {
+						state = Error;
+						break;
+					}
+				} else {
+					// 0xc0, 0xc1, 0xf5 to 0xff are invalid in UTF-8 (see RFC 3629)
+					state = Error;
+					break;
+				}
+			}
+			fs.Position = 0;
+			switch (state) {
+				case ASCII:
+				case Error:
+					// when the file seems to be ASCII or non-UTF8,
+					// we read it using the user-specified encoding so it is saved again
+					// using that encoding.
+					if (IsUnicode(defaultEncoding)) {
+						// the file is not Unicode, so don't read it using Unicode even if the
+						// user has choosen Unicode as the default encoding.
+						
+						// If we don't do this, SD will end up always adding a Byte Order Mark
+						// to ASCII files.
+						defaultEncoding = Encoding.Default; // use system encoding instead
+					}
+					return new StreamReader(fs, defaultEncoding);
+				default:
+					return new StreamReader(fs);
+			}
+		}
+	}
+}

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

@@ -86,7 +86,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get;
 		}
 		
-		List<ITypeParameter> TypeParameters {
+		IList<ITypeParameter> TypeParameters {
 			get;
 		}
 

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

@@ -22,7 +22,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			set;
 		}
 		
-		List<IAttribute> Attributes {
+		IList<IAttribute> Attributes {
 			get;
 		}
 		

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

@@ -17,14 +17,14 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get;
 		}
 		
-		List<IParameter> Parameters {
+		IList<IParameter> Parameters {
 			get;
 		}
 	}
 	
 	public interface IMethod : IMethodOrProperty
 	{
-		List<ITypeParameter> TypeParameters {
+		IList<ITypeParameter> TypeParameters {
 			get;
 		}
 		

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

@@ -23,7 +23,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			set;
 		}
 
-		List<IAttribute> Attributes {
+		IList<IAttribute> Attributes {
 			get;
 		}
 

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

@@ -14,10 +14,10 @@ using ICSharpCode.Core;
 namespace ICSharpCode.SharpDevelop.Dom
 {
 	[Serializable]
-	public abstract class AbstractDecoration : MarshalByRefObject, IDecoration
+	public abstract class AbstractDecoration : IDecoration
 	{
 		ModifierEnum            modifiers  = ModifierEnum.None;
-		List<IAttribute> attributes = null;
+		IList<IAttribute> attributes = null;
 		
 		IClass declaringType;
 		object userData = null;
@@ -46,13 +46,16 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		public List<IAttribute> Attributes {
+		public IList<IAttribute> Attributes {
 			get {
 				if (attributes == null) {
 					attributes = new List<IAttribute>();
 				}
 				return attributes;
 			}
+			set {
+				attributes = value;
+			}
 		}
 		
 		string documentation;

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

@@ -21,9 +21,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 		public string FullyQualifiedName {
 			get {
 				if (fullyQualifiedName == null) {
-					return String.Empty;
+					if (name != null && nspace != null) {
+						fullyQualifiedName = nspace + '.' + name;
+					} else {
+						return String.Empty;
+					}
 				}
-				
 				return fullyQualifiedName;
 			}
 			set {
@@ -101,12 +104,14 @@ namespace ICSharpCode.SharpDevelop.Dom
 			System.Diagnostics.Debug.Assert(declaringType != null);
 			this.name = name;
 			nspace = declaringType.FullyQualifiedName;
-			fullyQualifiedName = nspace + '.' + name;
+			
+			// lazy-computing the fully qualified name for class members saves ~7 MB RAM (when loading the SharpDevelop solution).
+			//fullyQualifiedName = nspace + '.' + name;
 		}
 		
 		public override string ToString()
 		{
-			return String.Format("[{0}: {1}]", GetType().Name, fullyQualifiedName);
+			return String.Format("[{0}: {1}]", GetType().Name, FullyQualifiedName);
 		}
 	}
 }

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

@@ -57,8 +57,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 			foreach (IClass part in parts) {
 				modifier |= part.Modifiers;
 				this.BaseTypes.AddRange(part.BaseTypes);
-				this.TypeParameters.AddRange(part.TypeParameters);
-				this.Attributes.AddRange(part.Attributes);
+				foreach (ITypeParameter typeParam in part.TypeParameters) {
+					this.TypeParameters.Add(typeParam);
+				}
+				foreach (IAttribute attribute in part.Attributes) {
+					this.Attributes.Add(attribute);
+				}
 			}
 			this.Modifiers = modifier;
 		}

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

@@ -87,7 +87,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		bool CheckParameters(List<IParameter> l)
+		bool CheckParameters(IList<IParameter> l)
 		{
 			foreach (IParameter p in l) {
 				if (CheckReturnType(p.ReturnType)) return true;

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

@@ -13,6 +13,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 {
 	public class DefaultAttribute : IAttribute
 	{
+		public static readonly IList<IAttribute> EmptyAttributeList = new List<IAttribute>().AsReadOnly();
+		
 		string name;
 		List<AttributeArgument> positionalArguments;
 		SortedList<string, AttributeArgument> namedArguments;

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

@@ -30,7 +30,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		List<IProperty> properties   = null;
 		List<IMethod>   methods      = null;
 		List<IEvent>    events       = null;
-		List<ITypeParameter> typeParameters = null;
+		IList<ITypeParameter> typeParameters = null;
 		
 		public DefaultClass(ICompilationUnit compilationUnit, string fullyQualifiedName) : base(null)
 		{
@@ -181,13 +181,16 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		public virtual List<ITypeParameter> TypeParameters {
+		public virtual IList<ITypeParameter> TypeParameters {
 			get {
 				if (typeParameters == null) {
 					typeParameters = new List<ITypeParameter>();
 				}
 				return typeParameters;
 			}
+			set {
+				typeParameters = value;
+			}
 		}
 		
 		public virtual int CompareTo(IClass value)

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

@@ -53,8 +53,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 	{
 		protected DomRegion bodyRegion;
 		
-		List<IParameter> parameters = null;
-		List<ITypeParameter> typeParameters = null;
+		IList<IParameter> parameters = null;
+		IList<ITypeParameter> typeParameters = null;
 		
 		public override IMember Clone()
 		{
@@ -82,7 +82,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 					string dotnetName = this.DotNetName;
 					StringBuilder b = new StringBuilder("M:", dotnetName.Length + 2);
 					b.Append(dotnetName);
-					List<IParameter> paras = this.Parameters;
+					IList<IParameter> paras = this.Parameters;
 					if (paras.Count > 0) {
 						b.Append('(');
 						for (int i = 0; i < paras.Count; ++i) {
@@ -106,16 +106,19 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		public virtual List<ITypeParameter> TypeParameters {
+		public virtual IList<ITypeParameter> TypeParameters {
 			get {
 				if (typeParameters == null) {
 					typeParameters = new List<ITypeParameter>();
 				}
 				return typeParameters;
 			}
+			set {
+				typeParameters = value;
+			}
 		}
 		
-		public virtual List<IParameter> Parameters {
+		public virtual IList<IParameter> Parameters {
 			get {
 				if (parameters == null) {
 					parameters = new List<IParameter>();

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

@@ -12,8 +12,10 @@ using System.Collections.Generic;
 namespace ICSharpCode.SharpDevelop.Dom
 {
 	[Serializable]
-	public class DefaultParameter : System.MarshalByRefObject, IParameter
+	public class DefaultParameter : IParameter
 	{
+		public static readonly IList<IParameter> EmptyParameterList = new List<IParameter>().AsReadOnly();
+		
 		string              name;
 		string              documentation;
 		
@@ -23,7 +25,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		protected IReturnType         returnType;
 		protected ParameterModifiers  modifier;
 		protected DomRegion region;
-		List<IAttribute> attributes;
+		IList<IAttribute> attributes;
 		
 		protected DefaultParameter(string name)
 		{
@@ -93,13 +95,16 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 
-		public virtual List<IAttribute> Attributes {
+		public virtual IList<IAttribute> Attributes {
 			get {
 				if (attributes == null) {
 					attributes = new List<IAttribute>();
 				}
 				return attributes;
 			}
+			set {
+				attributes = value;
+			}
 		}
 
 		public virtual ParameterModifiers Modifiers {
@@ -128,7 +133,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		public static List<IParameter> Clone(List<IParameter> l)
+		public static List<IParameter> Clone(IList<IParameter> l)
 		{
 			List<IParameter> r = new List<IParameter>(l.Count);
 			for (int i = 0; i < l.Count; ++i) {

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

@@ -18,7 +18,7 @@ namespace ICSharpCode.SharpDevelop.Dom {
 		DomRegion getterRegion = DomRegion.Empty;
 		DomRegion setterRegion = DomRegion.Empty;
 		
-		List<IParameter> parameters = null;
+		IList<IParameter> parameters = null;
 		internal byte accessFlags;
 		const byte indexerFlag = 1;
 		const byte getterFlag  = 2;
@@ -59,7 +59,7 @@ namespace ICSharpCode.SharpDevelop.Dom {
 			return p;
 		}
 		
-		public virtual List<IParameter> Parameters {
+		public virtual IList<IParameter> Parameters {
 			get {
 				if (parameters == null) {
 					parameters = new List<IParameter>();

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

@@ -16,6 +16,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 	/// </summary>
 	public class DefaultTypeParameter : ITypeParameter
 	{
+		public static readonly IList<ITypeParameter> EmptyTypeParameterList = new List<ITypeParameter>().AsReadOnly();
+		
 		string name;
 		IMethod method;
 		IClass targetClass;

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

@@ -232,7 +232,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			inferredTypeParameters = new IReturnType[list.Count][];
 			for (int i = 0; i < ranking.Length; i++) {
 				if (ranking[i] == maxScore) {
-					List<IParameter> parameters = list[i].Parameters;
+					IList<IParameter> parameters = list[i].Parameters;
 					IReturnType[] typeParameters = (list[i] is IMethod) ? InferTypeArguments((IMethod)list[i], arguments) : null;
 					inferredTypeParameters[i] = typeParameters;
 					IReturnType paramsType = null;
@@ -366,7 +366,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			int count = method.TypeParameters.Count;
 			if (count == 0) return null;
 			IReturnType[] result = new IReturnType[count];
-			List<IParameter> parameters = method.Parameters;
+			IList<IParameter> parameters = method.Parameters;
 			for (int i = 0; i < arguments.Length; i++) {
 				if (i >= parameters.Count)
 					break;
@@ -432,7 +432,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		#endregion
 		
 		#region IsApplicable
-		static bool IsApplicable(List<IParameter> parameters,
+		static bool IsApplicable(IList<IParameter> parameters,
 		                         IReturnType[] arguments,
 		                         bool allowAdditionalArguments,
 		                         out int score,

src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs

@@ -174,6 +174,15 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			return data;
 		}
 		
+		void ConvertAttributes(AST.AttributedNode from, AbstractDecoration to)
+		{
+			if (from.Attributes.Count == 0) {
+				to.Attributes = DefaultAttribute.EmptyAttributeList;
+			} else {
+				to.Attributes = VisitAttributes(from.Attributes);
+			}
+		}
+		
 		List<IAttribute> VisitAttributes(List<AST.AttributeSection> attributes)
 		{
 			// TODO Expressions???
@@ -268,7 +277,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		{
 			DomRegion region = GetRegion(typeDeclaration.StartLocation, typeDeclaration.EndLocation);
 			DefaultClass c = new DefaultClass(cu, TranslateClassType(typeDeclaration.Type), ConvertModifier(typeDeclaration.Modifier, ModifierEnum.Internal), region, GetCurrentClass());
-			c.Attributes.AddRange(VisitAttributes(typeDeclaration.Attributes));
+			ConvertAttributes(typeDeclaration, c);
 			c.Documentation = GetDocumentation(region.BeginLine);
 			
 			if (currentClass.Count > 0) {
@@ -314,19 +323,27 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			return ret;
 		}
 		
-		void ConvertTemplates(List<AST.TemplateDefinition> templateList, IClass c)
+		void ConvertTemplates(List<AST.TemplateDefinition> templateList, DefaultClass c)
 		{
 			int index = 0;
-			foreach (AST.TemplateDefinition template in templateList) {
-				c.TypeParameters.Add(ConvertConstraints(template, new DefaultTypeParameter(c, template.Name, index++)));
+			if (templateList.Count == 0) {
+				c.TypeParameters = DefaultTypeParameter.EmptyTypeParameterList;
+			} else {
+				foreach (AST.TemplateDefinition template in templateList) {
+					c.TypeParameters.Add(ConvertConstraints(template, new DefaultTypeParameter(c, template.Name, index++)));
+				}
 			}
 		}
 		
-		void ConvertTemplates(List<AST.TemplateDefinition> templateList, IMethod m)
+		void ConvertTemplates(List<AST.TemplateDefinition> templateList, DefaultMethod m)
 		{
 			int index = 0;
-			foreach (AST.TemplateDefinition template in templateList) {
-				m.TypeParameters.Add(ConvertConstraints(template, new DefaultTypeParameter(m, template.Name, index++)));
+			if (templateList.Count == 0) {
+				m.TypeParameters = DefaultTypeParameter.EmptyTypeParameterList;
+			} else {
+				foreach (AST.TemplateDefinition template in templateList) {
+					m.TypeParameters.Add(ConvertConstraints(template, new DefaultTypeParameter(m, template.Name, index++)));
+				}
 			}
 		}
 		
@@ -343,7 +360,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			DomRegion region = GetRegion(delegateDeclaration.StartLocation, delegateDeclaration.EndLocation);
 			DefaultClass c = new DefaultClass(cu, ClassType.Delegate, ConvertModifier(delegateDeclaration.Modifier, ModifierEnum.Internal), region, GetCurrentClass());
 			c.Documentation = GetDocumentation(region.BeginLine);
-			c.Attributes.AddRange(VisitAttributes(delegateDeclaration.Attributes));
+			ConvertAttributes(delegateDeclaration, c);
 			c.BaseTypes.Add(ReflectionReturnType.CreatePrimitive(typeof(Delegate)));
 			if (currentClass.Count > 0) {
 				DefaultClass cur = GetCurrentClass();
@@ -405,11 +422,13 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			method.Documentation = GetDocumentation(region.BeginLine);
 			ConvertTemplates(methodDeclaration.Templates, method);
 			method.ReturnType = CreateReturnType(methodDeclaration.TypeReference, method);
-			method.Attributes.AddRange(VisitAttributes(methodDeclaration.Attributes));
-			if (methodDeclaration.Parameters != null) {
+			ConvertAttributes(methodDeclaration, method);
+			if (methodDeclaration.Parameters != null && methodDeclaration.Parameters.Count > 0) {
 				foreach (AST.ParameterDeclarationExpression par in methodDeclaration.Parameters) {
 					method.Parameters.Add(CreateParameter(par, method));
 				}
+			} else {
+				method.Parameters = DefaultParameter.EmptyParameterList;
 			}
 			c.Methods.Add(method);
 			return null;
@@ -422,6 +441,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			DomRegion bodyRegion = GetRegion(operatorDeclaration.EndLocation, operatorDeclaration.Body != null ? operatorDeclaration.Body.EndLocation : new Point(-1, -1));
 			
 			DefaultMethod method = new DefaultMethod(operatorDeclaration.Name, CreateReturnType(operatorDeclaration.ConvertToType), ConvertModifier(operatorDeclaration.Modifier), region, bodyRegion, c);
+			ConvertAttributes(operatorDeclaration, method);
 			if(operatorDeclaration.Parameters != null)
 			{
 				foreach (AST.ParameterDeclarationExpression par in operatorDeclaration.Parameters) {
@@ -440,7 +460,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			
 			Constructor constructor = new Constructor(ConvertModifier(constructorDeclaration.Modifier), region, bodyRegion, GetCurrentClass());
 			constructor.Documentation = GetDocumentation(region.BeginLine);
-			constructor.Attributes.AddRange(VisitAttributes(constructorDeclaration.Attributes));
+			ConvertAttributes(constructorDeclaration, constructor);
 			if (constructorDeclaration.Parameters != null) {
 				foreach (AST.ParameterDeclarationExpression par in constructorDeclaration.Parameters) {
 					constructor.Parameters.Add(CreateParameter(par));
@@ -458,7 +478,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			DefaultClass c = GetCurrentClass();
 			
 			Destructor destructor = new Destructor(region, bodyRegion, c);
-			destructor.Attributes.AddRange(VisitAttributes(destructorDeclaration.Attributes));
+			ConvertAttributes(destructorDeclaration, destructor);
 			c.Methods.Add(destructor);
 			return null;
 		}
@@ -479,7 +499,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 					else
 						retType = CreateReturnType(fieldDeclaration.GetTypeForField(i));
 					DefaultField f = new DefaultField(retType, field.Name, ConvertModifier(fieldDeclaration.Modifier), region, c);
-					f.Attributes.AddRange(VisitAttributes(fieldDeclaration.Attributes));
+					ConvertAttributes(fieldDeclaration, f);
 					f.Documentation = doku;
 					if (c.ClassType == ClassType.Enum) {
 						f.Modifiers = ModifierEnum.Const | ModifierEnum.Public;
@@ -509,7 +529,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				property.CanSet = true;
 			}
 			property.Documentation = GetDocumentation(region.BeginLine);
-			property.Attributes.AddRange(VisitAttributes(propertyDeclaration.Attributes));
+			ConvertAttributes(propertyDeclaration, property);
 			c.Properties.Add(property);
 			return null;
 		}
@@ -525,12 +545,12 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			if (eventDeclaration.VariableDeclarators != null && eventDeclaration.VariableDeclarators.Count > 0) {
 				foreach (ICSharpCode.NRefactory.Parser.AST.VariableDeclaration varDecl in eventDeclaration.VariableDeclarators) {
 					e = new DefaultEvent(varDecl.Name, type, ConvertModifier(eventDeclaration.Modifier), region, bodyRegion, GetCurrentClass());
-					e.Attributes.AddRange(VisitAttributes(eventDeclaration.Attributes));
+					ConvertAttributes(eventDeclaration, e);
 					c.Events.Add(e);
 				}
 			} else {
 				e = new DefaultEvent(eventDeclaration.Name, type, ConvertModifier(eventDeclaration.Modifier), region, bodyRegion, GetCurrentClass());
-				e.Attributes.AddRange(VisitAttributes(eventDeclaration.Attributes));
+				ConvertAttributes(eventDeclaration, e);
 				c.Events.Add(e);
 			}
 			if (e != null) {
@@ -548,7 +568,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			DefaultProperty i = new DefaultProperty("Indexer", CreateReturnType(indexerDeclaration.TypeReference), ConvertModifier(indexerDeclaration.Modifier), region, bodyRegion, GetCurrentClass());
 			i.IsIndexer = true;
 			i.Documentation = GetDocumentation(region.BeginLine);
-			i.Attributes.AddRange(VisitAttributes(indexerDeclaration.Attributes));
+			ConvertAttributes(indexerDeclaration, i);
 			if (indexerDeclaration.Parameters != null) {
 				foreach (AST.ParameterDeclarationExpression par in indexerDeclaration.Parameters) {
 					i.Parameters.Add(CreateParameter(par));

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

@@ -966,16 +966,16 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			AddUsing(result, projectContent.DefaultImports);
 			
 			if (callingClass != null) {
+				foreach (object member in projectContent.GetNamespaceContents(callingClass.Namespace)) {
+					if (!result.Contains(member))
+						result.Add(member);
+				}
 				IClass currentClass = callingClass;
 				do {
 					foreach (IClass innerClass in currentClass.GetAccessibleTypes(currentClass)) {
 						if (!result.Contains(innerClass))
 							result.Add(innerClass);
 					}
-					foreach (object member in projectContent.GetNamespaceContents(currentClass.Namespace)) {
-						if (!result.Contains(member))
-							result.Add(member);
-					}
 					currentClass = currentClass.DeclaringType;
 				} while (currentClass != null);
 			}

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

@@ -21,7 +21,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 	{
 		public const long FileMagic = 0x11635233ED2F428C;
 		public const long IndexFileMagic = 0x11635233ED2F427D;
-		public const short FileVersion = 3;
+		public const short FileVersion = 4;
 		
 		#region Cache management
 		#if DEBUG
@@ -73,7 +73,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 			ReflectionProjectContent pc;
 			using (FileStream fs = new FileStream(cacheFileName, FileMode.Open, FileAccess.Read)) {
 				using (BinaryReader reader = new BinaryReader(fs)) {
-					pc = new ReadWriteHelper(reader).ReadProjectContent();
+					try {
+						pc = new ReadWriteHelper(reader).ReadProjectContent();
+					} catch (EndOfStreamException) {
+						LoggingService.Warn("Read dom: EndOfStreamException");
+						return null;
+					}
 				}
 			}
 			if (pc != null) {
@@ -193,9 +198,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 			
 			readonly BinaryWriter writer;
 			readonly Dictionary<ClassNameTypeCountPair, int> classIndices = new Dictionary<ClassNameTypeCountPair, int>();
+			readonly Dictionary<string, int> stringDict = new Dictionary<string, int>();
 			
 			readonly BinaryReader reader;
 			IReturnType[] types;
+			string[] stringArray;
 			
 			#region Write/Read ProjectContent
 			public ReadWriteHelper(BinaryWriter writer)
@@ -252,8 +259,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 					referencedAssemblies[i] = new AssemblyName(reader.ReadString());
 				}
 				this.pc = new ReflectionProjectContent(assemblyName, assemblyLocation, referencedAssemblies);
-				ReadClasses();
-				return pc;
+				if (ReadClasses()) {
+					return pc;
+				} else {
+					LoggingService.Warn("Read dom: error in file (invalid control mark)");
+					return null;
+				}
 			}
 			
 			void WriteClasses()
@@ -261,6 +272,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 				ICollection<IClass> classes = pc.Classes;
 				
 				classIndices.Clear();
+				stringDict.Clear();
 				int i = 0;
 				foreach (IClass c in classes) {
 					classIndices[new ClassNameTypeCountPair(c)] = i;
@@ -268,7 +280,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 				}
 				
 				List<ClassNameTypeCountPair> externalTypes = new List<ClassNameTypeCountPair>();
-				CreateExternalTypeList(externalTypes, classes.Count, classes);
+				List<string> stringList = new List<string>();
+				CreateExternalTypeList(externalTypes, stringList, classes.Count, classes);
 				
 				writer.Write(classes.Count);
 				writer.Write(externalTypes.Count);
@@ -279,12 +292,19 @@ namespace ICSharpCode.SharpDevelop.Dom
 					writer.Write(type.ClassName);
 					writer.Write(type.TypeParameterCount);
 				}
+				writer.Write(stringList.Count);
+				foreach (string text in stringList) {
+					writer.Write(text);
+				}
 				foreach (IClass c in classes) {
 					WriteClass(c);
+					// BinaryReader easily reads junk data when the file does not have the
+					// expected format, so we put a checking byte after each class.
+					writer.Write((byte)64);
 				}
 			}
 			
-			void ReadClasses()
+			bool ReadClasses()
 			{
 				int classCount = reader.ReadInt32();
 				int externalTypeCount = reader.ReadInt32();
@@ -299,10 +319,18 @@ namespace ICSharpCode.SharpDevelop.Dom
 					string name = reader.ReadString();
 					types[i] = new GetClassReturnType(pc, name, reader.ReadByte());
 				}
+				stringArray = new string[reader.ReadInt32()];
+				for (int i = 0; i < stringArray.Length; i++) {
+					stringArray[i] = reader.ReadString();
+				}
 				for (int i = 0; i < classes.Length; i++) {
 					ReadClass(classes[i]);
 					pc.AddClassToNamespaceList(classes[i]);
+					if (reader.ReadByte() != 64) {
+						return false;
+					}
 				}
+				return true;
 			}
 			#endregion
 			
@@ -322,7 +350,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 				WriteAttributes(c.Attributes);
 				writer.Write(c.InnerClasses.Count);
 				foreach (IClass innerClass in c.InnerClasses) {
-					WriteString(innerClass.FullyQualifiedName);
+					writer.Write(innerClass.FullyQualifiedName);
 					WriteClass(innerClass);
 				}
 				this.currentClass = c;
@@ -345,7 +373,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 				this.currentClass = null;
 			}
 			
-			void WriteTemplates(List<ITypeParameter> list)
+			void WriteTemplates(IList<ITypeParameter> list)
 			{
 				// read code exists twice: in ReadClass and ReadMethod
 				writer.Write((byte)list.Count);
@@ -368,11 +396,15 @@ namespace ICSharpCode.SharpDevelop.Dom
 				for (int i = 0; i < count; i++) {
 					c.TypeParameters.Add(new DefaultTypeParameter(c, ReadString(), i));
 				}
-				foreach (ITypeParameter typeParameter in c.TypeParameters) {
-					count = reader.ReadInt32();
-					for (int i = 0; i < count; i++) {
-						typeParameter.Constraints.Add(ReadType());
+				if (count > 0) {
+					foreach (ITypeParameter typeParameter in c.TypeParameters) {
+						count = reader.ReadInt32();
+						for (int i = 0; i < count; i++) {
+							typeParameter.Constraints.Add(ReadType());
+						}
 					}
+				} else {
+					c.TypeParameters = DefaultTypeParameter.EmptyTypeParameterList;
 				}
 				count = reader.ReadInt32();
 				for (int i = 0; i < count; i++) {
@@ -380,11 +412,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 				}
 				c.Modifiers = (ModifierEnum)reader.ReadInt32();
 				c.ClassType = (ClassType)reader.ReadByte();
-				ReadAttributes(c.Attributes);
+				ReadAttributes(c);
 				count = reader.ReadInt32();
 				for (int i = 0; i < count; i++) {
 					DefaultClass innerClass = new DefaultClass(c.CompilationUnit, c);
-					innerClass.FullyQualifiedName = ReadString();
+					innerClass.FullyQualifiedName = reader.ReadString();
 					c.InnerClasses.Add(innerClass);
 					ReadClass(innerClass);
 				}
@@ -409,42 +441,54 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 			#endregion
 			
-			#region Write/Read return types
+			#region Write/Read return types / Collect strings
 			/// <summary>
 			/// Finds all return types used in the class collection and adds the unknown ones
 			/// to the externalTypeIndices and externalTypes collections.
 			/// </summary>
 			void CreateExternalTypeList(List<ClassNameTypeCountPair> externalTypes,
+			                            List<string> stringList,
 			                            int classCount, ICollection<IClass> classes)
 			{
 				foreach (IClass c in classes) {
-					CreateExternalTypeList(externalTypes, classCount, c.InnerClasses);
+					CreateExternalTypeList(externalTypes, stringList, classCount, c.InnerClasses);
+					AddStrings(stringList, c.Attributes);
 					foreach (IReturnType returnType in c.BaseTypes) {
 						AddExternalType(returnType, externalTypes, classCount);
 					}
 					foreach (ITypeParameter tp in c.TypeParameters) {
+						AddString(stringList, tp.Name);
 						foreach (IReturnType returnType in tp.Constraints) {
 							AddExternalType(returnType, externalTypes, classCount);
 						}
 					}
 					foreach (IField f in c.Fields) {
+						AddStrings(stringList, f);
 						AddExternalType(f.ReturnType, externalTypes, classCount);
 					}
 					foreach (IEvent f in c.Events) {
+						AddStrings(stringList, f);
 						AddExternalType(f.ReturnType, externalTypes, classCount);
 					}
 					foreach (IProperty p in c.Properties) {
+						AddStrings(stringList, p);
 						AddExternalType(p.ReturnType, externalTypes, classCount);
 						foreach (IParameter parameter in p.Parameters) {
+							AddString(stringList, parameter.Name);
+							AddStrings(stringList, parameter.Attributes);
 							AddExternalType(parameter.ReturnType, externalTypes, classCount);
 						}
 					}
 					foreach (IMethod m in c.Methods) {
+						AddStrings(stringList, m);
 						AddExternalType(m.ReturnType, externalTypes, classCount);
 						foreach (IParameter parameter in m.Parameters) {
+							AddString(stringList, parameter.Name);
+							AddStrings(stringList, parameter.Attributes);
 							AddExternalType(parameter.ReturnType, externalTypes, classCount);
 						}
 						foreach (ITypeParameter tp in m.TypeParameters) {
+							AddString(stringList, tp.Name);
 							foreach (IReturnType returnType in tp.Constraints) {
 								AddExternalType(returnType, externalTypes, classCount);
 							}
@@ -453,6 +497,21 @@ namespace ICSharpCode.SharpDevelop.Dom
 				}
 			}
 			
+			void AddStrings(List<string> stringList, IMember member)
+			{
+				AddString(stringList, member.Name);
+				AddStrings(stringList, member.Attributes);
+			}
+			
+			void AddString(List<string> stringList, string text)
+			{
+				text = text ?? string.Empty;
+				if (!stringDict.ContainsKey(text)) {
+					stringDict.Add(text, stringList.Count);
+					stringList.Add(text);
+				}
+			}
+			
 			void AddExternalType(IReturnType rt, List<ClassNameTypeCountPair> externalTypes, int classCount)
 			{
 				if (rt.IsDefaultReturnType) {
@@ -555,12 +614,13 @@ namespace ICSharpCode.SharpDevelop.Dom
 			#region Write/Read class member
 			void WriteString(string text)
 			{
-				writer.Write(text ?? string.Empty);
+				text = text ?? string.Empty;
+				writer.Write(stringDict[text]);
 			}
 			
 			string ReadString()
 			{
-				return reader.ReadString();
+				return stringArray[reader.ReadInt32()];
 			}
 			
 			void WriteMember(IMember m)
@@ -574,11 +634,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 				}
 			}
 			
-			void ReadMember(IMember m)
+			void ReadMember(AbstractMember m)
 			{
 				// name is already read by the method that calls the member constructor
 				m.Modifiers = (ModifierEnum)reader.ReadInt32();
-				ReadAttributes(m.Attributes);
+				ReadAttributes(m);
 				if (!(m is IMethod)) {
 					m.ReturnType = ReadType();
 				}
@@ -595,9 +655,35 @@ namespace ICSharpCode.SharpDevelop.Dom
 				}
 			}
 			
-			void ReadAttributes(IList<IAttribute> attributes)
+			void AddStrings(List<string> stringList, IList<IAttribute> attributes)
+			{
+				foreach (IAttribute a in attributes) {
+					AddString(stringList, a.Name);
+				}
+			}
+			
+			void ReadAttributes(DefaultParameter parameter)
 			{
 				int count = reader.ReadUInt16();
+				if (count > 0) {
+					ReadAttributes(parameter.Attributes, count);
+				} else {
+					parameter.Attributes = DefaultAttribute.EmptyAttributeList;
+				}
+			}
+			
+			void ReadAttributes(AbstractDecoration decoration)
+			{
+				int count = reader.ReadUInt16();
+				if (count > 0) {
+					ReadAttributes(decoration.Attributes, count);
+				} else {
+					decoration.Attributes = DefaultAttribute.EmptyAttributeList;
+				}
+			}
+			
+			void ReadAttributes(IList<IAttribute> attributes, int count)
+			{
 				for (int i = 0; i < count; i++) {
 					string name = ReadString();
 					attributes.Add(new DefaultAttribute(name, (AttributeTarget)reader.ReadByte()));
@@ -617,14 +703,33 @@ namespace ICSharpCode.SharpDevelop.Dom
 				}
 			}
 			
-			void ReadParameters(IList<IParameter> parameters)
+			void ReadParameters(DefaultMethod m)
+			{
+				int count = reader.ReadUInt16();
+				if (count > 0) {
+					ReadParameters(m.Parameters, count);
+				} else {
+					m.Parameters = DefaultParameter.EmptyParameterList;
+				}
+			}
+			
+			void ReadParameters(DefaultProperty m)
 			{
 				int count = reader.ReadUInt16();
+				if (count > 0) {
+					ReadParameters(m.Parameters, count);
+				} else {
+					m.Parameters = DefaultParameter.EmptyParameterList;
+				}
+			}
+			
+			void ReadParameters(IList<IParameter> parameters, int count)
+			{
 				for (int i = 0; i < count; i++) {
 					string name = ReadString();
 					DefaultParameter p = new DefaultParameter(name, ReadType(), DomRegion.Empty);
 					p.Modifiers = (ParameterModifiers)reader.ReadByte();
-					ReadAttributes(p.Attributes);
+					ReadAttributes(p);
 					parameters.Add(p);
 				}
 			}
@@ -652,14 +757,18 @@ namespace ICSharpCode.SharpDevelop.Dom
 				for (int i = 0; i < count; i++) {
 					m.TypeParameters.Add(new DefaultTypeParameter(m, ReadString(), i));
 				}
-				foreach (ITypeParameter typeParameter in m.TypeParameters) {
-					count = reader.ReadInt32();
-					for (int i = 0; i < count; i++) {
-						typeParameter.Constraints.Add(ReadType());
+				if (count > 0) {
+					foreach (ITypeParameter typeParameter in m.TypeParameters) {
+						count = reader.ReadInt32();
+						for (int i = 0; i < count; i++) {
+							typeParameter.Constraints.Add(ReadType());
+						}
 					}
+				} else {
+					m.TypeParameters = DefaultTypeParameter.EmptyTypeParameterList;
 				}
 				m.ReturnType = ReadType();
-				ReadParameters(m.Parameters);
+				ReadParameters(m);
 				currentMethod = null;
 				return m;
 			}
@@ -678,7 +787,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 				DefaultProperty p = new DefaultProperty(currentClass, ReadString());
 				ReadMember(p);
 				p.accessFlags = reader.ReadByte();
-				ReadParameters(p.Parameters);
+				ReadParameters(p);
 				return p;
 			}
 			#endregion

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

@@ -65,7 +65,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			return type.IsSubclassOf(typeof(Delegate)) && type != typeof(MulticastDelegate);
 		}
 		
-		static void AddAttributes(IProjectContent pc, List<IAttribute> list, IList<CustomAttributeData> attributes)
+		static void AddAttributes(IProjectContent pc, IList<IAttribute> list, IList<CustomAttributeData> attributes)
 		{
 			foreach (CustomAttributeData att in attributes) {
 				DefaultAttribute a = new DefaultAttribute(att.Constructor.DeclaringType.FullName);

src/Main/Base/Project/Src/Internal/DiffUtility.cs

@@ -7,6 +7,7 @@
 
 using System;
 using System.Collections;
+using System.Collections.Generic;
 
 namespace ICSharpCode.SharpDevelop
 {
@@ -64,6 +65,31 @@ namespace ICSharpCode.SharpDevelop
 			return Compare(a, b, Comparer.Default);
 		}
 		
+		static public int Compare<T>(IList<T> a, IList<T> b)
+		{
+			return Compare(a, b, Comparer.Default);
+		}
+		
+		static public int Compare<T>(IList<T> a, IList<T> b, IComparer comparer)
+		{
+			if (a == null || b == null) {
+				return 1;
+			}
+			if (a.Count != b.Count) {
+				return Math.Sign(a.Count - b.Count);
+			}
+			int limit = (a.Count < b.Count) ? a.Count : b.Count;
+			for(int i=0; i < limit; i++) {
+				if (a[i] is IComparable && b[i] is IComparable) {
+					int cmp = comparer.Compare(a[i], b[i]);
+					if (cmp != 0) {
+						return cmp;
+					}
+				}
+			}
+			return a.Count - b.Count;
+		}
+		
 		static public int Compare(IList a, IList b, IComparer comparer)
 		{
 			if (a == null || b == null) {

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

@@ -95,7 +95,7 @@ namespace ICSharpCode.Core
 				loadSolutionProjectsThread.Join();
 			}
 			loadSolutionProjectsThread = new Thread(new ThreadStart(LoadSolutionProjects));
-			loadSolutionProjectsThread.Priority = ThreadPriority.Lowest;
+			loadSolutionProjectsThread.Priority = ThreadPriority.BelowNormal;
 			loadSolutionProjectsThread.IsBackground = true;
 			loadSolutionProjectsThread.Start();
 		}
@@ -166,7 +166,7 @@ namespace ICSharpCode.Core
 		{
 			abortParserUpdateThread = false;
 			Thread parserThread = new Thread(new ThreadStart(ParserUpdateThread));
-			parserThread.Priority = ThreadPriority.Lowest;
+			parserThread.Priority = ThreadPriority.BelowNormal;
 			parserThread.IsBackground  = true;
 			parserThread.Start();
 		}

src/Main/Base/Project/Src/Services/ProjectService/ParseableFileContentEnumerator.cs

@@ -63,6 +63,7 @@ namespace ICSharpCode.SharpDevelop.Project
 		
 		ProjectItem[] projectItems;
 		bool isOnMainThread;
+		Encoding defaultEncoding;
 		
 		public ParseableFileContentEnumerator(IProject project) : this(project.Items.ToArray()) { }
 		
@@ -70,20 +71,13 @@ namespace ICSharpCode.SharpDevelop.Project
 		{
 			isOnMainThread = !WorkbenchSingleton.InvokeRequired;
 			this.projectItems = projectItems;
-			Properties textEditorProperties = ((Properties)PropertyService.Get("ICSharpCode.TextEditor.Document.Document.DefaultDocumentAggregatorProperties", new Properties()));
-			getParseableContentEncoding = Encoding.GetEncoding(textEditorProperties.Get("Encoding", 1252));
-			pcd = new GetParseableContentDelegate(GetParseableFileContent);
 			if (projectItems.Length > 0) {
 				nextItem = projectItems[0];
 			}
+			Properties textEditorProperties = PropertyService.Get("ICSharpCode.TextEditor.Document.Document.DefaultDocumentAggregatorProperties", new Properties());
+			defaultEncoding = Encoding.GetEncoding(textEditorProperties.Get("Encoding", 1252));
 		}
 		
-		delegate string GetParseableContentDelegate(IProject project, string fileName);
-		
-		GetParseableContentDelegate pcd;
-		
-		Encoding getParseableContentEncoding;
-		
 		string GetParseableFileContent(IProject project, string fileName)
 		{
 			// Loading the source files is done asynchronously:
@@ -93,13 +87,11 @@ namespace ICSharpCode.SharpDevelop.Project
 				return res;
 			
 			// load file
-			using (StreamReader r = new StreamReader(fileName, getParseableContentEncoding)) {
-				return r.ReadToEnd();
-			}
+			Encoding tmp = defaultEncoding;
+			return ICSharpCode.TextEditor.Util.FileReader.ReadFileContent(fileName, ref tmp, defaultEncoding);
 		}
 		
 		ProjectItem nextItem;
-		IAsyncResult res;
 		int index = 0;
 		
 		public int ItemCount {
@@ -123,24 +115,14 @@ namespace ICSharpCode.SharpDevelop.Project
 				return MoveNext();
 			string fileContent;
 			try {
-				if (res != null) {
-					fileContent = pcd.EndInvoke(res);
-				} else {
-					fileContent = GetFileContent(item);
-				}
+				fileContent = GetFileContent(item);
 			} catch (FileNotFoundException ex) {
-				res = null;
 				LoggingService.Warn("ParseableFileContentEnumerator: " + ex.Message);
 				return MoveNext(); // skip files that were not found
 			} catch (IOException ex) {
-				res = null;
 				LoggingService.Warn("ParseableFileContentEnumerator: " + ex.Message);
 				return MoveNext(); // skip invalid files
 			}
-			if (nextItem != null && nextItem.ItemType == ItemType.Compile && CanReadAsync(nextItem))
-				res = pcd.BeginInvoke(nextItem.Project, nextItem.FileName, null, null);
-			else
-				res = null;
 			current = new KeyValuePair<string, string>(item.FileName, fileContent);
 			return true;
 		}
@@ -148,16 +130,40 @@ namespace ICSharpCode.SharpDevelop.Project
 		string GetFileContent(ProjectItem item)
 		{
 			string fileName = item.FileName;
-			string content;
-			if (isOnMainThread)
-				content = GetFileContentFromOpenFile(fileName);
-			else
-				content = (string)WorkbenchSingleton.SafeThreadCall(this, "GetFileContentFromOpenFile", fileName);
-			if (content != null)
-				return content;
+			if (IsFileOpen(fileName)) {
+				string content;
+				if (isOnMainThread)
+					content = GetFileContentFromOpenFile(fileName);
+				else
+					content = (string)WorkbenchSingleton.SafeThreadCall(this, "GetFileContentFromOpenFile", fileName);
+				if (content != null)
+					return content;
+			}
 			return GetParseableFileContent(item.Project, fileName);
 		}
 		
+		IViewContent[] viewContentCollection;
+		
+		IViewContent[] GetViewContentCollection()
+		{
+			return WorkbenchSingleton.Workbench.ViewContentCollection.ToArray();
+		}
+		
+		bool IsFileOpen(string fileName)
+		{
+			if (viewContentCollection == null) {
+				viewContentCollection = (IViewContent[])WorkbenchSingleton.SafeThreadCall(this, "GetViewContentCollection");
+			}
+			foreach (IViewContent content in viewContentCollection) {
+				string contentName = content.IsUntitled ? content.UntitledName : content.FileName;
+				if (contentName != null) {
+					if (FileUtility.IsEqualFileName(fileName, contentName))
+						return true;
+				}
+			}
+			return false;
+		}
+		
 		string GetFileContentFromOpenFile(string fileName)
 		{
 			IWorkbenchWindow window = FileService.GetOpenFile(fileName);
@@ -170,13 +176,5 @@ namespace ICSharpCode.SharpDevelop.Project
 			}
 			return null;
 		}
-		
-		bool CanReadAsync(ProjectItem item)
-		{
-			if (isOnMainThread)
-				return !FileService.IsOpen(item.FileName);
-			else
-				return !(bool)WorkbenchSingleton.SafeThreadCall(typeof(FileService), "IsOpen", item.FileName);
-		}
 	}
 }

src/Main/Base/Test/ReflectionLayerTests.cs

@@ -46,8 +46,8 @@ namespace ICSharpCode.SharpDevelop.Tests
 		{
 			DefaultParameter p1 = new DefaultParameter("a", pc.GetClass("System.String").DefaultReturnType, DomRegion.Empty);
 			DefaultParameter p2 = new DefaultParameter("b", new GetClassReturnType(pc, "System.String", 0), DomRegion.Empty);
-			List<IParameter> a1 = new List<IParameter>();
-			List<IParameter> a2 = new List<IParameter>();
+			IList<IParameter> a1 = new List<IParameter>();
+			IList<IParameter> a2 = new List<IParameter>();
 			a1.Add(p1);
 			a2.Add(p2);
 			Assert.AreEqual(0, DiffUtility.Compare(a1, a2));