[Monodevelop-patches-list] r1997 - in trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser: . ICSharpCode.AssemblyAnalyzer/Engine ICSharpCode.AssemblyAnalyzer/Rules ICSharpCode.AssemblyAnalyzer/Rules/DesignRules ICSharpCode.AssemblyAnalyzer/Rules/NamingRules ICSharpCode.AssemblyAnalyzer.AddIn ICSharpCode.AssemblyAnalyzer.AddIn/Gui ICSharpCode.AssemblyAnalyzer.AddIn/Gui/Panels

[commit-watcher at mono-cvs.ximian.com]

Author: jluke
Date: 2004-10-25 23:51:03 -0400 (Mon, 25 Oct 2004)
New Revision: 1997

Added:
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Engine/ChangeLog
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/ChangeLog
Modified:
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ChangeLog
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Commands.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/AssemblyAnalyserControl.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/AssemblyAnalyserView.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/Panels/AssemblyTreeControl.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/Panels/ResultDetailsView.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/Panels/ResultListControl.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Engine/AssemblyAnalyser.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Engine/Resolution.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/AbstractReflectionRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/AbstractRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AbstractTypesPublicConstructorsRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AssemblyClsCompliantRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AssemblyStrongNameRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AssemblyVersionNumberRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AvoidNamespacesWithFewMembers.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventFirstParameterIsObjectRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventHandlersReturnVoidRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventSecondParameterIsEventArgsRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventsHaveTwoParametersRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/InterfaceNotEmptyRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/PropertiesShouldNotHaveSetOnly.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/TypesHaveNoPublicInstanceFields.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/TypesShouldBeInNamespacesRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IAssemblyRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IConstructorRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IEventRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IFieldRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IMemberRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IMethodBaseRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IMethodRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IModuleRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/INamespaceRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IParameterRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IPropertyRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IReflectionRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/ITypeRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/AttributeSuffixIsAttributeRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/CheckCollectionSuffix.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/DelegatesHaveNoDelegateSuffix.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/DictionaryTypeSuffixIsDictionary.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EnumsHaveNoEnumSuffix.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventArgsSuffixIsEventArgsRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventFirstParameterNameIsSender.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventHandlerSuffixIsEventHandler.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventSecondParameterNameIsE.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventsDoNotHaveBeforeOrAfterPrefix.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/ExceptionSuffixIsExceptionRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/FlagEnumerationsArePlural.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/InterfacesPrefixIsI.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/MembersArePascalCased.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/MembersDoNotContainUnderscores.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/MembershipConditionNamesSuffixIsMembershipCondition.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/NamespacesArePascalCased.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/NamespacesDoNotContainUnderscores.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyAttributesSuffixAttributeRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyCollectionsSuffixCollectionRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyEventArgsSuffixEventArgsRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyEventHandlerSuffixIsEventHandlerRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyExceptionsSuffixExceptionRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyPermissionsSuffixPermissionRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyStreamsSuffixStreamRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/ParameterNamesDoNotHaveUnderscores.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/ParametersAreCamelCased.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/PermissionSuffixIsPermissionRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/StreamSuffixIsStreamRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/TypeNamesDoNotContainUnderscores.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/TypesArePascalCased.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/TypesImplementingInterfacesHaveNoSuffixImplRule.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingUtilities.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/PriorityLevel.cs
   trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/ProtectionLevels.cs
Log:
update


Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ChangeLog
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ChangeLog	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ChangeLog	2004-10-26 03:51:03 UTC (rev 1997)
@@ -0,0 +1,5 @@
+2004-10-26  John Luke  <john.luke at gmail.com>
+
+	* re-update the non-gui parts from SD svn and use it (mostly)
+	un-modified, only resources/I18N stuff should be different
+	update the Gui stuff to compile with ICSharpCode namespaces

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Engine/AssemblyAnalyser.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Engine/AssemblyAnalyser.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Engine/AssemblyAnalyser.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,217 +1,210 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Collections;
-using System.Reflection;
-using MonoDevelop.AssemblyAnalyser.Rules;
-
-namespace MonoDevelop.AssemblyAnalyser
-{
-	public class AssemblyAnalyser : System.MarshalByRefObject
-	{
-		ArrayList assemblyRules    = new ArrayList ();
-		ArrayList moduleRules      = new ArrayList ();
-		ArrayList typeRules        = new ArrayList ();
-		ArrayList namespaceRules   = new ArrayList ();
-		ArrayList memberRules      = new ArrayList ();
-		ArrayList methodBaseRules  = new ArrayList ();
-		ArrayList constructorRules = new ArrayList ();
-		ArrayList eventRules       = new ArrayList ();
-		ArrayList fieldRules       = new ArrayList ();
-		ArrayList methodRules      = new ArrayList ();
-		ArrayList parameterRules   = new ArrayList ();
-		ArrayList propertyRules    = new ArrayList ();
-		
-		ArrayList resolutions      = new ArrayList ();
-		
-		Hashtable namespaces       = new Hashtable ();
-		
-		public ArrayList Resolutions {
-			get {
-				return resolutions;
-			}
-		}
-		
-		public AssemblyAnalyser()
-		{
-			Type[] types = typeof (AssemblyAnalyser).Assembly.GetTypes ();
-			foreach (Type type in types) {
-				if (!type.IsAbstract && type.IsClass) {
-					if (type.GetInterface(typeof(IAssemblyRule).FullName) != null) {
- 						assemblyRules.Add(type.Assembly.CreateInstance(type.FullName));
-					} else if (type.GetInterface (typeof (IConstructorRule).FullName) != null) {
-						constructorRules.Add(type.Assembly.CreateInstance(type.FullName));
-					} else if (type.GetInterface (typeof (IEventRule).FullName) != null) {
-						eventRules.Add(type.Assembly.CreateInstance(type.FullName));
-					} else if (type.GetInterface (typeof (IFieldRule).FullName) != null) {
-						fieldRules.Add(type.Assembly.CreateInstance(type.FullName));
-					} else if (type.GetInterface (typeof (IMemberRule).FullName) != null) {
-						memberRules.Add(type.Assembly.CreateInstance(type.FullName));
-					} else if (type.GetInterface (typeof (IMethodBaseRule).FullName) != null) {
-						methodBaseRules.Add(type.Assembly.CreateInstance(type.FullName));
-					} else if (type.GetInterface (typeof (IMethodRule).FullName) != null) {
-						methodRules.Add(type.Assembly.CreateInstance(type.FullName));
-					} else if (type.GetInterface (typeof (IModuleRule).FullName) != null) {
-						moduleRules.Add(type.Assembly.CreateInstance(type.FullName));
-					} else if (type.GetInterface (typeof (INamespaceRule).FullName) != null) {
-						namespaceRules.Add(type.Assembly.CreateInstance(type.FullName));
-					} else if (type.GetInterface (typeof (IParameterRule).FullName) != null) {
-						parameterRules.Add(type.Assembly.CreateInstance(type.FullName));
-					} else if (type.GetInterface (typeof (IPropertyRule).FullName) != null) {
-						propertyRules.Add(type.Assembly.CreateInstance(type.FullName));
-					} else if (type.GetInterface (typeof (ITypeRule).FullName) != null) {
-						typeRules.Add(type.Assembly.CreateInstance (type.FullName));
-					}
-				}
-			}
-		}
-		
-		void AddResolutions (Resolution resolution)
-		{
-			if (resolution != null) {
-				resolutions.Add (resolution);
-			}
-		}
-		
-		public void Analyse (string fileName)
-		{
-			Assembly assembly = null;
-			
-			try {
-				assembly = Assembly.LoadFrom (fileName);
-			} catch (Exception e) {
-				resolutions.Add (new Resolution (new CustomRule ("Assembly cannot be loaded.",
-				                                              "Assembly cannot be loaded details. ", PriorityLevel.CriticalError, 100), 
-				                               "Assembly cannot be loaded resolution.",
-				                               fileName,
-				                               new string[,] { { "FileName", fileName }, {"ExceptionMessage", e.Message}}));
-				return;
-			}
-			
-			Analyse (assembly);
-		}
-		
-		public void Analyse (Module module, Type type)
-		{
-			if (type.IsSpecialName || !(Char.IsLetter (type.Name[0]) || type.Name[0] == '_')) {
-				return;
-			}
-			
-			string ns = type.Namespace == null ? "" : type.Namespace;
-			
-			if (namespaces[ns] == null) {
-				namespaces[ns] = new ArrayList();
-			}
-			
-			((ArrayList) namespaces[ns]).Add (type);
-			
-			foreach (ITypeRule typeRule in typeRules) {
-				AddResolutions (typeRule.Check (type));
-			}
-			
-			foreach (Type nestedType in type.GetNestedTypes ()) {
-				Analyse (module, nestedType);
-			}
-			
-			BindingFlags bf = BindingFlags.DeclaredOnly |
-			                  BindingFlags.Public |
-			                  BindingFlags.NonPublic |
-			                  BindingFlags.Static |
-			                  BindingFlags.Instance;
-			
-			
-			foreach (MemberInfo memberInfo in type.GetMembers(bf)) {
-				foreach (IMemberRule memberRule in memberRules) {
-					AddResolutions (memberRule.Check (module, memberInfo));
-				}
-			}
-			
-			foreach (ConstructorInfo constructorInfo in type.GetConstructors(bf)) {
-				if (!constructorInfo.IsSpecialName) {
-					// search parameters
-					foreach (ParameterInfo parameter in constructorInfo.GetParameters ()) {
-						foreach (IParameterRule parameterRule in parameterRules) {
-							AddResolutions (parameterRule.Check (module, parameter));
-						}
-					}
-					
-					foreach (IConstructorRule constructorRule in constructorRules) {
-						AddResolutions (constructorRule.Check (constructorInfo));
-					}
-				}
-			}
-			
-			foreach (EventInfo eventInfo in type.GetEvents (bf)) {
-				if (!eventInfo.IsSpecialName) {
-					foreach (IEventRule eventRule in eventRules) {
-						AddResolutions (eventRule.Check (eventInfo));
-					}
-				}
-			}
-			
-			foreach (FieldInfo fieldInfo in type.GetFields (bf)) {
-				if (!fieldInfo.IsSpecialName) {
-					foreach (IFieldRule fieldRule in fieldRules) {
-						AddResolutions (fieldRule.Check (module, fieldInfo));
-					}
-				}
-			}
-			
-			// TODO: IMethodBaseRule
-			foreach (MethodInfo methodInfo in type.GetMethods(bf)) {
-				if (!methodInfo.IsSpecialName) {
-					//Console.WriteLine (methodInfo.Attributes);
-				
-					// search parameters
-					foreach (ParameterInfo parameter in methodInfo.GetParameters()) {
-						foreach (IParameterRule parameterRule in parameterRules) {
-							AddResolutions (parameterRule.Check (module, parameter));
-						}
-					}
-					
-					foreach (IMethodRule methodRule in methodRules) {
-						AddResolutions (methodRule.Check (module, methodInfo));
-					}
-				}
-			}
-			
-			foreach (PropertyInfo propertyInfo in type.GetProperties(bf)) {
-				if (!propertyInfo.IsSpecialName) {
-					foreach (IPropertyRule propertyRule in propertyRules) {
-						AddResolutions (propertyRule.Check (propertyInfo));
-					}
-				}
-			}
-		}
-		
-		public void Analyse (Assembly assembly)
-		{
-			namespaces = new Hashtable ();
-			resolutions = new ArrayList ();
-			
-			foreach (IAssemblyRule assemblyRule in assemblyRules) {
-				AddResolutions (assemblyRule.Check (assembly));
-			}
-			
-			foreach (Module module in assembly.GetModules ()) {
-				foreach (IModuleRule moduleRule in moduleRules) {
-					AddResolutions (moduleRule.Check (module));
-				}
-				foreach (Type type in module.GetTypes ()) {
-					Analyse (module, type);
-				}
-			}
-			
-			foreach (DictionaryEntry namespaceEntry in namespaces) {
-				foreach (INamespaceRule namespaceRule in namespaceRules) {
-					AddResolutions (namespaceRule.Check (namespaceEntry.Key.ToString (), (ArrayList) namespaceEntry.Value));
-				}
-			}
-		}
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Collections;
+using System.Reflection;
+using ICSharpCode.AssemblyAnalyser.Rules;
+
+namespace ICSharpCode.AssemblyAnalyser
+{
+	/// <summary>
+	/// Description of AssemblyAnalyser.	
+	/// </summary>
+	public class AssemblyAnalyser : System.MarshalByRefObject
+	{
+		ArrayList assemblyRules    = new ArrayList();
+		ArrayList moduleRules      = new ArrayList();
+		ArrayList typeRules        = new ArrayList();
+		ArrayList namespaceRules   = new ArrayList();
+		ArrayList memberRules      = new ArrayList();
+		ArrayList methodBaseRules  = new ArrayList();
+		ArrayList constructorRules = new ArrayList();
+		ArrayList eventRules       = new ArrayList();
+		ArrayList fieldRules       = new ArrayList();
+		ArrayList methodRules      = new ArrayList();
+		ArrayList parameterRules   = new ArrayList();
+		ArrayList propertyRules    = new ArrayList();
+		
+		ArrayList resolutions      = new ArrayList();
+		
+		Hashtable namespaces       = new Hashtable();
+		
+		public ArrayList Resolutions {
+			get {
+				return resolutions;
+			}
+		}
+		
+		public AssemblyAnalyser()
+		{
+			
+			Type[] types = typeof(AssemblyAnalyser).Assembly.GetTypes();
+			foreach (Type type in types) {
+				if (!type.IsAbstract && type.IsClass) {
+					if (type.GetInterface(typeof(IAssemblyRule).FullName) != null) {
+ 						assemblyRules.Add(type.Assembly.CreateInstance(type.FullName));
+					} else if (type.GetInterface(typeof(IConstructorRule).FullName) != null) {
+						constructorRules.Add(type.Assembly.CreateInstance(type.FullName));
+					} else if (type.GetInterface(typeof(IEventRule).FullName) != null) {
+						eventRules.Add(type.Assembly.CreateInstance(type.FullName));
+					} else if (type.GetInterface(typeof(IFieldRule).FullName) != null) {
+						fieldRules.Add(type.Assembly.CreateInstance(type.FullName));
+					} else if (type.GetInterface(typeof(IMemberRule).FullName) != null) {
+						memberRules.Add(type.Assembly.CreateInstance(type.FullName));
+					} else if (type.GetInterface(typeof(IMethodBaseRule).FullName) != null) {
+						methodBaseRules.Add(type.Assembly.CreateInstance(type.FullName));
+					} else if (type.GetInterface(typeof(IMethodRule).FullName) != null) {
+						methodRules.Add(type.Assembly.CreateInstance(type.FullName));
+					} else if (type.GetInterface(typeof(IModuleRule).FullName) != null) {
+						moduleRules.Add(type.Assembly.CreateInstance(type.FullName));
+					} else if (type.GetInterface(typeof(INamespaceRule).FullName) != null) {
+						namespaceRules.Add(type.Assembly.CreateInstance(type.FullName));
+					} else if (type.GetInterface(typeof(IParameterRule).FullName) != null) {
+						parameterRules.Add(type.Assembly.CreateInstance(type.FullName));
+					} else if (type.GetInterface(typeof(IPropertyRule).FullName) != null) {
+						propertyRules.Add(type.Assembly.CreateInstance(type.FullName));
+					} else if (type.GetInterface(typeof(ITypeRule).FullName) != null) {
+						typeRules.Add(type.Assembly.CreateInstance(type.FullName));
+					}
+				}
+			}
+		}
+		
+		void AddResolutions(Resolution resolution)
+		{
+			if (resolution != null) {
+				resolutions.Add(resolution);
+			}
+		}
+		
+		public void Analyse(string fileName)
+		{
+			Assembly assembly = null;
+			try {
+				assembly = Assembly.LoadFrom(fileName);
+			} catch (Exception e) {
+				// FIXME: I18N
+				resolutions.Add (new Resolution (new CustomRule ("Assembly cannot be loaded", "When an assembly cannot be loaded it indicates that the format is corrupt. This means that the .dll or .exe might not be in a managed .NET format or that the file was altered (in this case recompiling might help).", PriorityLevel.CriticalError, 100), String.Format ("Recompile {0}. Exception was: {1}", fileName, e.Message), fileName));
+				return;
+			}
+			Analyse(assembly);
+		}
+		
+		public void Analyse(Module module, Type type)
+		{
+			if (type.IsSpecialName || !(Char.IsLetter(type.Name[0]) || type.Name[0] == '_')) {
+				return;
+			}
+			string ns = type.Namespace == null ? "" : type.Namespace;
+			if (namespaces[ns] == null) {
+				namespaces[ns] = new ArrayList();
+			}
+			((ArrayList)namespaces[ns]).Add(type);
+			
+			foreach (ITypeRule typeRule in typeRules) {
+				AddResolutions(typeRule.Check(type));
+			}
+			
+			foreach (Type nestedType in type.GetNestedTypes()) {
+				Analyse(module, nestedType);
+			}
+			BindingFlags bf = BindingFlags.DeclaredOnly |
+			                  BindingFlags.Public |
+			                  BindingFlags.NonPublic |
+			                  BindingFlags.Static |
+			                  BindingFlags.Instance;
+			
+			
+			foreach (MemberInfo memberInfo in type.GetMembers(bf)) {
+				foreach (IMemberRule memberRule in memberRules) {
+					AddResolutions(memberRule.Check(module, memberInfo));
+				}
+			}
+			
+			foreach (ConstructorInfo constructorInfo in type.GetConstructors(bf)) {
+				if (!constructorInfo.IsSpecialName) {
+					// search parameters
+					foreach (ParameterInfo parameter in constructorInfo.GetParameters()) {
+						foreach (IParameterRule parameterRule in parameterRules) {
+							AddResolutions(parameterRule.Check(module, parameter));
+						}
+					}
+					
+					foreach (IConstructorRule constructorRule in constructorRules) {
+						AddResolutions(constructorRule.Check(constructorInfo));
+					}
+				}
+			}
+			
+			foreach (EventInfo eventInfo in type.GetEvents(bf)) {
+				if (!eventInfo.IsSpecialName) {
+					foreach (IEventRule eventRule in eventRules) {
+						AddResolutions(eventRule.Check(eventInfo));
+					}
+				}
+			}
+			
+			foreach (FieldInfo fieldInfo in type.GetFields(bf)) {
+				if (!fieldInfo.IsSpecialName) {
+					foreach (IFieldRule fieldRule in fieldRules) {
+						AddResolutions(fieldRule.Check(module, fieldInfo));
+					}
+				}
+			}
+			
+			// TODO: IMethodBaseRule
+			foreach (MethodInfo methodInfo in type.GetMethods(bf)) {
+				if (!methodInfo.IsSpecialName) {
+					//Console.WriteLine(methodInfo.Attributes);
+				
+					// search parameters
+					foreach (ParameterInfo parameter in methodInfo.GetParameters()) {
+						foreach (IParameterRule parameterRule in parameterRules) {
+							AddResolutions(parameterRule.Check(module, parameter));
+						}
+					}
+					
+					foreach (IMethodRule methodRule in methodRules) {
+						AddResolutions(methodRule.Check(module, methodInfo));
+					}
+				}
+			}
+			
+			foreach (PropertyInfo propertyInfo in type.GetProperties(bf)) {
+				if (!propertyInfo.IsSpecialName) {
+					foreach (IPropertyRule propertyRule in propertyRules) {
+						AddResolutions(propertyRule.Check(propertyInfo));
+					}
+				}
+			}
+		}
+		public void Analyse(Assembly assembly)
+		{
+			namespaces = new Hashtable();
+			resolutions = new ArrayList();
+			foreach (IAssemblyRule assemblyRule in assemblyRules) {
+				AddResolutions(assemblyRule.Check(assembly));
+			}
+			
+			foreach (Module module in assembly.GetModules()) {
+				foreach (IModuleRule moduleRule in moduleRules) {
+					AddResolutions(moduleRule.Check(module));
+				}
+				foreach (Type type in module.GetTypes()) {
+					Analyse(module, type);
+				}
+			}
+			
+			foreach (DictionaryEntry namespaceEntry in namespaces) {
+				foreach (INamespaceRule namespaceRule in namespaceRules) {
+					AddResolutions(namespaceRule.Check(namespaceEntry.Key.ToString(), (ArrayList)namespaceEntry.Value));
+				}
+			}
+		}
+	}
+}

Added: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Engine/ChangeLog
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Engine/ChangeLog	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Engine/ChangeLog	2004-10-26 03:51:03 UTC (rev 1997)
@@ -0,0 +1,5 @@
+2004-10-25  John Luke  <john.luke at gmail.com>
+
+	* AssemblyAnalzer.cs: comment Console.WriteLine
+	* Resolution.cs: remove Variables stuff for string substitution
+	the Rules can just pass in the final text.

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Engine/Resolution.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Engine/Resolution.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Engine/Resolution.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,56 +1,47 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using MonoDevelop.AssemblyAnalyser.Rules;
-
-namespace MonoDevelop.AssemblyAnalyser
-{	
-	public class Resolution : System.MarshalByRefObject
-	{
-		IRule  failedRule;
-		string text;
-		string item;
-		string[,] variables;
-		
-		public IRule FailedRule {
-			get {
-				return failedRule;
-			}
-		}
-		public string Text {
-			get {
-				return text;
-			}
-		}
-		public string Item {
-			get {
-				return item;
-			}
-		}
-		public string[,] Variables {
-			get {
-				return variables;
-			}
-		}
-		
-		public Resolution (IRule failedRule, string text, string item)
-		{
-			this.failedRule = failedRule;
-			this.text = text;
-			this.item = item;
-		}
-		
-		public Resolution (IRule failedRule, string text, string item, string[,] variables)
-		{
-			this.failedRule = failedRule;
-			this.text = text;
-			this.item = item;
-			this.variables = variables;
-		}
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using ICSharpCode.AssemblyAnalyser.Rules;
+
+namespace ICSharpCode.AssemblyAnalyser
+{
+	/// </summary>
+	/// <summary>
+	/// Description of Resolution.	
+	public class Resolution : System.MarshalByRefObject
+	{
+		IRule  failedRule;
+		string text;
+		string item;
+		
+		public IRule FailedRule {
+			get {
+				return failedRule;
+			}
+		}
+		public string Text {
+			get {
+				return text;
+			}
+		}
+		public string Item {
+			get {
+				return item;
+			}
+		}
+		
+		// instead of the SD substitution, Rules are expected to
+		// pass in the final text, hint use String.Format ()
+		public Resolution(IRule failedRule, string text, string item)
+		{
+			this.failedRule = failedRule;
+			this.text = text;
+			this.item = item;
+		}
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/AbstractReflectionRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/AbstractReflectionRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/AbstractReflectionRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,41 +1,41 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AbstractReflectionRule.	
-	/// </summary>
-	public abstract class AbstractReflectionRule : AbstractRule, MonoDevelop.AssemblyAnalyser.Rules.IReflectionRule
-	{
-		protected ProtectionLevels memberProtectionLevel     = ProtectionLevels.All;
-		protected ProtectionLevels nestedTypeProtectionLevel = ProtectionLevels.All;
-		protected ProtectionLevels typeProtectionLevel       = ProtectionLevels.All;
-		
-		#region MonoDevelop.AssemblyAnalyser.Rules.IReflectionRule interface implementation
-		public virtual ProtectionLevels MemberProtectionLevel {
-			get {
-				return memberProtectionLevel;
-			}
-		}
-		
-		public virtual ProtectionLevels NestedTypeProtectionLevel {
-			get {
-				return nestedTypeProtectionLevel;
-			}
-		}
-		
-		public virtual ProtectionLevels TypeProtectionLevel {
-			get {
-				return typeProtectionLevel;
-			}
-		}
-		#endregion
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of AbstractReflectionRule.	
+	/// </summary>
+	public abstract class AbstractReflectionRule : AbstractRule, IReflectionRule
+	{
+		protected ProtectionLevels memberProtectionLevel     = ProtectionLevels.All;
+		protected ProtectionLevels nestedTypeProtectionLevel = ProtectionLevels.All;
+		protected ProtectionLevels typeProtectionLevel       = ProtectionLevels.All;
+		
+		#region ICSharpCode.AssemblyAnalyser.Rules.IReflectionRule interface implementation
+		public virtual ProtectionLevels MemberProtectionLevel {
+			get {
+				return memberProtectionLevel;
+			}
+		}
+		
+		public virtual ProtectionLevels NestedTypeProtectionLevel {
+			get {
+				return nestedTypeProtectionLevel;
+			}
+		}
+		
+		public virtual ProtectionLevels TypeProtectionLevel {
+			get {
+				return typeProtectionLevel;
+			}
+		}
+		#endregion
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/AbstractRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/AbstractRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/AbstractRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,82 +1,82 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AbstractRule.	
-	/// </summary>
-	public abstract class AbstractRule : System.MarshalByRefObject, IRule
-	{
-		protected PriorityLevel priorityLevel = PriorityLevel.Error;
-		protected int certainty = 99;
-		
-		#region MonoDevelop.AssemblyAnalyser.Rules.IRule interface implementation
-		public PriorityLevel PriorityLevel {
-			get {
-				return priorityLevel;
-			}
-		}
-		
-		public int Certainty {
-			get {
-				return certainty;
-			}
-		}
-		
-		public abstract string Description {
-			get;
-		}
-		
-		public abstract string Details {
-			get;
-		}
-		
-		public virtual void EndAnalysis()
-		{
-		}
-		
-		public virtual void StartAnalysis()
-		{
-		}
-		#endregion
-	}
-	
-	public class CustomRule : AbstractRule
-	{
-		string description;
-		string details;
-		
-		public override string Description {
-			get {
-				return description;
-			}
-		}
-		
-		public override string Details {
-			get {
-				return details;
-			}
-		}
-		
-		public CustomRule(string description, string details)
-		{
-			this.description = description;
-			this.details = details;
-		}
-		public CustomRule(string description, string details, PriorityLevel priorityLevel, int certainty)
-		{
-			this.description = description;
-			this.details = details;
-			this.priorityLevel = priorityLevel;
-			this.certainty = certainty;
-		}
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of AbstractRule.	
+	/// </summary>
+	public abstract class AbstractRule : System.MarshalByRefObject, IRule
+	{
+		protected PriorityLevel priorityLevel = PriorityLevel.Error;
+		protected int certainty = 99;
+		
+		#region ICSharpCode.AssemblyAnalyser.Rules.IRule interface implementation
+		public PriorityLevel PriorityLevel {
+			get {
+				return priorityLevel;
+			}
+		}
+		
+		public int Certainty {
+			get {
+				return certainty;
+			}
+		}
+		
+		public abstract string Description {
+			get;
+		}
+		
+		public abstract string Details {
+			get;
+		}
+		
+		public virtual void EndAnalysis()
+		{
+		}
+		
+		public virtual void StartAnalysis()
+		{
+		}
+		#endregion
+	}
+	
+	public class CustomRule : AbstractRule
+	{
+		string description;
+		string details;
+		
+		public override string Description {
+			get {
+				return description;
+			}
+		}
+		
+		public override string Details {
+			get {
+				return details;
+			}
+		}
+		
+		public CustomRule(string description, string details)
+		{
+			this.description = description;
+			this.details = details;
+		}
+		public CustomRule(string description, string details, PriorityLevel priorityLevel, int certainty)
+		{
+			this.description = description;
+			this.details = details;
+			this.priorityLevel = priorityLevel;
+			this.certainty = certainty;
+		}
+	}
+}

Added: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/ChangeLog
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/ChangeLog	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/ChangeLog	2004-10-26 03:51:03 UTC (rev 1997)
@@ -0,0 +1,5 @@
+2004-10-25  John Luke  <john.luke at gmail.com>
+
+	* All Rules: add the Description, Details, and Resoltion text into the rule
+	I18N will be done in another way, don't use contractions in text,
+	fix some typos spelling

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AbstractTypesPublicConstructorsRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AbstractTypesPublicConstructorsRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AbstractTypesPublicConstructorsRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,102 +1,103 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AssemblyStrongName.	
-	/// </summary>
-	public class AbstractTypesPublicConstructorsRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.AbstractTypesPublicConstructors.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.AbstractTypesPublicConstructors.Details}";
-			}
-		}
-		
-		public AbstractTypesPublicConstructorsRule()
-		{
-			priorityLevel = PriorityLevel.CriticalWarning;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (type.IsAbstract) {
-				foreach (ConstructorInfo info in type.GetConstructors()) {
-					if (info.IsPublic) {
- 						return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.AbstractTypesPublicConstructors.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-					}
-				}
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class AbstractTypesPublicConstructorsRuleTest
-	{
-		abstract class AbstractClassPublic1 {
-			public AbstractClassPublic1()
-			{
-			}
-		}
-		abstract class AbstractClassPublic2 {
-			protected AbstractClassPublic2()
-			{
-			}
-			public AbstractClassPublic2(int x, int y)
-			{
-			}
-		}
-		[Test]
-		public void TestAbstractTypesWithPublicConstructor()
-		{
-			AbstractTypesPublicConstructorsRule rule = new AbstractTypesPublicConstructorsRule();
-			Assertion.AssertNotNull(rule.Check(typeof(AbstractClassPublic1)));
-			Assertion.AssertNotNull(rule.Check(typeof(AbstractClassPublic2)));
-		}
-		
-		abstract class AbstractClass1 {
-			protected AbstractClass1()
-			{
-			}
-		}
-		abstract class AbstractClass2 {
-			protected AbstractClass2(int x, int y)
-			{
-			}
-		}
-		
-		[Test]
-		public void TestAbstractTypesWithoutPublicConstructor()
-		{
-			AbstractTypesPublicConstructorsRule rule = new AbstractTypesPublicConstructorsRule();
-			Assertion.AssertNull(rule.Check(typeof(AbstractClass1)));
-			Assertion.AssertNull(rule.Check(typeof(AbstractClass2)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of AssemblyStrongName.	
+	/// </summary>
+	public class AbstractTypesPublicConstructorsRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Abstract types should not have public constructors";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "You cannot create abstract types therefore public constructors do not make any sense.";
+			}
+		}
+		
+		public AbstractTypesPublicConstructorsRule()
+		{
+			priorityLevel = PriorityLevel.CriticalWarning;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (type.IsAbstract) {
+				foreach (ConstructorInfo info in type.GetConstructors()) {
+					if (info.IsPublic) {
+						// FIXME: I18N
+ 						return new Resolution (this, String.Format ("Change all constructors access levels in <code>{0}</code> to <code>protected</code>.", type.FullName), type.FullName);
+					}
+				}
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class AbstractTypesPublicConstructorsRuleTest
+	{
+		abstract class AbstractClassPublic1 {
+			public AbstractClassPublic1()
+			{
+			}
+		}
+		abstract class AbstractClassPublic2 {
+			protected AbstractClassPublic2()
+			{
+			}
+			public AbstractClassPublic2(int x, int y)
+			{
+			}
+		}
+		[Test]
+		public void TestAbstractTypesWithPublicConstructor()
+		{
+			AbstractTypesPublicConstructorsRule rule = new AbstractTypesPublicConstructorsRule();
+			Assertion.AssertNotNull(rule.Check(typeof(AbstractClassPublic1)));
+			Assertion.AssertNotNull(rule.Check(typeof(AbstractClassPublic2)));
+		}
+		
+		abstract class AbstractClass1 {
+			protected AbstractClass1()
+			{
+			}
+		}
+		abstract class AbstractClass2 {
+			protected AbstractClass2(int x, int y)
+			{
+			}
+		}
+		
+		[Test]
+		public void TestAbstractTypesWithoutPublicConstructor()
+		{
+			AbstractTypesPublicConstructorsRule rule = new AbstractTypesPublicConstructorsRule();
+			Assertion.AssertNull(rule.Check(typeof(AbstractClass1)));
+			Assertion.AssertNull(rule.Check(typeof(AbstractClass2)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AssemblyClsCompliantRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AssemblyClsCompliantRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AssemblyClsCompliantRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,51 +1,55 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.IO;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AssemblyStrongName.	
-	/// </summary>
-	public class AssemblyClsCompliantRule : AbstractReflectionRule, IAssemblyRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.AssemblyClsCompliantRule.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.AssemblyClsCompliantRule.Details}";
-			}
-		}
-		
-		public AssemblyClsCompliantRule()
-		{
-			certainty = 99;
-		}
-		
-		public Resolution Check(Assembly assembly)
-		{
-			object[] attributes = assembly.GetCustomAttributes(typeof(System.CLSCompliantAttribute), true);
-			if (attributes == null || attributes.Length == 0) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.AssemblyClsCompliantRule.Resolution1}", assembly.Location, new string[,] { {"AssemblyName", Path.GetFileName(assembly.Location)} });
-			} else {
-				foreach (CLSCompliantAttribute attr in attributes) {
-					if (!attr.IsCompliant) {
-						return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.AssemblyClsCompliantRule.Resolution2}", assembly.Location, new string[,] { {"AssemblyName", Path.GetFileName(assembly.Location)} });
-					}
-				}
-			}
-			return null;
-		}
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.IO;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of AssemblyStrongName.	
+	/// </summary>
+	public class AssemblyClsCompliantRule : AbstractReflectionRule, IAssemblyRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Assemblies should be marked CLSCompliant";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Assemblies should be marked CLS (Common Language Specification) compliant using the <code><a href='help://types/System.CLSCompliantAttribute'>CLSCompliantAttribute</a></code> assemblies without this attribute are not CLS compliant. It is possible to have non-CLS compliant parts in a CLS compliant assembly. In this case all non-compliant members must have the CLSCompliant attribute set to <code>false</code>. You should supply for each non-CLS compliant member a CLS compliant alternative.";
+			}
+		}
+		
+		public AssemblyClsCompliantRule()
+		{
+			certainty = 99;
+		}
+		
+		public Resolution Check(Assembly assembly)
+		{
+			object[] attributes = assembly.GetCustomAttributes(typeof(System.CLSCompliantAttribute), true);
+			if (attributes == null || attributes.Length == 0) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Declare a <code><a href='help://types/System.CLSCompliantAttribute'>CLSCompliantAttribute</a></code> in the assembly <code>{0}</code> and its value should be <code>true</code>.", Path.GetFileName (assembly.Location)), assembly.Location);
+			} else {
+				foreach (CLSCompliantAttribute attr in attributes) {
+					if (!attr.IsCompliant) {
+						// FIXME: I18N
+						return new Resolution (this, String.Format ("Set the <code><a href='help://types/System.CLSCompliantAttribute'>CLSCompliantAttribute</a></code> in the assembly <code>{0}</code> to <code>true<code>.", Path.GetFileName (assembly.Location)), assembly.Location);
+					}
+				}
+			}
+			return null;
+		}
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AssemblyStrongNameRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AssemblyStrongNameRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AssemblyStrongNameRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,45 +1,48 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.IO;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AssemblyStrongName.	
-	/// </summary>
-	public class AssemblyStrongNameRule : AbstractReflectionRule, IAssemblyRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.AssemblyStrongName.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.AssemblyStrongName.Details}";
-			}
-		}
-		
-		public AssemblyStrongNameRule()
-		{
-			certainty = 95;
-		}
-		
-		public Resolution Check(Assembly assembly)
-		{
-			byte[] publicKeyToken = assembly.GetName().GetPublicKeyToken();
-			if (publicKeyToken == null || publicKeyToken.Length == 0) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.AssemblyStrongName.Resolution}", assembly.Location, new string[,] { {"AssemblyName", Path.GetFileName(assembly.Location)} });
-			}
-			return null;
-		}
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.IO;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of AssemblyStrongName.	
+	/// </summary>
+	public class AssemblyStrongNameRule : AbstractReflectionRule, IAssemblyRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Assemblies should be strong named";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Assemblies with a strong name can be placed in the GAC. Furthermore only strong named assemblies can be referenced by a strong named assembly (Your assembly cannot be used by a strong named assembly if you do not sign it).";
+			}
+		}
+		
+		public AssemblyStrongNameRule()
+		{
+			certainty = 95;
+		}
+		
+		public Resolution Check(Assembly assembly)
+		{
+			byte[] publicKeyToken = assembly.GetName().GetPublicKeyToken();
+			// FIXME: I18N
+			if (publicKeyToken == null || publicKeyToken.Length == 0) {
+				return new Resolution (this, String.Format ("Sign the assembly {0} with a strong name.", Path.GetFileName (assembly.Location)), assembly.Location);
+			}
+			return null;
+		}
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AssemblyVersionNumberRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AssemblyVersionNumberRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AssemblyVersionNumberRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,45 +1,48 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.IO;
-using System.Reflection;
-using MonoDevelop.AssemblyAnalyser.Rules;
-
-namespace MonoDevelop.AssemblyAnalyser
-{
-	/// <summary>
-	/// Description of AssemblyVersionNumber.	
-	/// </summary>
-	public class AssemblyVersionNumberRule : AbstractReflectionRule, IAssemblyRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.AssemblyVersionNumber.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.AssemblyVersionNumber.Details}";
-			}
-		}
-		
-		public AssemblyVersionNumberRule()
-		{
-			certainty = 95;
-		}
-		
-		public Resolution Check(Assembly assembly)
-		{
-			if (assembly.GetName().Version == new Version(0, 0, 0, 0)) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.AssemblyVersionNumber.Resolution}", assembly.Location, new string[,] { {"AssemblyName", Path.GetFileName(assembly.Location)} });
-			}
-			return null;
-		}
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.IO;
+using System.Reflection;
+using ICSharpCode.AssemblyAnalyser.Rules;
+
+namespace ICSharpCode.AssemblyAnalyser
+{
+	/// <summary>
+	/// Description of AssemblyVersionNumberRule.
+	/// </summary>
+	public class AssemblyVersionNumberRule : AbstractReflectionRule, IAssemblyRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Assemblies should have version numbers";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "The Version number is part of the assembly identity. Use the <code><a href='help://types/System.Reflection.AssemblyVersionAttribute'>AssemblyVersion</a></code> attribute to assign a version number.";
+			}
+		}
+		
+		public AssemblyVersionNumberRule()
+		{
+			certainty = 95;
+		}
+		
+		public Resolution Check(Assembly assembly)
+		{
+			if (assembly.GetName().Version == new Version(0, 0, 0, 0)) {
+				// FIXME: I18N
+				return new Resolution(this, String.Format ("Add an <code><a href='help://types/System.Reflection.AssemblyVersionAttribute'>AssemblyVersion</a></code> attribute to the assembly {0}.", Path.GetFileName (assembly.Location)), assembly.Location);
+			}
+			return null;
+		}
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AvoidNamespacesWithFewMembers.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AvoidNamespacesWithFewMembers.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/AvoidNamespacesWithFewMembers.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,77 +1,78 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Collections;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AvoidNamespacesWithFewMembers.	
-	/// </summary>
-	public class AvoidNamespacesWithFewMembers : AbstractReflectionRule, INamespaceRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.AvoidNamespacesWithFewMembers.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.AvoidNamespacesWithFewMembers.Details}";
-			}
-		}
-		
-		public AvoidNamespacesWithFewMembers()
-		{
-			base.certainty     = 50;
-			base.priorityLevel = PriorityLevel.Warning;
-		}
-		
-		public Resolution Check(string namespaceName, ICollection types)
-		{
-			if (namespaceName != null && namespaceName.Length > 0 && types.Count < 5) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.AvoidNamespacesWithFewMembers.Resolution}", namespaceName, new string[,]{{"NamespaceName", namespaceName}});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class AvoidNamespacesWithFewMembersTest
-	{
-		[Test]
-		public void TestCorrectNamespaces()
-		{
-			AvoidNamespacesWithFewMembers rule = new AvoidNamespacesWithFewMembers();
-			Assertion.AssertNull(rule.Check("MyNamespace", new Type[] {typeof(System.Object),
-			                                                             typeof(System.Object),
-			                                                             typeof(System.Object),
-			                                                             typeof(System.Object),
-			                                                             typeof(System.Object),
-			                                                             typeof(System.Object)}));
-		}
-		
-		[Test]
-		public void TestIncorrectAttribute()
-		{
-			AvoidNamespacesWithFewMembers rule = new AvoidNamespacesWithFewMembers();
-			Assertion.AssertNotNull(rule.Check("a", new Type[] {}));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Collections;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of AvoidNamespacesWithFewMembers.	
+	/// </summary>
+	public class AvoidNamespacesWithFewMembers : AbstractReflectionRule, INamespaceRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Avoid having namespaces with few type members";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return " A namespace should generally contain a minimum of five types.";
+			}
+		}
+		
+		public AvoidNamespacesWithFewMembers()
+		{
+			base.certainty     = 50;
+			base.priorityLevel = PriorityLevel.Warning;
+		}
+		
+		public Resolution Check(string namespaceName, ICollection types)
+		{
+			if (namespaceName != null && namespaceName.Length > 0 && types.Count < 5) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Consider merging the types inside namespace <code>{0}</code> with another namespace.", namespaceName), namespaceName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class AvoidNamespacesWithFewMembersTest
+	{
+		[Test]
+		public void TestCorrectNamespaces()
+		{
+			AvoidNamespacesWithFewMembers rule = new AvoidNamespacesWithFewMembers();
+			Assertion.AssertNull(rule.Check("MyNamespace", new Type[] {typeof(System.Object),
+			                                                             typeof(System.Object),
+			                                                             typeof(System.Object),
+			                                                             typeof(System.Object),
+			                                                             typeof(System.Object),
+			                                                             typeof(System.Object)}));
+		}
+		
+		[Test]
+		public void TestIncorrectAttribute()
+		{
+			AvoidNamespacesWithFewMembers rule = new AvoidNamespacesWithFewMembers();
+			Assertion.AssertNotNull(rule.Check("a", new Type[] {}));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventFirstParameterIsObjectRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventFirstParameterIsObjectRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventFirstParameterIsObjectRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,92 +1,93 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of EventFirstParameterIsObject.	
-	/// </summary>
-	public class EventFirstParameterIsObjectRule : AbstractReflectionRule, IEventRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventFirstParameterIsObject.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventFirstParameterIsObject.Details}";
-			}
-		}
-		
-		public EventFirstParameterIsObjectRule()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(EventInfo evnt)
-		{
-			MethodInfo invokeMethod = evnt.EventHandlerType.GetMethod("Invoke");
-			ParameterInfo[] parameters = invokeMethod.GetParameters();
-
-			if (parameters.Length > 0 && parameters[0].ParameterType != typeof(System.Object)) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.EventFirstParameterIsObject.Resolution}", evnt.EventHandlerType.FullName, new string[,] { { "EventType", evnt.EventHandlerType.FullName }, { "OldParameterType", parameters[0].ParameterType.FullName }});
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class EventFirstParameterIsObjectRuleTest
-	{
-		public delegate void CorrectEventHandler(object sender, EventArgs e);
-		public event CorrectEventHandler CorrectEvent;
-		protected virtual void OnCorrectEvent(EventArgs e)
-		{
-			if (CorrectEvent != null) {
-				CorrectEvent(this, e);
-			}
-		}
-		[Test]
-		public void TestCorrectEventHandler()
-		{
-			EventFirstParameterIsObjectRule rule = new EventFirstParameterIsObjectRule();
-			Assertion.AssertNull(rule.Check(this.GetType().GetEvent("CorrectEvent")));
-		}
-		
-		public delegate void IncorrectEventHandler(int sender, EventArgs e);
-		public event IncorrectEventHandler IncorrectEvent;
-		protected virtual void OnIncorrectEvent(EventArgs e)
-		{
-			if (IncorrectEvent != null) {
-				IncorrectEvent(6, e);
-			}
-		}
-		
-		[Test]
-		public void TestIncorrectEventHandler()
-		{
-			EventFirstParameterIsObjectRule rule = new EventFirstParameterIsObjectRule();
-			Assertion.AssertNotNull(rule.Check(this.GetType().GetEvent("IncorrectEvent")));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of EventFirstParameterIsObject.	
+	/// </summary>
+	public class EventFirstParameterIsObjectRule : AbstractReflectionRule, IEventRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "The first parameter of an event is from type System.Object";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "As a convention in .NET events have two parameters a sender and an event data object. The sender must always be from the type <code><a href='help://types/System.Object'>object</a></code> and never a specialized type.<BR>For example: <code>void MouseEventHandler(object sender, MouseEventArgs e);</code>";
+			}
+		}
+		
+		public EventFirstParameterIsObjectRule()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(EventInfo evnt)
+		{
+			MethodInfo invokeMethod = evnt.EventHandlerType.GetMethod("Invoke");
+			ParameterInfo[] parameters = invokeMethod.GetParameters();
+
+			if (parameters.Length > 0 && parameters[0].ParameterType != typeof(System.Object)) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the first parameter of <code>{0}</code> from the type <code>{1}</code> to the type <code><a href='help://types/System.Object'>object</a></code>.", evnt.EventHandlerType.FullName, parameters[0].ParameterType.FullName), evnt.EventHandlerType.FullName);
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class EventFirstParameterIsObjectRuleTest
+	{
+		public delegate void CorrectEventHandler(object sender, EventArgs e);
+		public event CorrectEventHandler CorrectEvent;
+		protected virtual void OnCorrectEvent(EventArgs e)
+		{
+			if (CorrectEvent != null) {
+				CorrectEvent(this, e);
+			}
+		}
+		[Test]
+		public void TestCorrectEventHandler()
+		{
+			EventFirstParameterIsObjectRule rule = new EventFirstParameterIsObjectRule();
+			Assertion.AssertNull(rule.Check(this.GetType().GetEvent("CorrectEvent")));
+		}
+		
+		public delegate void IncorrectEventHandler(int sender, EventArgs e);
+		public event IncorrectEventHandler IncorrectEvent;
+		protected virtual void OnIncorrectEvent(EventArgs e)
+		{
+			if (IncorrectEvent != null) {
+				IncorrectEvent(6, e);
+			}
+		}
+		
+		[Test]
+		public void TestIncorrectEventHandler()
+		{
+			EventFirstParameterIsObjectRule rule = new EventFirstParameterIsObjectRule();
+			Assertion.AssertNotNull(rule.Check(this.GetType().GetEvent("IncorrectEvent")));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventHandlersReturnVoidRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventHandlersReturnVoidRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventHandlersReturnVoidRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,90 +1,91 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of EventFirstParameterNameIsSender.	
-	/// </summary>
-	public class EventHandlersReturnVoidRule : AbstractReflectionRule, IEventRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventHandlersReturnVoid.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventHandlersReturnVoid.Details}";
-			}
-		}
-		
-		public EventHandlersReturnVoidRule()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(EventInfo evnt)
-		{
-			MethodInfo invokeMethod = evnt.EventHandlerType.GetMethod("Invoke");
-			if (invokeMethod.ReturnType != typeof(void)) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.EventHandlersReturnVoid.Resolution}", evnt.EventHandlerType.FullName, new string[,] { { "EventType", evnt.EventHandlerType.FullName }, {"OldReturnType", invokeMethod.ReturnType.FullName}});
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class EventHandlersReturnVoidRuleTest
-	{
-		public delegate void CorrectEventHandler(object sender, EventArgs e);
-		public event CorrectEventHandler CorrectEvent;
-		protected virtual void OnCorrectEvent(EventArgs e)
-		{
-			if (CorrectEvent != null) {
-				CorrectEvent(this, e);
-			}
-		}
-		[Test]
-		public void TestCorrectEventHandler()
-		{
-			EventHandlersReturnVoidRule rule = new EventHandlersReturnVoidRule();
-			Assertion.AssertNull(rule.Check(this.GetType().GetEvent("CorrectEvent")));
-		}
-		
-		public delegate int IncorrectEventHandler(object sender, EventArgs e);
-		public event IncorrectEventHandler IncorrectEvent;
-		protected virtual void OnIncorrectEvent(EventArgs e)
-		{
-			if (IncorrectEvent != null) {
-				IncorrectEvent(this, e);
-			}
-		}
-		
-		[Test]
-		public void TestIncorrectEventHandler()
-		{
-			EventHandlersReturnVoidRule rule = new EventHandlersReturnVoidRule();
-			Assertion.AssertNotNull(rule.Check(this.GetType().GetEvent("IncorrectEvent")));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of EventFirstParameterNameIsSender.	
+	/// </summary>
+	public class EventHandlersReturnVoidRule : AbstractReflectionRule, IEventRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Event handlers return void";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Event handlers return <code>void</code> because they can send event to multiple target methods. Any return value would get lost.";
+			}
+		}
+		
+		public EventHandlersReturnVoidRule()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(EventInfo evnt)
+		{
+			MethodInfo invokeMethod = evnt.EventHandlerType.GetMethod("Invoke");
+			if (invokeMethod.ReturnType != typeof(void)) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change <code>{0}</code> so that it returns <code>void</code> instead of <code>{1}</code>.", evnt.EventHandlerType.FullName, invokeMethod.ReturnType.FullName), evnt.EventHandlerType.FullName);
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class EventHandlersReturnVoidRuleTest
+	{
+		public delegate void CorrectEventHandler(object sender, EventArgs e);
+		public event CorrectEventHandler CorrectEvent;
+		protected virtual void OnCorrectEvent(EventArgs e)
+		{
+			if (CorrectEvent != null) {
+				CorrectEvent(this, e);
+			}
+		}
+		[Test]
+		public void TestCorrectEventHandler()
+		{
+			EventHandlersReturnVoidRule rule = new EventHandlersReturnVoidRule();
+			Assertion.AssertNull(rule.Check(this.GetType().GetEvent("CorrectEvent")));
+		}
+		
+		public delegate int IncorrectEventHandler(object sender, EventArgs e);
+		public event IncorrectEventHandler IncorrectEvent;
+		protected virtual void OnIncorrectEvent(EventArgs e)
+		{
+			if (IncorrectEvent != null) {
+				IncorrectEvent(this, e);
+			}
+		}
+		
+		[Test]
+		public void TestIncorrectEventHandler()
+		{
+			EventHandlersReturnVoidRule rule = new EventHandlersReturnVoidRule();
+			Assertion.AssertNotNull(rule.Check(this.GetType().GetEvent("IncorrectEvent")));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventSecondParameterIsEventArgsRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventSecondParameterIsEventArgsRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventSecondParameterIsEventArgsRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,92 +1,93 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of EventFirstParameterIsObject.	
-	/// </summary>
-	public class EventSecondParameterIsEventArgsRule : AbstractReflectionRule, IEventRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventSecondParameterIsEventArgs.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventSecondParameterIsEventArgs.Details}";
-			}
-		}
-		
-		public EventSecondParameterIsEventArgsRule()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(EventInfo evnt)
-		{
-			MethodInfo invokeMethod = evnt.EventHandlerType.GetMethod("Invoke");
-			ParameterInfo[] parameters = invokeMethod.GetParameters();
-
-			if (parameters.Length > 1 && !typeof(System.EventArgs).IsAssignableFrom(parameters[1].ParameterType)) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.EventSecondParameterIsEventArgs.Resolution}", evnt.EventHandlerType.FullName, new string[,] { { "EventType", evnt.EventHandlerType.FullName }, { "OldParameterType", parameters[1].ParameterType.FullName }});
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class EventSecondParameterIsEventArgsRuleTest
-	{
-		public delegate void CorrectEventHandler(object sender, EventArgs e);
-		public event CorrectEventHandler CorrectEvent;
-		protected virtual void OnCorrectEvent(EventArgs e)
-		{
-			if (CorrectEvent != null) {
-				CorrectEvent(this, e);
-			}
-		}
-		[Test]
-		public void TestCorrectEventHandler()
-		{
-			EventSecondParameterIsEventArgsRule rule = new EventSecondParameterIsEventArgsRule();
-			Assertion.AssertNull(rule.Check(this.GetType().GetEvent("CorrectEvent")));
-		}
-		
-		public delegate void IncorrectEventHandler(object sender, int e);
-		public event IncorrectEventHandler IncorrectEvent;
-		protected virtual void OnIncorrectEvent(int e)
-		{
-			if (IncorrectEvent != null) {
-				IncorrectEvent(this, e);
-			}
-		}
-		
-		[Test]
-		public void TestIncorrectEventHandler()
-		{
-			EventSecondParameterIsEventArgsRule rule = new EventSecondParameterIsEventArgsRule();
-			Assertion.AssertNotNull(rule.Check(this.GetType().GetEvent("IncorrectEvent")));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of EventSecondParameterIsEventArgsRule.	
+	/// </summary>
+	public class EventSecondParameterIsEventArgsRule : AbstractReflectionRule, IEventRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Second parameter type in events is a System.EventArgs type";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "As a convention in .NET events have two parameters a sender and an event data object. The event data must always extend from the type <code><a href='help://types/System.EventArgs'>System.EventArgs</a></code> .<BR>For example: <code>void MouseEventHandler(object sender, MouseEventArgs e);</code> where <code>MouseEventArgs</code> extends <code><a href='help://types/System.EventArgs'>System.EventArgs</a></code>.";
+			}
+		}
+		
+		public EventSecondParameterIsEventArgsRule()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(EventInfo evnt)
+		{
+			MethodInfo invokeMethod = evnt.EventHandlerType.GetMethod("Invoke");
+			ParameterInfo[] parameters = invokeMethod.GetParameters();
+
+			if (parameters.Length > 1 && !typeof(System.EventArgs).IsAssignableFrom(parameters[1].ParameterType)) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the second parameter of the event <code>{0}</code> from <code>{1}</code> so that it is from the type <code><a href='help://types/System.EventArgs'>EventArgs</a></code> or any more specialized type.", evnt.EventHandlerType.FullName, parameters[1].ParameterType.FullName), evnt.EventHandlerType.FullName);
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class EventSecondParameterIsEventArgsRuleTest
+	{
+		public delegate void CorrectEventHandler(object sender, EventArgs e);
+		public event CorrectEventHandler CorrectEvent;
+		protected virtual void OnCorrectEvent(EventArgs e)
+		{
+			if (CorrectEvent != null) {
+				CorrectEvent(this, e);
+			}
+		}
+		[Test]
+		public void TestCorrectEventHandler()
+		{
+			EventSecondParameterIsEventArgsRule rule = new EventSecondParameterIsEventArgsRule();
+			Assertion.AssertNull(rule.Check(this.GetType().GetEvent("CorrectEvent")));
+		}
+		
+		public delegate void IncorrectEventHandler(object sender, int e);
+		public event IncorrectEventHandler IncorrectEvent;
+		protected virtual void OnIncorrectEvent(int e)
+		{
+			if (IncorrectEvent != null) {
+				IncorrectEvent(this, e);
+			}
+		}
+		
+		[Test]
+		public void TestIncorrectEventHandler()
+		{
+			EventSecondParameterIsEventArgsRule rule = new EventSecondParameterIsEventArgsRule();
+			Assertion.AssertNotNull(rule.Check(this.GetType().GetEvent("IncorrectEvent")));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventsHaveTwoParametersRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventsHaveTwoParametersRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/EventsHaveTwoParametersRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,92 +1,93 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of EventsHaveTwoParameters.	
-	/// </summary>
-	public class EventsHaveTwoParametersRule : AbstractReflectionRule, IEventRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventsHaveTwoParameters.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventsHaveTwoParameters.Details}";
-			}
-		}
-		
-		public EventsHaveTwoParametersRule()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(EventInfo evnt)
-		{
-			MethodInfo invokeMethod = evnt.EventHandlerType.GetMethod("Invoke");
-			ParameterInfo[] parameters = invokeMethod.GetParameters();
-
-			if (parameters.Length != 2) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.EventsHaveTwoParameters.Resolution}", evnt.EventHandlerType.FullName, new string[,] { { "EventType", evnt.EventHandlerType.FullName }});
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class EventsHaveTwoParametersTest
-	{
-		public delegate void CorrectEventHandler(object sender, EventArgs e);
-		public event CorrectEventHandler CorrectEvent;
-		protected virtual void OnCorrectEvent(EventArgs e)
-		{
-			if (CorrectEvent != null) {
-				CorrectEvent(this, e);
-			}
-		}
-		[Test]
-		public void TestCorrectEventHandler()
-		{
-			EventsHaveTwoParametersRule rule = new EventsHaveTwoParametersRule();
-			Assertion.AssertNull(rule.Check(this.GetType().GetEvent("CorrectEvent")));
-		}
-		
-		public delegate void IncorrectEventHandler(object sender, EventArgs e, int i);
-		public event IncorrectEventHandler IncorrectEvent;
-		protected virtual void OnIncorrectEvent(EventArgs e)
-		{
-			if (IncorrectEvent != null) {
-				IncorrectEvent(this, e, 5);
-			}
-		}
-		
-		[Test]
-		public void TestIncorrectEventHandler()
-		{
-			EventsHaveTwoParametersRule rule = new EventsHaveTwoParametersRule();
-			Assertion.AssertNotNull(rule.Check(this.GetType().GetEvent("IncorrectEvent")));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of EventsHaveTwoParameters.	
+	/// </summary>
+	public class EventsHaveTwoParametersRule : AbstractReflectionRule, IEventRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Events have two parameters";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "As a convention in .NET events have two parameters a sender and an event data object. <BR>For example: <code>void MouseEventHandler(object sender, MouseEventArgs e);</code>";
+			}
+		}
+		
+		public EventsHaveTwoParametersRule()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(EventInfo evnt)
+		{
+			MethodInfo invokeMethod = evnt.EventHandlerType.GetMethod("Invoke");
+			ParameterInfo[] parameters = invokeMethod.GetParameters();
+
+			if (parameters.Length != 2) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change <code>{0}</code> so that it has only two parameters. A sender and an event data object.", evnt.EventHandlerType.FullName), evnt.EventHandlerType.FullName);
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class EventsHaveTwoParametersTest
+	{
+		public delegate void CorrectEventHandler(object sender, EventArgs e);
+		public event CorrectEventHandler CorrectEvent;
+		protected virtual void OnCorrectEvent(EventArgs e)
+		{
+			if (CorrectEvent != null) {
+				CorrectEvent(this, e);
+			}
+		}
+		[Test]
+		public void TestCorrectEventHandler()
+		{
+			EventsHaveTwoParametersRule rule = new EventsHaveTwoParametersRule();
+			Assertion.AssertNull(rule.Check(this.GetType().GetEvent("CorrectEvent")));
+		}
+		
+		public delegate void IncorrectEventHandler(object sender, EventArgs e, int i);
+		public event IncorrectEventHandler IncorrectEvent;
+		protected virtual void OnIncorrectEvent(EventArgs e)
+		{
+			if (IncorrectEvent != null) {
+				IncorrectEvent(this, e, 5);
+			}
+		}
+		
+		[Test]
+		public void TestIncorrectEventHandler()
+		{
+			EventsHaveTwoParametersRule rule = new EventsHaveTwoParametersRule();
+			Assertion.AssertNotNull(rule.Check(this.GetType().GetEvent("IncorrectEvent")));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/InterfaceNotEmptyRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/InterfaceNotEmptyRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/InterfaceNotEmptyRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,86 +1,87 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of InterfaceNotEmpty.	
-	/// </summary>
-	public class InterfaceNotEmptyRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.InterfaceNotEmpty.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.InterfaceNotEmpty.Details}";
-			}
-		}
-		public Resolution Check(Type type)
-		{
-			if (type.IsInterface && type.GetMembers().Length == 0) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.InterfaceNotEmpty.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class InterfaceNotEmptyRuleTests
-	{
-		interface NonEmptyInterface1
-		{
-			void A();
-		}
-		interface NonEmptyInterface2
-		{
-			event EventHandler TestEvent;
-		}
-		interface NonEmptyInterface3
-		{
-			int MyProperty {
-				get;
-			}
-		}
-		[Test]
-		public void TestNonEmptyInterface()
-		{
-			InterfaceNotEmptyRule rule = new InterfaceNotEmptyRule();
-			Assertion.AssertNull(rule.Check(typeof(NonEmptyInterface1)));
-			Assertion.AssertNull(rule.Check(typeof(NonEmptyInterface2)));
-			Assertion.AssertNull(rule.Check(typeof(NonEmptyInterface3)));
-		}
-		
-		interface EmptyInterface
-		{
-		}
-		
-		[Test]
-		public void TestEmptyInterface()
-		{
-			InterfaceNotEmptyRule rule = new InterfaceNotEmptyRule();
-			Assertion.AssertNotNull(rule.Check(typeof(EmptyInterface)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of InterfaceNotEmpty.	
+	/// </summary>
+	public class InterfaceNotEmptyRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Interfaces should not be empty";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Interfaces should specify behaviour. To mark classes use Attributes instead of empty interfaces.";
+			}
+		}
+		public Resolution Check(Type type)
+		{
+			if (type.IsInterface && type.GetMembers().Length == 0) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Use a custom attribute to replace the empty interface <code>{0}</code>. Or specify behaviour for this interface.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class InterfaceNotEmptyRuleTests
+	{
+		interface NonEmptyInterface1
+		{
+			void A();
+		}
+		interface NonEmptyInterface2
+		{
+			event EventHandler TestEvent;
+		}
+		interface NonEmptyInterface3
+		{
+			int MyProperty {
+				get;
+			}
+		}
+		[Test]
+		public void TestNonEmptyInterface()
+		{
+			InterfaceNotEmptyRule rule = new InterfaceNotEmptyRule();
+			Assertion.AssertNull(rule.Check(typeof(NonEmptyInterface1)));
+			Assertion.AssertNull(rule.Check(typeof(NonEmptyInterface2)));
+			Assertion.AssertNull(rule.Check(typeof(NonEmptyInterface3)));
+		}
+		
+		interface EmptyInterface
+		{
+		}
+		
+		[Test]
+		public void TestEmptyInterface()
+		{
+			InterfaceNotEmptyRule rule = new InterfaceNotEmptyRule();
+			Assertion.AssertNotNull(rule.Check(typeof(EmptyInterface)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/PropertiesShouldNotHaveSetOnly.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/PropertiesShouldNotHaveSetOnly.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/PropertiesShouldNotHaveSetOnly.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,101 +1,96 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of PropertiesShouldNotHaveSetOnly.	
-	/// </summary>
-	public class PropertiesShouldNotHaveSetOnly : AbstractReflectionRule, IPropertyRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.PropertiesShouldNotHaveSetOnly.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.PropertiesShouldNotHaveSetOnly.Details}";
-			}
-		}
-		
-		public Resolution Check(PropertyInfo property)
-		{
-			if (!property.CanRead && property.CanWrite) {
-				return new Resolution(this, 
-				                      "${res:MonoDevelop.AssemblyAnalyser.Rules.PropertiesShouldNotHaveSetOnly.Resolution}",
-				                      NamingUtilities.Combine(property.DeclaringType.FullName, property.Name),
-				                      new string[,] { 
-				                      	{"PropertyName", property.Name}, 
-				                      	{"DeclaringType", property.DeclaringType.FullName}, 
-				                      });
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class PropertiesShouldNotHaveSetOnlyTest
-	{
-		class A {
-			public int Inta {
-				get {
-					return 5;
-				}
-				set {
-					
-				}
-			}
-			public string StrB {
-				get {
-					return "";
-				}
-			}
-		}
-		[Test]
-		public void TestCorrectProperties()
-		{
-			PropertiesShouldNotHaveSetOnly rule = new PropertiesShouldNotHaveSetOnly();
-			Assertion.AssertNull(rule.Check(typeof(A).GetProperty("Inta")));
-			Assertion.AssertNull(rule.Check(typeof(A).GetProperty("StrB")));
-		}
-		
-		class B {
-			public int Inta {
-				set {
-				}
-			}
-			public string StrB {
-				set {
-				}
-			}
-		}
-		
-		[Test]
-		public void TestIncorrectProperties()
-		{
-			PropertiesShouldNotHaveSetOnly rule = new PropertiesShouldNotHaveSetOnly();
-			Assertion.AssertNotNull(rule.Check(typeof(B).GetProperty("Inta")));
-			Assertion.AssertNotNull(rule.Check(typeof(B).GetProperty("StrB")));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of PropertiesShouldNotHaveSetOnly.	
+	/// </summary>
+	public class PropertiesShouldNotHaveSetOnly : AbstractReflectionRule, IPropertyRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Properties should not be write only";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Write only properties generally indicate a design flaw and should be avoided.";
+			}
+		}
+		
+		public Resolution Check(PropertyInfo property)
+		{
+			if (!property.CanRead && property.CanWrite) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Add a getter to the property <code>{0}</code> in the type <code>{1}</code>.", property.Name, property.DeclaringType.FullName), NamingUtilities.Combine(property.DeclaringType.FullName, property.Name));
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class PropertiesShouldNotHaveSetOnlyTest
+	{
+		class A {
+			public int Inta {
+				get {
+					return 5;
+				}
+				set {
+					
+				}
+			}
+			public string StrB {
+				get {
+					return "";
+				}
+			}
+		}
+		[Test]
+		public void TestCorrectProperties()
+		{
+			PropertiesShouldNotHaveSetOnly rule = new PropertiesShouldNotHaveSetOnly();
+			Assertion.AssertNull(rule.Check(typeof(A).GetProperty("Inta")));
+			Assertion.AssertNull(rule.Check(typeof(A).GetProperty("StrB")));
+		}
+		
+		class B {
+			public int Inta {
+				set {
+				}
+			}
+			public string StrB {
+				set {
+				}
+			}
+		}
+		
+		[Test]
+		public void TestIncorrectProperties()
+		{
+			PropertiesShouldNotHaveSetOnly rule = new PropertiesShouldNotHaveSetOnly();
+			Assertion.AssertNotNull(rule.Check(typeof(B).GetProperty("Inta")));
+			Assertion.AssertNotNull(rule.Check(typeof(B).GetProperty("StrB")));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/TypesHaveNoPublicInstanceFields.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/TypesHaveNoPublicInstanceFields.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/TypesHaveNoPublicInstanceFields.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,107 +1,102 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of PropertiesShouldNotHaveSetOnly.	
-	/// </summary>
-	public class TypesHaveNoPublicInstanceFields : AbstractReflectionRule, IFieldRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.TypesHaveNoPublicInstanceFields.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.TypesHaveNoPublicInstanceFields.Details}";
-			}
-		}
-		
-		public TypesHaveNoPublicInstanceFields()
-		{
-			base.certainty = 90;
-		}
-		
-		public Resolution Check(Module module, FieldInfo field)
-		{
-			if (!field.IsStatic && (field.IsPublic || field.IsAssembly)) {
-				return new Resolution(this, 
-				                      "${res:MonoDevelop.AssemblyAnalyser.Rules.TypesHaveNoPublicInstanceFields.Resolution}",
-				                      NamingUtilities.Combine(field.DeclaringType.FullName, field.Name),
-				                      new string[,] {
-				                      	{"FieldName", field.Name}, 
-				                      	{"DeclaringType", field.DeclaringType.FullName}, 
-				                      });
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class TypesHaveNoPublicInstanceFieldsTest
-	{
-		class A {
-			int a;
-			protected string b;
-			public static int c = 12;
-			public int AA {
-				get {
-					return a;
-				}
-				set {
-					a = value;
-				}
-			}
-			public string B {
-				get {
-					return b;
-				}
-				set {
-					b = value;
-				}
-			}
-		}
-		[Test]
-		public void TestCorrectFields()
-		{
-			TypesHaveNoPublicInstanceFields rule = new TypesHaveNoPublicInstanceFields();
-			Assertion.AssertNull(rule.Check(null, typeof(A).GetField("a", BindingFlags.NonPublic | BindingFlags.Instance)));
-			Assertion.AssertNull(rule.Check(null, typeof(A).GetField("b", BindingFlags.NonPublic | BindingFlags.Instance)));
-			Assertion.AssertNull(rule.Check(null, typeof(A).GetField("c", BindingFlags.Public | BindingFlags.Static)));
-		}
-		
-		class B {
-			public int a = 5;
-			internal string b ="";
-		}
-		
-		[Test]
-		public void TestIncorrectFields()
-		{
-			TypesHaveNoPublicInstanceFields rule = new TypesHaveNoPublicInstanceFields();
-			Assertion.AssertNotNull(rule.Check(null, typeof(B).GetField("a", BindingFlags.Public | BindingFlags.Instance)));
-			Assertion.AssertNotNull(rule.Check(null, typeof(B).GetField("b", BindingFlags.NonPublic | BindingFlags.Instance)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of TypesHaveNoPublicInstanceFields
+	/// </summary>
+	public class TypesHaveNoPublicInstanceFields : AbstractReflectionRule, IFieldRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Types do not have externally visible instance fields";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Public or internal instance fields are a design flaw and should be avoided. Use properties instead. They are more flexible and hide the implementation details of the underlying data. Furthermore, properties do not have a performance penalty.";
+			}
+		}
+		
+		public TypesHaveNoPublicInstanceFields()
+		{
+			base.certainty = 90;
+		}
+		
+		public Resolution Check(Module module, FieldInfo field)
+		{
+			if (!field.IsStatic && (field.IsPublic || field.IsAssembly)) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Make the field <code>{0}</code> in the type <code>{1}</code> private or protected. Provide a public or internal property if the field should be accessed from outside.", field.Name, field.DeclaringType.FullName), NamingUtilities.Combine (field.DeclaringType.FullName, field.Name));
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class TypesHaveNoPublicInstanceFieldsTest
+	{
+		class A {
+			int a;
+			protected string b;
+			public static int c = 12;
+			public int AA {
+				get {
+					return a;
+				}
+				set {
+					a = value;
+				}
+			}
+			public string B {
+				get {
+					return b;
+				}
+				set {
+					b = value;
+				}
+			}
+		}
+		[Test]
+		public void TestCorrectFields()
+		{
+			TypesHaveNoPublicInstanceFields rule = new TypesHaveNoPublicInstanceFields();
+			Assertion.AssertNull(rule.Check(null, typeof(A).GetField("a", BindingFlags.NonPublic | BindingFlags.Instance)));
+			Assertion.AssertNull(rule.Check(null, typeof(A).GetField("b", BindingFlags.NonPublic | BindingFlags.Instance)));
+			Assertion.AssertNull(rule.Check(null, typeof(A).GetField("c", BindingFlags.Public | BindingFlags.Static)));
+		}
+		
+		class B {
+			public int a = 5;
+			internal string b ="";
+		}
+		
+		[Test]
+		public void TestIncorrectFields()
+		{
+			TypesHaveNoPublicInstanceFields rule = new TypesHaveNoPublicInstanceFields();
+			Assertion.AssertNotNull(rule.Check(null, typeof(B).GetField("a", BindingFlags.Public | BindingFlags.Instance)));
+			Assertion.AssertNotNull(rule.Check(null, typeof(B).GetField("b", BindingFlags.NonPublic | BindingFlags.Instance)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/TypesShouldBeInNamespacesRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/TypesShouldBeInNamespacesRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/DesignRules/TypesShouldBeInNamespacesRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,76 +1,77 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of TypesShouldBeInNamespaces.	
-	/// </summary>
-	public class TypesShouldBeInNamespacesRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.TypesShouldBeInNamespaces.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.TypesShouldBeInNamespaces.Details}";
-			}
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (type.Namespace == null || type.Namespace.Length == 0) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.TypesShouldBeInNamespaces.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-class OutsideNamespace
-{
-	
-}
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class TypesShouldBeInNamespacesRuleTest
-	{
-		interface ICorrectInterface
-		{
-		}
-		[Test]
-		public void TestCorrectAttribute()
-		{
-			TypesShouldBeInNamespacesRule rule = new TypesShouldBeInNamespacesRule();
-			Assertion.AssertNull(rule.Check(typeof(System.ICloneable)));
-			Assertion.AssertNull(rule.Check(typeof(TypesShouldBeInNamespacesRuleTest)));
-			Assertion.AssertNull(rule.Check(typeof(ICorrectInterface)));
-		}
-		
-		[Test]
-		public void TestIncorrectAttribute()
-		{
-			TypesShouldBeInNamespacesRule rule = new TypesShouldBeInNamespacesRule();
-			Assertion.AssertNotNull(rule.Check(typeof(OutsideNamespace)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of TypesShouldBeInNamespaces.	
+	/// </summary>
+	public class TypesShouldBeInNamespacesRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Types should be defined in namespaces";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type should always be defined inside a namespace to avoid naming collisions.";
+			}
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (type.Namespace == null || type.Namespace.Length == 0) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Declare <code>{0}</code> inside a namespace.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+class OutsideNamespace
+{
+	
+}
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class TypesShouldBeInNamespacesRuleTest
+	{
+		interface ICorrectInterface
+		{
+		}
+		[Test]
+		public void TestCorrectAttribute()
+		{
+			TypesShouldBeInNamespacesRule rule = new TypesShouldBeInNamespacesRule();
+			Assertion.AssertNull(rule.Check(typeof(System.ICloneable)));
+			Assertion.AssertNull(rule.Check(typeof(TypesShouldBeInNamespacesRuleTest)));
+			Assertion.AssertNull(rule.Check(typeof(ICorrectInterface)));
+		}
+		
+		[Test]
+		public void TestIncorrectAttribute()
+		{
+			TypesShouldBeInNamespacesRule rule = new TypesShouldBeInNamespacesRule();
+			Assertion.AssertNotNull(rule.Check(typeof(OutsideNamespace)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IAssemblyRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IAssemblyRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IAssemblyRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,20 +1,20 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of IAssemblyRule.	
-	/// </summary>
-	public interface IAssemblyRule : IReflectionRule
-	{
-		Resolution Check(Assembly assembly);
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of IAssemblyRule.	
+	/// </summary>
+	public interface IAssemblyRule : IReflectionRule
+	{
+		Resolution Check(Assembly assembly);
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IConstructorRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IConstructorRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IConstructorRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,20 +1,20 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of IConstructorRule.	
-	/// </summary>
-	public interface IConstructorRule : IReflectionRule
-	{
-		Resolution Check(ConstructorInfo constructor);
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of IConstructorRule.	
+	/// </summary>
+	public interface IConstructorRule : IReflectionRule
+	{
+		Resolution Check(ConstructorInfo constructor);
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IEventRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IEventRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IEventRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,20 +1,20 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of IEventRule.	
-	/// </summary>
-	public interface IEventRule : IReflectionRule
-	{
-		Resolution Check(EventInfo evnt);
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of IEventRule.	
+	/// </summary>
+	public interface IEventRule : IReflectionRule
+	{
+		Resolution Check(EventInfo evnt);
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IFieldRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IFieldRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IFieldRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,20 +1,20 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of IFieldRule.	
-	/// </summary>
-	public interface IFieldRule : IReflectionRule
-	{
-		Resolution Check(Module module, FieldInfo field);
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of IFieldRule.	
+	/// </summary>
+	public interface IFieldRule : IReflectionRule
+	{
+		Resolution Check(Module module, FieldInfo field);
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IMemberRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IMemberRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IMemberRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,20 +1,20 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of IMemberRule.	
-	/// </summary>
-	public interface IMemberRule : IReflectionRule
-	{
-		 Resolution Check(Module module, MemberInfo member);
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of IMemberRule.	
+	/// </summary>
+	public interface IMemberRule : IReflectionRule
+	{
+		 Resolution Check(Module module, MemberInfo member);
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IMethodBaseRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IMethodBaseRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IMethodBaseRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,20 +1,20 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of IMethodBaseRule.	
-	/// </summary>
-	public interface IMethodBaseRule : IReflectionRule
-	{
-		Resolution Check(Module module, MethodBase methodBase);
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of IMethodBaseRule.	
+	/// </summary>
+	public interface IMethodBaseRule : IReflectionRule
+	{
+		Resolution Check(Module module, MethodBase methodBase);
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IMethodRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IMethodRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IMethodRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,20 +1,20 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of IMethodRule.	
-	/// </summary>
-	public interface IMethodRule : IReflectionRule
-	{
-		Resolution Check(Module module, MethodInfo method);
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of IMethodRule.	
+	/// </summary>
+	public interface IMethodRule : IReflectionRule
+	{
+		Resolution Check(Module module, MethodInfo method);
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IModuleRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IModuleRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IModuleRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,20 +1,20 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of IModuleRule.	
-	/// </summary>
-	public interface IModuleRule : IReflectionRule
-	{
-		Resolution Check(Module module);
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of IModuleRule.	
+	/// </summary>
+	public interface IModuleRule : IReflectionRule
+	{
+		Resolution Check(Module module);
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/INamespaceRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/INamespaceRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/INamespaceRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,21 +1,21 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Collections;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of INamespaceRule.	
-	/// </summary>
-	public interface INamespaceRule : IReflectionRule
-	{
-		Resolution Check(string namespaceName, ICollection types);
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Collections;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of INamespaceRule.	
+	/// </summary>
+	public interface INamespaceRule : IReflectionRule
+	{
+		Resolution Check(string namespaceName, ICollection types);
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IParameterRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IParameterRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IParameterRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,20 +1,20 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of IParameterRule.	
-	/// </summary>
-	public interface IParameterRule : IReflectionRule
-	{
-		Resolution Check(Module module, ParameterInfo param);
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of IParameterRule.	
+	/// </summary>
+	public interface IParameterRule : IReflectionRule
+	{
+		Resolution Check(Module module, ParameterInfo param);
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IPropertyRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IPropertyRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IPropertyRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,20 +1,20 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of IPropertyRule.	
-	/// </summary>
-	public interface IPropertyRule : IReflectionRule
-	{
-		Resolution Check(PropertyInfo property);
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of IPropertyRule.	
+	/// </summary>
+	public interface IPropertyRule : IReflectionRule
+	{
+		Resolution Check(PropertyInfo property);
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IReflectionRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IReflectionRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IReflectionRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,31 +1,31 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of IAssemblyRule.	
-	/// </summary>
-	public interface IReflectionRule : IRule
-	{
-		ProtectionLevels MemberProtectionLevel {
-			get;
-		}
-		
-		ProtectionLevels NestedTypeProtectionLevel {
-			get;
-		}
-		
-		ProtectionLevels TypeProtectionLevel {
-			get;
-		}
-		
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of IAssemblyRule.	
+	/// </summary>
+	public interface IReflectionRule : IRule
+	{
+		ProtectionLevels MemberProtectionLevel {
+			get;
+		}
+		
+		ProtectionLevels NestedTypeProtectionLevel {
+			get;
+		}
+		
+		ProtectionLevels TypeProtectionLevel {
+			get;
+		}
+		
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/IRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,37 +1,37 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of IRule.	
-	/// </summary>
-	public interface IRule
-	{
-		void EndAnalysis();
-		void StartAnalysis();
-		
-		PriorityLevel PriorityLevel {
-			get;
-		}
-		
-		int Certainty {
-			get;
-		}
-		
-		string Description {
-			get;
-		}
-		
-		string Details {
-			get;
-		}
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of IRule.	
+	/// </summary>
+	public interface IRule
+	{
+		void EndAnalysis();
+		void StartAnalysis();
+		
+		PriorityLevel PriorityLevel {
+			get;
+		}
+		
+		int Certainty {
+			get;
+		}
+		
+		string Description {
+			get;
+		}
+		
+		string Details {
+			get;
+		}
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/ITypeRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/ITypeRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/ITypeRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,20 +1,20 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of ITypeRule.	
-	/// </summary>
-	public interface ITypeRule : IReflectionRule
-	{
-		Resolution Check(Type type);
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of ITypeRule.	
+	/// </summary>
+	public interface ITypeRule : IReflectionRule
+	{
+		Resolution Check(Type type);
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/AttributeSuffixIsAttributeRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/AttributeSuffixIsAttributeRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/AttributeSuffixIsAttributeRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,73 +1,74 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AttributeSuffixIsAttribute.	
-	/// </summary>
-	public class AttributeSuffixIsAttributeRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.AttributeSuffixIsAttribute.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.AttributeSuffixIsAttribute.Details}";
-			}
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (type.IsSubclassOf(typeof(System.Attribute)) && !type.Name.EndsWith("Attribute")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.AttributeSuffixIsAttribute.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class AttributeSuffixIsAttributeRuleTest
-	{
-		class MyAttribute : System.Attribute
-		{
-		}
-		[Test]
-		public void TestCorrectAttribute()
-		{
-			AttributeSuffixIsAttributeRule rule = new AttributeSuffixIsAttributeRule();
-			Assertion.AssertNull(rule.Check(typeof(MyAttribute)));
-		}
-		
-		class MyAttr : System.Attribute
-		{
-		}
-		[Test]
-		public void TestIncorrectAttribute()
-		{
-			AttributeSuffixIsAttributeRule rule = new AttributeSuffixIsAttributeRule();
-			Assertion.AssertNotNull(rule.Check(typeof(MyAttr)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of AttributeSuffixIsAttribute.	
+	/// </summary>
+	public class AttributeSuffixIsAttributeRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Attribute names have the suffix 'Attribute'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type that extends <code><a href='help://types/System.Attribute'>Attribute</a></code> is an attribute and its name should always end with <i>Attribute</i> like in <code>CategoryAttribute</code>.";
+			}
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (type.IsSubclassOf(typeof(System.Attribute)) && !type.Name.EndsWith("Attribute")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the name of the type <code>{0}</code> so that it ends with <I>Attribute</I>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class AttributeSuffixIsAttributeRuleTest
+	{
+		class MyAttribute : System.Attribute
+		{
+		}
+		[Test]
+		public void TestCorrectAttribute()
+		{
+			AttributeSuffixIsAttributeRule rule = new AttributeSuffixIsAttributeRule();
+			Assertion.AssertNull(rule.Check(typeof(MyAttribute)));
+		}
+		
+		class MyAttr : System.Attribute
+		{
+		}
+		[Test]
+		public void TestIncorrectAttribute()
+		{
+			AttributeSuffixIsAttributeRule rule = new AttributeSuffixIsAttributeRule();
+			Assertion.AssertNotNull(rule.Check(typeof(MyAttr)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/CheckCollectionSuffix.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/CheckCollectionSuffix.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/CheckCollectionSuffix.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,140 +1,143 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Collections;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of CheckCollectionSuffix.	
-	/// </summary>
-	public class CheckCollectionSuffix : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.CheckCollectionSuffix.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.CheckCollectionSuffix.Details}";
-			}
-		}
-		
-		public CheckCollectionSuffix()
-		{
-			base.certainty = 90;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if ((typeof(ICollection).IsAssignableFrom(type) || typeof(IEnumerable).IsAssignableFrom(type)) && !typeof(System.Collections.IDictionary).IsAssignableFrom(type)) {
-				if (typeof(Queue).IsAssignableFrom(type)) {
-					if (!type.Name.EndsWith("Queue")) {
-						return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.CheckCollectionSuffix.Resolution1}", type.FullName, new string[,] { { "TypeName", type.FullName }} );
-					}
-				} else if (typeof(Stack).IsAssignableFrom(type)) {
-					if (!type.Name.EndsWith("Stack")) {
-						return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.CheckCollectionSuffix.Resolution2}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-					}
-				} else {
-					if (!type.Name.EndsWith("Collection")) {
-						return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.CheckCollectionSuffix.Resolution3}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-					}
-				}
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class CheckCollectionSuffixTest
-	{
-		#region Collection suffix tests
-		class MyCollection : System.Collections.ArrayList
-		{
-		}
-		class MyDictionary : System.Collections.Hashtable
-		{
-		}
-		[Test]
-		public void TestCorrectCollection()
-		{
-			CheckCollectionSuffix checkCollectionSuffix = new CheckCollectionSuffix();
-			Assertion.AssertNull(checkCollectionSuffix.Check(typeof(MyCollection)));
-			Assertion.AssertNull(checkCollectionSuffix.Check(typeof(MyDictionary)));
-			Assertion.AssertNull(checkCollectionSuffix.Check(typeof(CheckCollectionSuffixTest)));
-		}
-		
-		class MyColl : System.Collections.ArrayList
-		{
-		}
-		[Test]
-		public void TestIncorrectCollection()
-		{
-			CheckCollectionSuffix checkCollectionSuffix = new CheckCollectionSuffix();
-			Assertion.AssertNotNull(checkCollectionSuffix.Check(typeof(MyColl)));
-		}
-		#endregion
-		
-		#region Queue suffix tests
-		class MyQueue : System.Collections.Queue
-		{
-		}
-		[Test]
-		public void TestCorrectQueue()
-		{
-			CheckCollectionSuffix checkCollectionSuffix = new CheckCollectionSuffix();
-			Assertion.AssertNull(checkCollectionSuffix.Check(typeof(MyQueue)));
-		}
-		
-		class MyQWEQWEQ : System.Collections.Queue
-		{
-		}
-		[Test]
-		public void TestIncorrectQueue()
-		{
-			CheckCollectionSuffix checkCollectionSuffix = new CheckCollectionSuffix();
-			Assertion.AssertNotNull(checkCollectionSuffix.Check(typeof(MyQWEQWEQ)));
-		}
-		#endregion 
-		
-		#region Stack suffix tests
-		class MyStack : System.Collections.Stack
-		{
-		}
-		[Test]
-		public void TestCorrectStack()
-		{
-			CheckCollectionSuffix checkCollectionSuffix = new CheckCollectionSuffix();
-			Assertion.AssertNull(checkCollectionSuffix.Check(typeof(MyStack)));
-		}
-		class MySfwefew : System.Collections.Stack
-		{
-		}
-		[Test]
-		public void TestIncorrectStack()
-		{
-			CheckCollectionSuffix checkCollectionSuffix = new CheckCollectionSuffix();
-			Assertion.AssertNotNull(checkCollectionSuffix.Check(typeof(MySfwefew)));
-		}
-		#endregion
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Collections;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of CheckCollectionSuffix.	
+	/// </summary>
+	public class CheckCollectionSuffix : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Collections names have the suffix 'Collection', 'Queue' or 'Stack'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type that implements <code><a href='help://types/System.Collections.ICollection'>ICollection</a></code> or <code><a href='help://types/System.Collections.IEnumerable'>IEnumerable</a></code> is a collection and its name should use the suffix <i>Collection</i>.<BR>An exception to this rule are queues (extend <code><a href='help://types/System.Collections.Queue'>Queue</a></code>) which should use the suffix <i>Queue</i> and stacks (extend <code><a href='help://types/System.Collections.Stack'>Stack</a></code>) that should use the <i>Stack</i> suffix. <BR>For example: <code>StringCollection</code>, <code>StateStack</code> or <code>EventQueue</code> are valid names.";
+			}
+		}
+		
+		public CheckCollectionSuffix()
+		{
+			base.certainty = 90;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if ((typeof(ICollection).IsAssignableFrom(type) || typeof(IEnumerable).IsAssignableFrom(type)) && !typeof(System.Collections.IDictionary).IsAssignableFrom(type)) {
+				if (typeof(Queue).IsAssignableFrom(type)) {
+					if (!type.Name.EndsWith("Queue")) {
+						// FIXME: I18N
+						return new Resolution (this, String.Format ("Change the name of the queue <code>{0}</code> so that it ends with <i>Queue</i>.", type.FullName), type.FullName);
+					}
+				} else if (typeof(Stack).IsAssignableFrom(type)) {
+					if (!type.Name.EndsWith("Stack")) {
+						// FIXME: I18N
+						return new Resolution (this, String.Format ("Change the name of the queue <code>{0}</code> so that it ends with <i>Stack</i>.", type.FullName), type.FullName);
+					}
+				} else {
+					if (!type.Name.EndsWith("Collection")) {
+						// FIXME: I18N
+						return new Resolution (this, String.Format ("Change the name of the queue <code>{0}</code> so that it ends with <i>Collection</i>.", type.FullName), type.FullName);
+					}
+				}
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class CheckCollectionSuffixTest
+	{
+		#region Collection suffix tests
+		class MyCollection : System.Collections.ArrayList
+		{
+		}
+		class MyDictionary : System.Collections.Hashtable
+		{
+		}
+		[Test]
+		public void TestCorrectCollection()
+		{
+			CheckCollectionSuffix checkCollectionSuffix = new CheckCollectionSuffix();
+			Assertion.AssertNull(checkCollectionSuffix.Check(typeof(MyCollection)));
+			Assertion.AssertNull(checkCollectionSuffix.Check(typeof(MyDictionary)));
+			Assertion.AssertNull(checkCollectionSuffix.Check(typeof(CheckCollectionSuffixTest)));
+		}
+		
+		class MyColl : System.Collections.ArrayList
+		{
+		}
+		[Test]
+		public void TestIncorrectCollection()
+		{
+			CheckCollectionSuffix checkCollectionSuffix = new CheckCollectionSuffix();
+			Assertion.AssertNotNull(checkCollectionSuffix.Check(typeof(MyColl)));
+		}
+		#endregion
+		
+		#region Queue suffix tests
+		class MyQueue : System.Collections.Queue
+		{
+		}
+		[Test]
+		public void TestCorrectQueue()
+		{
+			CheckCollectionSuffix checkCollectionSuffix = new CheckCollectionSuffix();
+			Assertion.AssertNull(checkCollectionSuffix.Check(typeof(MyQueue)));
+		}
+		
+		class MyQWEQWEQ : System.Collections.Queue
+		{
+		}
+		[Test]
+		public void TestIncorrectQueue()
+		{
+			CheckCollectionSuffix checkCollectionSuffix = new CheckCollectionSuffix();
+			Assertion.AssertNotNull(checkCollectionSuffix.Check(typeof(MyQWEQWEQ)));
+		}
+		#endregion 
+		
+		#region Stack suffix tests
+		class MyStack : System.Collections.Stack
+		{
+		}
+		[Test]
+		public void TestCorrectStack()
+		{
+			CheckCollectionSuffix checkCollectionSuffix = new CheckCollectionSuffix();
+			Assertion.AssertNull(checkCollectionSuffix.Check(typeof(MyStack)));
+		}
+		class MySfwefew : System.Collections.Stack
+		{
+		}
+		[Test]
+		public void TestIncorrectStack()
+		{
+			CheckCollectionSuffix checkCollectionSuffix = new CheckCollectionSuffix();
+			Assertion.AssertNotNull(checkCollectionSuffix.Check(typeof(MySfwefew)));
+		}
+		#endregion
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/DelegatesHaveNoDelegateSuffix.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/DelegatesHaveNoDelegateSuffix.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/DelegatesHaveNoDelegateSuffix.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,73 +1,74 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of DelegatesHaveNoDelegateSuffix.	
-	/// </summary>
-	public class DelegatesHaveNoDelegateSuffix : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.DelegatesHaveNoDelegateSuffix.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.DelegatesHaveNoDelegateSuffix.Details}";
-			}
-		}
-		
-		public DelegatesHaveNoDelegateSuffix()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (type.IsSubclassOf(typeof(System.Delegate)) && type.Name.EndsWith("Delegate")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.DelegatesHaveNoDelegateSuffix.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class DelegatesHaveNoDelegateSuffixTest
-	{
-		delegate void MyDelegateWithoutDelegateSuffix();
-		[Test]
-		public void TestCorrectDelegate()
-		{
-			DelegatesHaveNoDelegateSuffix delegatesHaveNoDelegateSuffix = new DelegatesHaveNoDelegateSuffix();
-			Assertion.AssertNull(delegatesHaveNoDelegateSuffix.Check(typeof(MyDelegateWithoutDelegateSuffix)));
-		}
-		
-		delegate void MyDelegateWithDelegateSuffixDelegate();
-		[Test]
-		public void TestIncorrectDelegate()
-		{
-			DelegatesHaveNoDelegateSuffix delegatesHaveNoDelegateSuffix = new DelegatesHaveNoDelegateSuffix();
-			Assertion.AssertNotNull(delegatesHaveNoDelegateSuffix.Check(typeof(MyDelegateWithDelegateSuffixDelegate)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of DelegatesHaveNoDelegateSuffix.	
+	/// </summary>
+	public class DelegatesHaveNoDelegateSuffix : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Delegate names do not have the suffix 'Delegate'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Do not use the <i>Delegate</i> suffix for delegate names. You may consider using a callback instead.";
+			}
+		}
+		
+		public DelegatesHaveNoDelegateSuffix()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (type.IsSubclassOf(typeof(System.Delegate)) && type.Name.EndsWith("Delegate")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Rename the delegate <code>{0}</code> so that it does not end with <i>Delegate</i>. Or replace it with a callback.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class DelegatesHaveNoDelegateSuffixTest
+	{
+		delegate void MyDelegateWithoutDelegateSuffix();
+		[Test]
+		public void TestCorrectDelegate()
+		{
+			DelegatesHaveNoDelegateSuffix delegatesHaveNoDelegateSuffix = new DelegatesHaveNoDelegateSuffix();
+			Assertion.AssertNull(delegatesHaveNoDelegateSuffix.Check(typeof(MyDelegateWithoutDelegateSuffix)));
+		}
+		
+		delegate void MyDelegateWithDelegateSuffixDelegate();
+		[Test]
+		public void TestIncorrectDelegate()
+		{
+			DelegatesHaveNoDelegateSuffix delegatesHaveNoDelegateSuffix = new DelegatesHaveNoDelegateSuffix();
+			Assertion.AssertNotNull(delegatesHaveNoDelegateSuffix.Check(typeof(MyDelegateWithDelegateSuffixDelegate)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/DictionaryTypeSuffixIsDictionary.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/DictionaryTypeSuffixIsDictionary.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/DictionaryTypeSuffixIsDictionary.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,74 +1,75 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of DelegatesHaveNoDelegateSuffix.	
-	/// </summary>
-	public class DictionaryTypeSuffixIsDictionary : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.DictionaryTypeSuffixIsDictionary.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.DictionaryTypeSuffixIsDictionary.Details}";
-			}
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (typeof(System.Collections.IDictionary).IsAssignableFrom(type) && !type.Name.EndsWith("Dictionary")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.DictionaryTypeSuffixIsDictionary.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class DictionaryTypeSuffixIsDictionaryTest
-	{
-		class CorrectDictionary : System.Collections.Hashtable
-		{
-		}
-		[Test]
-		public void TestCorrectDictionary()
-		{
-			DictionaryTypeSuffixIsDictionary dictionaryTypeSuffixIsDictionary = new DictionaryTypeSuffixIsDictionary();
-			Assertion.AssertNull(dictionaryTypeSuffixIsDictionary.Check(typeof(CorrectDictionary)));
-		}
-		
-		class IncorrectDictionaryWrongSuffix : System.Collections.Hashtable
-		{
-		}
-		[Test]
-		public void TestIncorrectDictionary()
-		{
-			DictionaryTypeSuffixIsDictionary dictionaryTypeSuffixIsDictionary = new DictionaryTypeSuffixIsDictionary();
-			Assertion.AssertNotNull(dictionaryTypeSuffixIsDictionary.Check(typeof(IncorrectDictionaryWrongSuffix)));
-		}
-		
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of DictionaryTypeSuffixIsDictionary.	
+	/// </summary>
+	public class DictionaryTypeSuffixIsDictionary : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Dictionary names have the suffix 'Dictionary'.";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type that implements <code><a href='help://types/System.Collections.IDictionary'>IDictionary</a></code> is a dictonary and should use the suffix <i>Dictionary</i> like in <code>HybridDictionary</code>.";
+			}
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (typeof(System.Collections.IDictionary).IsAssignableFrom(type) && !type.Name.EndsWith("Dictionary")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the name of the dictionary <code>{0}</code> so that it ends with <i>Dictionary</i>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class DictionaryTypeSuffixIsDictionaryTest
+	{
+		class CorrectDictionary : System.Collections.Hashtable
+		{
+		}
+		[Test]
+		public void TestCorrectDictionary()
+		{
+			DictionaryTypeSuffixIsDictionary dictionaryTypeSuffixIsDictionary = new DictionaryTypeSuffixIsDictionary();
+			Assertion.AssertNull(dictionaryTypeSuffixIsDictionary.Check(typeof(CorrectDictionary)));
+		}
+		
+		class IncorrectDictionaryWrongSuffix : System.Collections.Hashtable
+		{
+		}
+		[Test]
+		public void TestIncorrectDictionary()
+		{
+			DictionaryTypeSuffixIsDictionary dictionaryTypeSuffixIsDictionary = new DictionaryTypeSuffixIsDictionary();
+			Assertion.AssertNotNull(dictionaryTypeSuffixIsDictionary.Check(typeof(IncorrectDictionaryWrongSuffix)));
+		}
+		
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EnumsHaveNoEnumSuffix.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EnumsHaveNoEnumSuffix.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EnumsHaveNoEnumSuffix.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,80 +1,81 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of DelegatesHaveNoDelegateSuffix.	
-	/// </summary>
-	public class EnumsHaveNoEnumSuffix : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EnumsHaveNoEnumSuffix.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EnumsHaveNoEnumSuffix.Details}";
-			}
-		}
-		
-		public EnumsHaveNoEnumSuffix()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (type.IsSubclassOf(typeof(System.Enum)) && type.Name.EndsWith("Enum")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.EnumsHaveNoEnumSuffix.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class EnumsHaveNoEnumSuffixTest
-	{
-		enum CorrectEnumWithAnotherSuffix
-		{
-			A, B, C
-		}
-		[Test]
-		public void TestCorrectEnum()
-		{
-			EnumsHaveNoEnumSuffix enumsHaveNoEnumSuffix = new EnumsHaveNoEnumSuffix();
-			Assertion.AssertNull(enumsHaveNoEnumSuffix.Check(typeof(CorrectEnumWithAnotherSuffix)));
-		}
-		
-		enum IncorrectEnum
-		{
-			A, B, C
-		}
-		[Test]
-		public void TestIncorrectDictionary()
-		{
-			EnumsHaveNoEnumSuffix enumsHaveNoEnumSuffix = new EnumsHaveNoEnumSuffix();
-			Assertion.AssertNotNull(enumsHaveNoEnumSuffix.Check(typeof(IncorrectEnum)));
-		}
-		
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of EnumsHaveNoEnumSuffix.	
+	/// </summary>
+	public class EnumsHaveNoEnumSuffix : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Enumeration names do not have the suffix 'Enum'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Do not use the <i>Enum</i> suffix for enumeration names.";
+			}
+		}
+		
+		public EnumsHaveNoEnumSuffix()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (type.IsSubclassOf(typeof(System.Enum)) && type.Name.EndsWith("Enum")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Rename the enumeration <code>{0}</code> so that it does not end with <i>Enum</i>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class EnumsHaveNoEnumSuffixTest
+	{
+		enum CorrectEnumWithAnotherSuffix
+		{
+			A, B, C
+		}
+		[Test]
+		public void TestCorrectEnum()
+		{
+			EnumsHaveNoEnumSuffix enumsHaveNoEnumSuffix = new EnumsHaveNoEnumSuffix();
+			Assertion.AssertNull(enumsHaveNoEnumSuffix.Check(typeof(CorrectEnumWithAnotherSuffix)));
+		}
+		
+		enum IncorrectEnum
+		{
+			A, B, C
+		}
+		[Test]
+		public void TestIncorrectDictionary()
+		{
+			EnumsHaveNoEnumSuffix enumsHaveNoEnumSuffix = new EnumsHaveNoEnumSuffix();
+			Assertion.AssertNotNull(enumsHaveNoEnumSuffix.Check(typeof(IncorrectEnum)));
+		}
+		
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventArgsSuffixIsEventArgsRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventArgsSuffixIsEventArgsRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventArgsSuffixIsEventArgsRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,74 +1,75 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AttributeSuffixIsAttribute.	
-	/// </summary>
-	public class EventArgsSuffixIsEventArgsRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventArgsSuffixIsEventArgs.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventArgsSuffixIsEventArgs.Details}";
-			}
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (typeof(System.EventArgs).IsAssignableFrom(type) && !type.Name.EndsWith("EventArgs")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.EventArgsSuffixIsEventArgs.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class EventArgsSuffixIsEventArgsRuleTest
-	{
-		class CorrectEventArgs : System.EventArgs
-		{
-		}
-		[Test]
-		public void TestCorrectEventArgs()
-		{
-			EventArgsSuffixIsEventArgsRule rule = new EventArgsSuffixIsEventArgsRule();
-			Assertion.AssertNull(rule.Check(typeof(CorrectEventArgs)));
-		}
-		
-		class IncorrectEventArgsWithWrongSuffix : System.EventArgs
-		{
-		}
-		[Test]
-		public void TestIncorrectEventArgs()
-		{
-			EventArgsSuffixIsEventArgsRule rule = new EventArgsSuffixIsEventArgsRule();
-			Assertion.AssertNotNull(rule.Check(typeof(IncorrectEventArgsWithWrongSuffix)));
-		}
-		
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of EventArgsSuffixIsEventArgs
+	/// </summary>
+	public class EventArgsSuffixIsEventArgsRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "EventArgs names have the suffix 'EventArgs'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type that extends <code><a href='help://types/System.EventArgs'>EventArgs</a></code> is an event argument and should use the suffix <i>EventArgs</i> like in <code>MouseEventArgs</code>.";
+			}
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (typeof(System.EventArgs).IsAssignableFrom(type) && !type.Name.EndsWith("EventArgs")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Rename the event argument <code>{0}</code> so that it ends with <i>EventArgs</i>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class EventArgsSuffixIsEventArgsRuleTest
+	{
+		class CorrectEventArgs : System.EventArgs
+		{
+		}
+		[Test]
+		public void TestCorrectEventArgs()
+		{
+			EventArgsSuffixIsEventArgsRule rule = new EventArgsSuffixIsEventArgsRule();
+			Assertion.AssertNull(rule.Check(typeof(CorrectEventArgs)));
+		}
+		
+		class IncorrectEventArgsWithWrongSuffix : System.EventArgs
+		{
+		}
+		[Test]
+		public void TestIncorrectEventArgs()
+		{
+			EventArgsSuffixIsEventArgsRule rule = new EventArgsSuffixIsEventArgsRule();
+			Assertion.AssertNotNull(rule.Check(typeof(IncorrectEventArgsWithWrongSuffix)));
+		}
+		
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventFirstParameterNameIsSender.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventFirstParameterNameIsSender.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventFirstParameterNameIsSender.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,92 +1,93 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of EventFirstParameterNameIsSender.	
-	/// </summary>
-	public class EventFirstParameterNameIsSender : AbstractReflectionRule, IEventRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventFirstParameterNameIsSender.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventFirstParameterNameIsSender.Details}";
-			}
-		}
-		
-		public EventFirstParameterNameIsSender()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(EventInfo evnt)
-		{
-			MethodInfo invokeMethod = evnt.EventHandlerType.GetMethod("Invoke");
-			ParameterInfo[] parameters = invokeMethod.GetParameters();
-
-			if (parameters.Length > 0 && parameters[0].Name != "sender") {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.EventFirstParameterNameIsSender.Resolution}", evnt.EventHandlerType.FullName, new string[,] { { "EventType", evnt.EventHandlerType.FullName }, { "OldParameterName", parameters[0].Name }});
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class EventFirstParameterNameIsSenderTest
-	{
-		public delegate void CorrectEventHandler(object sender, EventArgs e);
-		public event CorrectEventHandler CorrectEvent;
-		protected virtual void OnCorrectEvent(EventArgs e)
-		{
-			if (CorrectEvent != null) {
-				CorrectEvent(this, e);
-			}
-		}
-		[Test]
-		public void TestCorrectEventHandler()
-		{
-			EventFirstParameterNameIsSender eventFirstParameterNameIsSender = new EventFirstParameterNameIsSender();
-			Assertion.AssertNull(eventFirstParameterNameIsSender.Check(this.GetType().GetEvent("CorrectEvent")));
-		}
-		
-		public delegate void IncorrectEventHandler(object s, EventArgs e);
-		public event IncorrectEventHandler IncorrectEvent;
-		protected virtual void OnIncorrectEvent(EventArgs e)
-		{
-			if (IncorrectEvent != null) {
-				IncorrectEvent(this, e);
-			}
-		}
-		
-		[Test]
-		public void TestIncorrectEventHandler()
-		{
-			EventFirstParameterNameIsSender eventFirstParameterNameIsSender = new EventFirstParameterNameIsSender();
-			Assertion.AssertNotNull(eventFirstParameterNameIsSender.Check(this.GetType().GetEvent("IncorrectEvent")));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of EventFirstParameterNameIsSender.	
+	/// </summary>
+	public class EventFirstParameterNameIsSender : AbstractReflectionRule, IEventRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "First parameter in events is named 'sender'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "As a convention in .NET events have two parameters a sender which must be called <i>sender</i> and an event data object. The sender must always be from the type <code><a href='help://types/System.Object'>object</a></code> and never a specialized type.<BR>For example: <code>void MouseEventHandler(object sender, MouseEventArgs e);</code>";
+			}
+		}
+		
+		public EventFirstParameterNameIsSender()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(EventInfo evnt)
+		{
+			MethodInfo invokeMethod = evnt.EventHandlerType.GetMethod("Invoke");
+			ParameterInfo[] parameters = invokeMethod.GetParameters();
+
+			if (parameters.Length > 0 && parameters[0].Name != "sender") {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Rename the first parameter name of the event <code>{0}</code> from <i>{1}</i> to <i>sender</i>.", evnt.EventHandlerType.FullName, parameters[0].Name), evnt.EventHandlerType.FullName);
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class EventFirstParameterNameIsSenderTest
+	{
+		public delegate void CorrectEventHandler(object sender, EventArgs e);
+		public event CorrectEventHandler CorrectEvent;
+		protected virtual void OnCorrectEvent(EventArgs e)
+		{
+			if (CorrectEvent != null) {
+				CorrectEvent(this, e);
+			}
+		}
+		[Test]
+		public void TestCorrectEventHandler()
+		{
+			EventFirstParameterNameIsSender eventFirstParameterNameIsSender = new EventFirstParameterNameIsSender();
+			Assertion.AssertNull(eventFirstParameterNameIsSender.Check(this.GetType().GetEvent("CorrectEvent")));
+		}
+		
+		public delegate void IncorrectEventHandler(object s, EventArgs e);
+		public event IncorrectEventHandler IncorrectEvent;
+		protected virtual void OnIncorrectEvent(EventArgs e)
+		{
+			if (IncorrectEvent != null) {
+				IncorrectEvent(this, e);
+			}
+		}
+		
+		[Test]
+		public void TestIncorrectEventHandler()
+		{
+			EventFirstParameterNameIsSender eventFirstParameterNameIsSender = new EventFirstParameterNameIsSender();
+			Assertion.AssertNotNull(eventFirstParameterNameIsSender.Check(this.GetType().GetEvent("IncorrectEvent")));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventHandlerSuffixIsEventHandler.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventHandlerSuffixIsEventHandler.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventHandlerSuffixIsEventHandler.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,95 +1,96 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of EventHandlerSuffixIsEventHandler.	
-	/// </summary>
-	public class EventHandlerSuffixIsEventHandler : AbstractReflectionRule, IEventRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventHandlerSuffixIsEventHandler.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventHandlerSuffixIsEventHandler.Details}";
-			}
-		}
-		
-		public Resolution Check(EventInfo evnt)
-		{
-			if (!evnt.EventHandlerType.Name.EndsWith("EventHandler")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.EventHandlerSuffixIsEventHandler.Resolution}", evnt.EventHandlerType.FullName, new string[,] { { "EventType", evnt.EventHandlerType.FullName }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class EventsDoNotHaveBeforeOrAfterPrefixTest
-	{
-		public event EventHandler CorrectEvent;
-		protected virtual void OnCorrectEvent(EventArgs e)
-		{
-			if (CorrectEvent != null) {
-				CorrectEvent(this, e);
-			}
-		}
-		[Test]
-		public void TestCorrectEventHandler()
-		{
-			EventsDoNotHaveBeforeOrAfterPrefix eventsDoNotHaveBeforeOrAfterPrefix = new EventsDoNotHaveBeforeOrAfterPrefix();
-			Assertion.AssertNull(eventsDoNotHaveBeforeOrAfterPrefix.Check(this.GetType().GetEvent("CorrectEvent")));
-		}
-
-		public event EventHandler BeforeIncorrectEvent;
-		protected virtual void OnBeforeIncorrectEvent(EventArgs e)
-		{
-			if (BeforeIncorrectEvent != null) {
-				BeforeIncorrectEvent(this, e);
-			}
-		}
-		[Test]
-		public void TestIncorrectEventHandler1()
-		{
-			EventsDoNotHaveBeforeOrAfterPrefix eventsDoNotHaveBeforeOrAfterPrefix = new EventsDoNotHaveBeforeOrAfterPrefix();
-			Assertion.AssertNotNull(eventsDoNotHaveBeforeOrAfterPrefix.Check(this.GetType().GetEvent("BeforeIncorrectEvent")));
-		}
-		
-		public event EventHandler AfterIncorrectEvent;
-		protected virtual void OnAfterIncorrectEvent(EventArgs e)
-		{
-			if (AfterIncorrectEvent != null) {
-				AfterIncorrectEvent(this, e);
-			}
-		}
-		[Test]
-		public void TestIncorrectEventHandler2()
-		{
-			EventsDoNotHaveBeforeOrAfterPrefix eventsDoNotHaveBeforeOrAfterPrefix = new EventsDoNotHaveBeforeOrAfterPrefix();
-			Assertion.AssertNotNull(eventsDoNotHaveBeforeOrAfterPrefix.Check(this.GetType().GetEvent("AfterIncorrectEvent")));
-		}
-		
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of EventHandlerSuffixIsEventHandler.	
+	/// </summary>
+	public class EventHandlerSuffixIsEventHandler : AbstractReflectionRule, IEventRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Event handler names have the suffix 'EventHandler'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "An event handler delegate name should use the suffix <i>EventHandler</i> like in <code>DragAndDropEventHandler</code>.";
+			}
+		}
+		
+		public Resolution Check(EventInfo evnt)
+		{
+			if (!evnt.EventHandlerType.Name.EndsWith("EventHandler")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the name of the member <code>{0}</code> in the type <code>{1}</code> so that it does not end with <i>EventHandler</i>.", evnt.EventHandlerType.FullName, evnt.DeclaringType.FullName), evnt.EventHandlerType.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class EventsDoNotHaveBeforeOrAfterPrefixTest
+	{
+		public event EventHandler CorrectEvent;
+		protected virtual void OnCorrectEvent(EventArgs e)
+		{
+			if (CorrectEvent != null) {
+				CorrectEvent(this, e);
+			}
+		}
+		[Test]
+		public void TestCorrectEventHandler()
+		{
+			EventsDoNotHaveBeforeOrAfterPrefix eventsDoNotHaveBeforeOrAfterPrefix = new EventsDoNotHaveBeforeOrAfterPrefix();
+			Assertion.AssertNull(eventsDoNotHaveBeforeOrAfterPrefix.Check(this.GetType().GetEvent("CorrectEvent")));
+		}
+
+		public event EventHandler BeforeIncorrectEvent;
+		protected virtual void OnBeforeIncorrectEvent(EventArgs e)
+		{
+			if (BeforeIncorrectEvent != null) {
+				BeforeIncorrectEvent(this, e);
+			}
+		}
+		[Test]
+		public void TestIncorrectEventHandler1()
+		{
+			EventsDoNotHaveBeforeOrAfterPrefix eventsDoNotHaveBeforeOrAfterPrefix = new EventsDoNotHaveBeforeOrAfterPrefix();
+			Assertion.AssertNotNull(eventsDoNotHaveBeforeOrAfterPrefix.Check(this.GetType().GetEvent("BeforeIncorrectEvent")));
+		}
+		
+		public event EventHandler AfterIncorrectEvent;
+		protected virtual void OnAfterIncorrectEvent(EventArgs e)
+		{
+			if (AfterIncorrectEvent != null) {
+				AfterIncorrectEvent(this, e);
+			}
+		}
+		[Test]
+		public void TestIncorrectEventHandler2()
+		{
+			EventsDoNotHaveBeforeOrAfterPrefix eventsDoNotHaveBeforeOrAfterPrefix = new EventsDoNotHaveBeforeOrAfterPrefix();
+			Assertion.AssertNotNull(eventsDoNotHaveBeforeOrAfterPrefix.Check(this.GetType().GetEvent("AfterIncorrectEvent")));
+		}
+		
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventSecondParameterNameIsE.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventSecondParameterNameIsE.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventSecondParameterNameIsE.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,91 +1,92 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of EventFirstParameterNameIsSender.	
-	/// </summary>
-	public class EventSecondParameterNameIsE : AbstractReflectionRule, IEventRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventSecondParameterNameIsE.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventSecondParameterNameIsE.Details}";
-			}
-		}
-		
-		public EventSecondParameterNameIsE()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(EventInfo evnt)
-		{
-			MethodInfo invokeMethod = evnt.EventHandlerType.GetMethod("Invoke");
-			ParameterInfo[] parameters = invokeMethod.GetParameters();
-
-			if (parameters.Length > 1 && parameters[1].Name != "e") {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.EventSecondParameterNameIsE.Resolution}", evnt.EventHandlerType.FullName, new string[,] { { "EventType", evnt.EventHandlerType.FullName }, { "OldParameterName", parameters[1].Name }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class EventSecondParameterNameIsETest
-	{
-		public delegate void CorrectEventHandler(object sender, EventArgs e);
-		public event CorrectEventHandler CorrectEvent;
-		protected virtual void OnCorrectEvent(EventArgs e)
-		{
-			if (CorrectEvent != null) {
-				CorrectEvent(this, e);
-			}
-		}
-		[Test]
-		public void TestCorrectEventHandler()
-		{
-			EventSecondParameterNameIsE eventSecondParameterNameIsE = new EventSecondParameterNameIsE();
-			Assertion.AssertNull(eventSecondParameterNameIsE.Check(this.GetType().GetEvent("CorrectEvent")));
-		}
-		
-		public delegate void IncorrectEventHandler(object sender, EventArgs notE);
-		public event IncorrectEventHandler IncorrectEvent;
-		protected virtual void OnIncorrectEvent(EventArgs e)
-		{
-			if (IncorrectEvent != null) {
-				IncorrectEvent(this, e);
-			}
-		}
-		
-		[Test]
-		public void TestIncorrectEventHandler()
-		{
-			EventSecondParameterNameIsE eventSecondParameterNameIsE = new EventSecondParameterNameIsE();
-			Assertion.AssertNotNull(eventSecondParameterNameIsE.Check(this.GetType().GetEvent("IncorrectEvent")));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of EventSecondParameterNameIsE	
+	/// </summary>
+	public class EventSecondParameterNameIsE : AbstractReflectionRule, IEventRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Second parameter in events is named 'e'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "As a convention in .NET events have two parameters a sender and an event data object which is called <i>e</i>. The event data object must be extend from the type <code><a href='help://types/System.EventArgs'>EventArgs</a></code>.<BR>For example: <code>void MouseEventHandler(object sender, MouseEventArgs e);</code>";
+			}
+		}
+		
+		public EventSecondParameterNameIsE()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(EventInfo evnt)
+		{
+			MethodInfo invokeMethod = evnt.EventHandlerType.GetMethod("Invoke");
+			ParameterInfo[] parameters = invokeMethod.GetParameters();
+
+			if (parameters.Length > 1 && parameters[1].Name != "e") {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Rename the second parameter name in the event <code>{0}</code> from <i>{1}</i> to <i>e</i>.", evnt.EventHandlerType.FullName, parameters[1].Name), evnt.EventHandlerType.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class EventSecondParameterNameIsETest
+	{
+		public delegate void CorrectEventHandler(object sender, EventArgs e);
+		public event CorrectEventHandler CorrectEvent;
+		protected virtual void OnCorrectEvent(EventArgs e)
+		{
+			if (CorrectEvent != null) {
+				CorrectEvent(this, e);
+			}
+		}
+		[Test]
+		public void TestCorrectEventHandler()
+		{
+			EventSecondParameterNameIsE eventSecondParameterNameIsE = new EventSecondParameterNameIsE();
+			Assertion.AssertNull(eventSecondParameterNameIsE.Check(this.GetType().GetEvent("CorrectEvent")));
+		}
+		
+		public delegate void IncorrectEventHandler(object sender, EventArgs notE);
+		public event IncorrectEventHandler IncorrectEvent;
+		protected virtual void OnIncorrectEvent(EventArgs e)
+		{
+			if (IncorrectEvent != null) {
+				IncorrectEvent(this, e);
+			}
+		}
+		
+		[Test]
+		public void TestIncorrectEventHandler()
+		{
+			EventSecondParameterNameIsE eventSecondParameterNameIsE = new EventSecondParameterNameIsE();
+			Assertion.AssertNotNull(eventSecondParameterNameIsE.Check(this.GetType().GetEvent("IncorrectEvent")));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventsDoNotHaveBeforeOrAfterPrefix.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventsDoNotHaveBeforeOrAfterPrefix.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/EventsDoNotHaveBeforeOrAfterPrefix.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,91 +1,93 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of EventsDoNotHaveBeforeOrAfterPrefix.	
-	/// </summary>
-	public class EventsDoNotHaveBeforeOrAfterPrefix : AbstractReflectionRule, IEventRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventsDoNotHaveBeforeOrAfterPrefix.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.EventsDoNotHaveBeforeOrAfterPrefix.Details}";
-			}
-		}
-		
-		public EventsDoNotHaveBeforeOrAfterPrefix()
-		{
-			base.certainty = 90;
-		}
-		
-		public Resolution Check(EventInfo evnt)
-		{
-			if (evnt.Name.StartsWith("Before")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.EventsDoNotHaveBeforeOrAfterPrefix.Resolution1}", NamingUtilities.Combine(evnt.ReflectedType.FullName, evnt.Name), new string[,] { { "EventName", evnt.Name }, { "ReflectedType", evnt.ReflectedType.FullName }});
-			} else if (evnt.Name.StartsWith("After")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.EventsDoNotHaveBeforeOrAfterPrefix.Resolution2}", NamingUtilities.Combine(evnt.ReflectedType.FullName, evnt.Name), new string[,] { { "EventName", evnt.Name }, { "ReflectedType", evnt.ReflectedType.FullName }});	
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class EventHandlerSuffixIsEventHandlerTest
-	{
-		public delegate void CorrectEventHandler(object sender, EventArgs e);
-		public event CorrectEventHandler CorrectEvent;
-		protected virtual void OnCorrectEvent(EventArgs e)
-		{
-			if (CorrectEvent != null) {
-				CorrectEvent(this, e);
-			}
-		}
-		[Test]
-		public void TestCorrectEventHandler()
-		{
-			EventHandlerSuffixIsEventHandler eventHandlerSuffixIsEventHandler = new EventHandlerSuffixIsEventHandler();
-			Assertion.AssertNull(eventHandlerSuffixIsEventHandler.Check(this.GetType().GetEvent("CorrectEvent")));
-		}
-		
-		public delegate void IncorrectEventHandlerWithWrongSuffix(object sender, EventArgs e);
-		public event IncorrectEventHandlerWithWrongSuffix IncorrectEvent;
-		protected virtual void OnIncorrectEvent(EventArgs e)
-		{
-			if (IncorrectEvent != null) {
-				IncorrectEvent(this, e);
-			}
-		}
-		
-		[Test]
-		public void TestIncorrectEventHandler()
-		{
-			EventHandlerSuffixIsEventHandler eventHandlerSuffixIsEventHandler = new EventHandlerSuffixIsEventHandler();
-			EventInfo evnt = this.GetType().GetEvent("IncorrectEvent");
-			Assertion.AssertNotNull("Type name is >" + evnt.EventHandlerType.FullName + "<", eventHandlerSuffixIsEventHandler.Check(evnt));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of EventsDoNotHaveBeforeOrAfterPrefix.	
+	/// </summary>
+	public class EventsDoNotHaveBeforeOrAfterPrefix : AbstractReflectionRule, IEventRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Event names do not have a 'Before' or 'After' prefix";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Use present or past tense for pre/post events instead using <i>Before</i> or <i>After</i> prefix.";
+			}
+		}
+		
+		public EventsDoNotHaveBeforeOrAfterPrefix()
+		{
+			base.certainty = 90;
+		}
+		
+		public Resolution Check(EventInfo evnt)
+		{
+			if (evnt.Name.StartsWith("Before")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change event name <code>{0}</code> in <code>{1}</code> so that it does not use the <i>Before</i> prefix.", evnt.Name, evnt.ReflectedType.FullName), NamingUtilities.Combine (evnt.ReflectedType.FullName, evnt.Name));
+			} else if (evnt.Name.StartsWith("After")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change event name <code>{0}</code> in <code>{1}</code> so that it does not use the <i>After</i> prefix.", evnt.Name, evnt.ReflectedType.FullName), NamingUtilities.Combine (evnt.ReflectedType.FullName, evnt.Name));
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class EventHandlerSuffixIsEventHandlerTest
+	{
+		public delegate void CorrectEventHandler(object sender, EventArgs e);
+		public event CorrectEventHandler CorrectEvent;
+		protected virtual void OnCorrectEvent(EventArgs e)
+		{
+			if (CorrectEvent != null) {
+				CorrectEvent(this, e);
+			}
+		}
+		[Test]
+		public void TestCorrectEventHandler()
+		{
+			EventHandlerSuffixIsEventHandler eventHandlerSuffixIsEventHandler = new EventHandlerSuffixIsEventHandler();
+			Assertion.AssertNull(eventHandlerSuffixIsEventHandler.Check(this.GetType().GetEvent("CorrectEvent")));
+		}
+		
+		public delegate void IncorrectEventHandlerWithWrongSuffix(object sender, EventArgs e);
+		public event IncorrectEventHandlerWithWrongSuffix IncorrectEvent;
+		protected virtual void OnIncorrectEvent(EventArgs e)
+		{
+			if (IncorrectEvent != null) {
+				IncorrectEvent(this, e);
+			}
+		}
+		
+		[Test]
+		public void TestIncorrectEventHandler()
+		{
+			EventHandlerSuffixIsEventHandler eventHandlerSuffixIsEventHandler = new EventHandlerSuffixIsEventHandler();
+			EventInfo evnt = this.GetType().GetEvent("IncorrectEvent");
+			Assertion.AssertNotNull("Type name is >" + evnt.EventHandlerType.FullName + "<", eventHandlerSuffixIsEventHandler.Check(evnt));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/ExceptionSuffixIsExceptionRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/ExceptionSuffixIsExceptionRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/ExceptionSuffixIsExceptionRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,77 +1,78 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of ExceptionSuffixIsException.	
-	/// </summary>
-	public class ExceptionSuffixIsExceptionRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.ExceptionSuffixIsException.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.ExceptionSuffixIsException.Details}";
-			}
-		}
-		
-		public ExceptionSuffixIsExceptionRule()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (typeof(System.Exception).IsAssignableFrom(type) && !type.Name.EndsWith("Exception")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.ExceptionSuffixIsException.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class ExceptionSuffixIsExceptionRuleTest
-	{
-		class MyException : System.Exception
-		{
-		}
-		[Test]
-		public void TestCorrectException()
-		{
-			ExceptionSuffixIsExceptionRule rule = new ExceptionSuffixIsExceptionRule();
-			Assertion.AssertNull(rule.Check(typeof(MyException)));
-		}
-		
-		class MyExcpt : System.Exception
-		{
-		}
-		[Test]
-		public void TestIncorrectException()
-		{
-			ExceptionSuffixIsExceptionRule rule = new ExceptionSuffixIsExceptionRule();
-			Assertion.AssertNotNull(rule.Check(typeof(MyExcpt)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of ExceptionSuffixIsException.	
+	/// </summary>
+	public class ExceptionSuffixIsExceptionRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Exception names have the suffix 'Exception'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type that extends <code><a href='help://types/System.Exception'>Exception</a></code> is an exception and should always use the suffix <i>Exception</i> like in <code>ArgumentNullException</code>.";
+			}
+		}
+		
+		public ExceptionSuffixIsExceptionRule()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (typeof(System.Exception).IsAssignableFrom(type) && !type.Name.EndsWith("Exception")) {
+				// FIXME: I18M
+				return new Resolution (this, String.Format ("Change the name of the type <code>{0}</code> so that it ends with <i>Exception</i>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class ExceptionSuffixIsExceptionRuleTest
+	{
+		class MyException : System.Exception
+		{
+		}
+		[Test]
+		public void TestCorrectException()
+		{
+			ExceptionSuffixIsExceptionRule rule = new ExceptionSuffixIsExceptionRule();
+			Assertion.AssertNull(rule.Check(typeof(MyException)));
+		}
+		
+		class MyExcpt : System.Exception
+		{
+		}
+		[Test]
+		public void TestIncorrectException()
+		{
+			ExceptionSuffixIsExceptionRule rule = new ExceptionSuffixIsExceptionRule();
+			Assertion.AssertNotNull(rule.Check(typeof(MyExcpt)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/FlagEnumerationsArePlural.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/FlagEnumerationsArePlural.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/FlagEnumerationsArePlural.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,85 +1,86 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AttributeSuffixIsAttribute.	
-	/// </summary>
-	public class FlagEnumerationsArePlural : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.FlagEnumerationsArePlural.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.FlagEnumerationsArePlural.Details}";
-			}
-		}
-		
-		public FlagEnumerationsArePlural()
-		{
-			base.certainty = 75;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (type.IsSubclassOf(typeof(System.Enum)) && type.IsDefined(typeof(System.FlagsAttribute), true)) {
-				if (!type.Name.EndsWith("s") && !type.Name.EndsWith("ae") && !type.Name.EndsWith("i")) {
- 					return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.FlagEnumerationsArePlural.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-				}
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class FlagEnumerationsArePluralTest
-	{
-		[Flags()]
-		enum CorrectFlags { a, b, c}
-		[Flags()]
-		enum CorrectNovae { Type1, Type2}
-		[Flags()]
-		enum CorrectSpaghetti { Bolognese, Napoli}
-		
-		[Test]
-		public void TestCorrectPluralEnums()
-		{
-			FlagEnumerationsArePlural elagEnumerationsArePlural = new FlagEnumerationsArePlural();
-			Assertion.AssertNull(elagEnumerationsArePlural.Check(typeof(CorrectFlags)));
-			Assertion.AssertNull(elagEnumerationsArePlural.Check(typeof(CorrectNovae)));
-			Assertion.AssertNull(elagEnumerationsArePlural.Check(typeof(CorrectSpaghetti)));
-		}
-		
-		[Flags()]
-		enum SomeFlag { Bolognese, Napoli}
-		
-		[Test]
-		public void TestIncorrectPluralEnums()
-		{
-			FlagEnumerationsArePlural elagEnumerationsArePlural = new FlagEnumerationsArePlural();
-			Assertion.AssertNotNull(elagEnumerationsArePlural.Check(typeof(SomeFlag)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of FlagEnumerationsArePlural.	
+	/// </summary>
+	public class FlagEnumerationsArePlural : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Flag enumeration names should be pluralized";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "An enumeration with the <code><a href='help://types/System.FlagsAttribute'>FlagsAttribute</a></code>  should have a plural name like in <code>Modifiers</code>.";
+			}
+		}
+		
+		public FlagEnumerationsArePlural()
+		{
+			base.certainty = 75;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (type.IsSubclassOf(typeof(System.Enum)) && type.IsDefined(typeof(System.FlagsAttribute), true)) {
+				if (!type.Name.EndsWith("s") && !type.Name.EndsWith("ae") && !type.Name.EndsWith("i")) {
+					// FIXME: I18N
+ 					return new Resolution (this, String.Format ("Change the type name of the enumeration <code>{0}</code> to plural.", type.FullName), type.FullName);
+				}
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class FlagEnumerationsArePluralTest
+	{
+		[Flags()]
+		enum CorrectFlags { a, b, c}
+		[Flags()]
+		enum CorrectNovae { Type1, Type2}
+		[Flags()]
+		enum CorrectSpaghetti { Bolognese, Napoli}
+		
+		[Test]
+		public void TestCorrectPluralEnums()
+		{
+			FlagEnumerationsArePlural elagEnumerationsArePlural = new FlagEnumerationsArePlural();
+			Assertion.AssertNull(elagEnumerationsArePlural.Check(typeof(CorrectFlags)));
+			Assertion.AssertNull(elagEnumerationsArePlural.Check(typeof(CorrectNovae)));
+			Assertion.AssertNull(elagEnumerationsArePlural.Check(typeof(CorrectSpaghetti)));
+		}
+		
+		[Flags()]
+		enum SomeFlag { Bolognese, Napoli}
+		
+		[Test]
+		public void TestIncorrectPluralEnums()
+		{
+			FlagEnumerationsArePlural elagEnumerationsArePlural = new FlagEnumerationsArePlural();
+			Assertion.AssertNotNull(elagEnumerationsArePlural.Check(typeof(SomeFlag)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/InterfacesPrefixIsI.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/InterfacesPrefixIsI.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/InterfacesPrefixIsI.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,80 +1,81 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AttributeSuffixIsAttribute.	
-	/// </summary>
-	public class InterfacesPrefixIsI : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.InterfacesPrefixIsI.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.InterfacesPrefixIsI.Details}";
-			}
-		}
-		
-		public InterfacesPrefixIsI()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (type.IsInterface && !type.Name.StartsWith("I")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.InterfacesPrefixIsI.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class InterfacesPrefixIsITest
-	{
-		interface ICorrectInterface
-		{
-		}
-		[Test]
-		public void TestCorrectAttribute()
-		{
-			InterfacesPrefixIsI interfacesPrefixIsI = new InterfacesPrefixIsI();
-			Assertion.AssertNull(interfacesPrefixIsI.Check(typeof(System.ICloneable)));
-			Assertion.AssertNull(interfacesPrefixIsI.Check(typeof(System.IComparable)));
-			Assertion.AssertNull(interfacesPrefixIsI.Check(typeof(ICorrectInterface)));
-		}
-		
-		interface WrongInterface
-		{
-		}
-		[Test]
-		public void TestIncorrectAttribute()
-		{
-			InterfacesPrefixIsI interfacesPrefixIsI = new InterfacesPrefixIsI();
-			Assertion.AssertNotNull(interfacesPrefixIsI.Check(typeof(WrongInterface)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of InterfacesPrefixIsI.	
+	/// </summary>
+	public class InterfacesPrefixIsI : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Interface names have the Prefix 'I'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "An interface name should always start with <i>I</i> like in <code>IComparable</code>.";
+			}
+		}
+		
+		public InterfacesPrefixIsI()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (type.IsInterface && !type.Name.StartsWith("I")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the name of the interface <code>{0}</code> so that it starts with <i>I</i>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class InterfacesPrefixIsITest
+	{
+		interface ICorrectInterface
+		{
+		}
+		[Test]
+		public void TestCorrectAttribute()
+		{
+			InterfacesPrefixIsI interfacesPrefixIsI = new InterfacesPrefixIsI();
+			Assertion.AssertNull(interfacesPrefixIsI.Check(typeof(System.ICloneable)));
+			Assertion.AssertNull(interfacesPrefixIsI.Check(typeof(System.IComparable)));
+			Assertion.AssertNull(interfacesPrefixIsI.Check(typeof(ICorrectInterface)));
+		}
+		
+		interface WrongInterface
+		{
+		}
+		[Test]
+		public void TestIncorrectAttribute()
+		{
+			InterfacesPrefixIsI interfacesPrefixIsI = new InterfacesPrefixIsI();
+			Assertion.AssertNotNull(interfacesPrefixIsI.Check(typeof(WrongInterface)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/MembersArePascalCased.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/MembersArePascalCased.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/MembersArePascalCased.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,59 +1,56 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AttributeSuffixIsAttribute.	
-	/// </summary>
-	public class MembersArePascalCased : AbstractReflectionRule, IMemberRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.MembersArePascalCased.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.MembersArePascalCased.Details}";
-			}
-		}
-		
-		public MembersArePascalCased()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(Module module, MemberInfo member)
-		{
-			if (member is FieldInfo || member is ConstructorInfo) {
-				return null;
-			}
-			if (member is MethodInfo) {
-				MethodInfo mi = (MethodInfo)member;
-				if (mi.IsSpecialName) {
-					return null;
-				}
-			}
-			
-			if (!NamingUtilities.IsPascalCase(member.Name)) {
-				return new Resolution(this, 
-				                      "${res:MonoDevelop.AssemblyAnalyser.Rules.MembersArePascalCased.Resolution}",
-				                      NamingUtilities.Combine(member.DeclaringType.FullName, member.Name),
-				                      new string[,] { 
-				                      	{"MemberName", member.Name}, 
-				                      	{"DeclaringType", member.DeclaringType.FullName}, 
-				                      	{"AlternateName", NamingUtilities.PascalCase(member.Name)}});
-			}
-			return null;
-		}
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of MembersArePascalCased.	
+	/// </summary>
+	public class MembersArePascalCased : AbstractReflectionRule, IMemberRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Member names should be pascal cased";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Pascal casing capitalized the first letter like in <code><b>W</b>riteLine</code>. Use pascal casing for all public identifiers that consist of compound words.";
+			}
+		}
+		
+		public MembersArePascalCased()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(Module module, MemberInfo member)
+		{
+			if (member is FieldInfo || member is ConstructorInfo) {
+				return null;
+			}
+			if (member is MethodInfo) {
+				MethodInfo mi = (MethodInfo)member;
+				if (mi.IsSpecialName) {
+					return null;
+				}
+			}
+			
+			if (!NamingUtilities.IsPascalCase(member.Name)) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Use pascal casing for <code>{0}</code> in <code>{1}</code>.<BR>For example : <code>${2}</code>.", member.Name, member.DeclaringType, NamingUtilities.PascalCase (member.Name)), NamingUtilities.Combine(member.DeclaringType.FullName, member.Name));
+			}
+			return null;
+		}
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/MembersDoNotContainUnderscores.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/MembersDoNotContainUnderscores.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/MembersDoNotContainUnderscores.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,54 +1,57 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AttributeSuffixIsAttribute.	
-	/// </summary>
-	public class MembersDoNotContainUnderscores : AbstractReflectionRule, IMemberRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.MembersDoNotContainUnderscores.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.MembersDoNotContainUnderscores.Details}";
-			}
-		}
-		
-		public MembersDoNotContainUnderscores()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(Module module, MemberInfo member)
-		{
-			if (member is FieldInfo || member is ConstructorInfo) {
-				return null;
-			}
-			if (member is MethodInfo) {
-				MethodInfo mi = (MethodInfo)member;
-				if (mi.IsSpecialName) {
-					return null;
-				}
-			}
-			
-			if (NamingUtilities.ContainsUnderscore(member.Name)) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.MembersDoNotContainUnderscores.Resolution}", NamingUtilities.Combine(member.ReflectedType.FullName, member.Name), new string[,] { {"MemberName", member.Name}, {"DeclaringType", member.DeclaringType.FullName} });
-			}
-			
-			return null;
-		}
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of MembersDoNotContainUnderscores.	
+	/// </summary>
+	public class MembersDoNotContainUnderscores : AbstractReflectionRule, IMemberRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Member names do not contain underscores '_'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Underscores should never be used inside public members.";
+			}
+		}
+		
+		public MembersDoNotContainUnderscores()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(Module module, MemberInfo member)
+		{
+			if (member is FieldInfo || member is ConstructorInfo) {
+				return null;
+			}
+			if (member is MethodInfo) {
+				MethodInfo mi = (MethodInfo)member;
+				if (mi.IsSpecialName) {
+					return null;
+				}
+			}
+			
+			if (NamingUtilities.ContainsUnderscore(member.Name)) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Remove all underscores in member name <code>{0}</code> in the type <code>{1}</code>.", member.Name, member.DeclaringType.FullName), NamingUtilities.Combine(member.ReflectedType.FullName, member.Name));
+			}
+			
+			return null;
+		}
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/MembershipConditionNamesSuffixIsMembershipCondition.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/MembershipConditionNamesSuffixIsMembershipCondition.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/MembershipConditionNamesSuffixIsMembershipCondition.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,112 +1,113 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AttributeSuffixIsAttribute.	
-	/// </summary>
-	public class MembershipConditionNamesSuffixIsMembershipCondition : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.MembershipConditionNamesSuffixIsMembershipCondition.Description}";
-			}
-		}
-		
-		// System.Attribute
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.MembershipConditionNamesSuffixIsMembershipCondition.Details}";
-			}
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (typeof(System.Security.Policy.IMembershipCondition).IsAssignableFrom(type) && !type.Name.EndsWith("MembershipCondition")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.MembershipConditionNamesSuffixIsMembershipCondition.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class MembershipConditionNamesSuffixIsMembershipConditionTest
-	{
-		class MyClass 
-		{
-		}
-		[Test]
-		public void TestCorrectMembershipCondition()
-		{
-			MembershipConditionNamesSuffixIsMembershipCondition membershipConditionNamesSuffixIsMembershipCondition = new MembershipConditionNamesSuffixIsMembershipCondition();
-			Assertion.AssertNull(membershipConditionNamesSuffixIsMembershipCondition.Check(typeof(System.Security.Policy.AllMembershipCondition)));
-			Assertion.AssertNull(membershipConditionNamesSuffixIsMembershipCondition.Check(typeof(System.Security.Policy.ZoneMembershipCondition)));
-			Assertion.AssertNull(membershipConditionNamesSuffixIsMembershipCondition.Check(typeof(MyClass)));
-		}
-		
-		class MyClass2 : System.Security.Policy.IMembershipCondition
-		{
-			#region System.Security.ISecurityEncodable interface implementation
-			public void FromXml(System.Security.SecurityElement e)
-			{
-				
-			}
-			
-			public System.Security.SecurityElement ToXml()
-			{
-				return null;
-			}
-			#endregion
-			
-			#region System.Security.ISecurityPolicyEncodable interface implementation
-			public void FromXml(System.Security.SecurityElement e, System.Security.Policy.PolicyLevel level)
-			{
-				
-			}
-			
-			public System.Security.SecurityElement ToXml(System.Security.Policy.PolicyLevel level)
-			{
-				return null;
-			}
-			#endregion
-			
-			#region System.Security.Policy.IMembershipCondition interface implementation
-			public System.Security.Policy.IMembershipCondition Copy()
-			{
-				return null;
-			}
-			
-			public bool Check(System.Security.Policy.Evidence evidence)
-			{
-				return false;
-			}
-			#endregion
-		}
-		
-		[Test]
-		public void TestIncorrectAttribute()
-		{
-			MembershipConditionNamesSuffixIsMembershipCondition membershipConditionNamesSuffixIsMembershipCondition = new MembershipConditionNamesSuffixIsMembershipCondition();
-			Assertion.AssertNotNull(membershipConditionNamesSuffixIsMembershipCondition.Check(typeof(MyClass2)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of MembershipConditionNamesSuffixIsMembershipCondition
+	/// </summary>
+	public class MembershipConditionNamesSuffixIsMembershipCondition : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "MembershipCondition names have the suffix 'MembershipCondition'";
+			}
+		}
+		
+		// System.Attribute
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return " A type that implements <code><a href='help://types/System.Security.Policy.IMembershipCondition'>IMembershipCondition</a></code> is a condition and its name should always end with <i>MembershipCondition</i> like in <code>UrlMembershipCondition</code>.";
+			}
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (typeof(System.Security.Policy.IMembershipCondition).IsAssignableFrom(type) && !type.Name.EndsWith("MembershipCondition")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the name of the type <code>{0}</code> so that it ends with <I>MembershipCondition</I>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class MembershipConditionNamesSuffixIsMembershipConditionTest
+	{
+		class MyClass 
+		{
+		}
+		[Test]
+		public void TestCorrectMembershipCondition()
+		{
+			MembershipConditionNamesSuffixIsMembershipCondition membershipConditionNamesSuffixIsMembershipCondition = new MembershipConditionNamesSuffixIsMembershipCondition();
+			Assertion.AssertNull(membershipConditionNamesSuffixIsMembershipCondition.Check(typeof(System.Security.Policy.AllMembershipCondition)));
+			Assertion.AssertNull(membershipConditionNamesSuffixIsMembershipCondition.Check(typeof(System.Security.Policy.ZoneMembershipCondition)));
+			Assertion.AssertNull(membershipConditionNamesSuffixIsMembershipCondition.Check(typeof(MyClass)));
+		}
+		
+		class MyClass2 : System.Security.Policy.IMembershipCondition
+		{
+			#region System.Security.ISecurityEncodable interface implementation
+			public void FromXml(System.Security.SecurityElement e)
+			{
+				
+			}
+			
+			public System.Security.SecurityElement ToXml()
+			{
+				return null;
+			}
+			#endregion
+			
+			#region System.Security.ISecurityPolicyEncodable interface implementation
+			public void FromXml(System.Security.SecurityElement e, System.Security.Policy.PolicyLevel level)
+			{
+				
+			}
+			
+			public System.Security.SecurityElement ToXml(System.Security.Policy.PolicyLevel level)
+			{
+				return null;
+			}
+			#endregion
+			
+			#region System.Security.Policy.IMembershipCondition interface implementation
+			public System.Security.Policy.IMembershipCondition Copy()
+			{
+				return null;
+			}
+			
+			public bool Check(System.Security.Policy.Evidence evidence)
+			{
+				return false;
+			}
+			#endregion
+		}
+		
+		[Test]
+		public void TestIncorrectAttribute()
+		{
+			MembershipConditionNamesSuffixIsMembershipCondition membershipConditionNamesSuffixIsMembershipCondition = new MembershipConditionNamesSuffixIsMembershipCondition();
+			Assertion.AssertNotNull(membershipConditionNamesSuffixIsMembershipCondition.Check(typeof(MyClass2)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/NamespacesArePascalCased.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/NamespacesArePascalCased.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/NamespacesArePascalCased.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,81 +1,82 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Collections;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of NamespacesArePascalCased.	
-	/// </summary>
-	public class NamespacesArePascalCased : AbstractReflectionRule, INamespaceRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.NamespacesArePascalCased.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.NamespacesArePascalCased.Details}";
-			}
-		}
-		
-		public NamespacesArePascalCased()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(string namespaceName, ICollection types)
-		{
-			string[] namespaces = namespaceName.Split('.');
-			foreach (string name in namespaces) {
-				if (!NamingUtilities.IsPascalCase(name)) {
-					for (int i = 0; i < namespaces.Length; ++i) {
-						namespaces[i] = NamingUtilities.PascalCase(namespaces[i]);
-					}
-					return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.NamespacesArePascalCased.Resolution}", namespaceName, new string[,]{{"NamespaceName", namespaceName}, {"AlternateName", String.Join(".", namespaces) }});
-				}
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class NamespacesArePascalCasedTest
-	{
-		[Test]
-		public void TestCorrectNamespaces()
-		{
-			NamespacesArePascalCased namespacesArePascalCased = new NamespacesArePascalCased();
-			Assertion.AssertNull("Empty Namespace", namespacesArePascalCased.Check("", null));
-			Assertion.AssertNull("Single Namespace", namespacesArePascalCased.Check("MyNamespace", null));
-			Assertion.AssertNull("Complex Namespace", namespacesArePascalCased.Check("System.Windows.Form", null));
-		}
-		
-		[Test]
-		public void TestIncorrectAttribute()
-		{
-			NamespacesArePascalCased namespacesArePascalCased = new NamespacesArePascalCased();
-			Assertion.AssertNotNull(namespacesArePascalCased.Check("a", null));
-			Assertion.AssertNotNull(namespacesArePascalCased.Check("A.Namespace.isWrong", null));
-			Assertion.AssertNotNull(namespacesArePascalCased.Check("System.windows.Form", null));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Collections;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of NamespacesArePascalCased.	
+	/// </summary>
+	public class NamespacesArePascalCased : AbstractReflectionRule, INamespaceRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Namespace names should be pascal cased";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Pascal casing capitalized the first letter like in <code><b>S</b>ystem.<b>C</b>omponentModel.<b>D</b>esign</code>. Use pascal casing for all namespaces.";
+			}
+		}
+		
+		public NamespacesArePascalCased()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(string namespaceName, ICollection types)
+		{
+			string[] namespaces = namespaceName.Split('.');
+			foreach (string name in namespaces) {
+				if (!NamingUtilities.IsPascalCase(name)) {
+					for (int i = 0; i < namespaces.Length; ++i) {
+						namespaces[i] = NamingUtilities.PascalCase(namespaces[i]);
+					}
+					// FIXME: I18N
+					return new Resolution (this, String.Format ("Use pascal casing for the namespace <code>{0}</code>.<BR>For example: <code>{1}</code>.", namespaceName, String.Join (".", namespaces)), namespaceName);
+				}
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class NamespacesArePascalCasedTest
+	{
+		[Test]
+		public void TestCorrectNamespaces()
+		{
+			NamespacesArePascalCased namespacesArePascalCased = new NamespacesArePascalCased();
+			Assertion.AssertNull("Empty Namespace", namespacesArePascalCased.Check("", null));
+			Assertion.AssertNull("Single Namespace", namespacesArePascalCased.Check("MyNamespace", null));
+			Assertion.AssertNull("Complex Namespace", namespacesArePascalCased.Check("System.Windows.Form", null));
+		}
+		
+		[Test]
+		public void TestIncorrectAttribute()
+		{
+			NamespacesArePascalCased namespacesArePascalCased = new NamespacesArePascalCased();
+			Assertion.AssertNotNull(namespacesArePascalCased.Check("a", null));
+			Assertion.AssertNotNull(namespacesArePascalCased.Check("A.Namespace.isWrong", null));
+			Assertion.AssertNotNull(namespacesArePascalCased.Check("System.windows.Form", null));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/NamespacesDoNotContainUnderscores.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/NamespacesDoNotContainUnderscores.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/NamespacesDoNotContainUnderscores.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,75 +1,76 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Collections;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of NamespacesArePascalCased.	
-	/// </summary>
-	public class NamespacesDoNotContainUnderscores : AbstractReflectionRule, INamespaceRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.NamespacesDoNotContainUnderscores.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.NamespacesDoNotContainUnderscores.Details}";
-			}
-		}
-		
-		public NamespacesDoNotContainUnderscores()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(string namespaceName, ICollection types)
-		{
-			if (NamingUtilities.ContainsUnderscore(namespaceName)) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.NamespacesDoNotContainUnderscores.Resolution}", namespaceName, new string[,]{{"NamespaceName", namespaceName}});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class NamespacesDoNotContainUnderscoresTest
-	{
-		[Test]
-		public void TestCorrectNamespaces()
-		{
-			NamespacesDoNotContainUnderscores rule = new NamespacesDoNotContainUnderscores();
-			Assertion.AssertNull("Empty Namespace", rule.Check("", null));
-			Assertion.AssertNull("Single Namespace", rule.Check("MyNamespace", null));
-			Assertion.AssertNull("Complex Namespace", rule.Check("System.Windows.Form", null));
-		}
-		
-		[Test]
-		public void TestIncorrectNamespaces()
-		{
-			NamespacesDoNotContainUnderscores rule = new NamespacesDoNotContainUnderscores();
-			Assertion.AssertNotNull(rule.Check("_", null));
-			Assertion.AssertNotNull(rule.Check("A.Namespace.isWrong_", null));
-			Assertion.AssertNotNull(rule.Check("System._Windows.Form", null));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Collections;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of NamespacesDoNotContainUnderScores
+	/// </summary>
+	public class NamespacesDoNotContainUnderscores : AbstractReflectionRule, INamespaceRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Namespace names do not contain underscores '_'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Underscores should never be used inside namespace names.";
+			}
+		}
+		
+		public NamespacesDoNotContainUnderscores()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(string namespaceName, ICollection types)
+		{
+			if (NamingUtilities.ContainsUnderscore(namespaceName)) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Remove all underscores in namespace <code>{0}</code>.", namespaceName), namespaceName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class NamespacesDoNotContainUnderscoresTest
+	{
+		[Test]
+		public void TestCorrectNamespaces()
+		{
+			NamespacesDoNotContainUnderscores rule = new NamespacesDoNotContainUnderscores();
+			Assertion.AssertNull("Empty Namespace", rule.Check("", null));
+			Assertion.AssertNull("Single Namespace", rule.Check("MyNamespace", null));
+			Assertion.AssertNull("Complex Namespace", rule.Check("System.Windows.Form", null));
+		}
+		
+		[Test]
+		public void TestIncorrectNamespaces()
+		{
+			NamespacesDoNotContainUnderscores rule = new NamespacesDoNotContainUnderscores();
+			Assertion.AssertNotNull(rule.Check("_", null));
+			Assertion.AssertNotNull(rule.Check("A.Namespace.isWrong_", null));
+			Assertion.AssertNotNull(rule.Check("System._Windows.Form", null));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyAttributesSuffixAttributeRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyAttributesSuffixAttributeRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyAttributesSuffixAttributeRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,82 +1,83 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of OnlyAttributesSuffixAttribute.	
-	/// </summary>
-	public class OnlyAttributesSuffixAttributeRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyAttributesSuffixAttribute.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyAttributesSuffixAttribute.Details}";
-			}
-		}
-		
-		public OnlyAttributesSuffixAttributeRule()
-		{
-			base.certainty = 99;
-			base.priorityLevel = PriorityLevel.CriticalError;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (!type.IsSubclassOf(typeof(System.Attribute)) && type.Name.EndsWith("Attribute")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyAttributesSuffixAttribute.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class OnlyAttributesSuffixAttributeTest
-	{
-		class MyOtherClass
-		{
-		}
-		class RealAttribute : System.Attribute
-		{
-		}
-		[Test]
-		public void TestCorrectAttribute()
-		{
-			OnlyAttributesSuffixAttributeRule rule = new OnlyAttributesSuffixAttributeRule();
-			Assertion.AssertNull(rule.Check(typeof(MyOtherClass)));
-			Assertion.AssertNull(rule.Check(typeof(RealAttribute)));
-		}
-		
-		class MyAttribute
-		{
-		}
-		[Test]
-		public void TestIncorrectAttribute()
-		{
-			OnlyAttributesSuffixAttributeRule rule = new OnlyAttributesSuffixAttributeRule();
-			Assertion.AssertNotNull(rule.Check(typeof(MyAttribute)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of OnlyAttributesSuffixAttribute.	
+	/// </summary>
+	public class OnlyAttributesSuffixAttributeRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Only attribute names have the suffix 'Attribute'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type that does not extend from <code><a href='help://types/System.Attribute'>Attribute</a></code> should never have the suffix <i>Attribute</i>.";
+			}
+		}
+		
+		public OnlyAttributesSuffixAttributeRule()
+		{
+			base.certainty = 99;
+			base.priorityLevel = PriorityLevel.CriticalError;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (!type.IsSubclassOf(typeof(System.Attribute)) && type.Name.EndsWith("Attribute")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the name of the type <code>{0}</code> so that it does not end with <i>Attribute</i>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class OnlyAttributesSuffixAttributeTest
+	{
+		class MyOtherClass
+		{
+		}
+		class RealAttribute : System.Attribute
+		{
+		}
+		[Test]
+		public void TestCorrectAttribute()
+		{
+			OnlyAttributesSuffixAttributeRule rule = new OnlyAttributesSuffixAttributeRule();
+			Assertion.AssertNull(rule.Check(typeof(MyOtherClass)));
+			Assertion.AssertNull(rule.Check(typeof(RealAttribute)));
+		}
+		
+		class MyAttribute
+		{
+		}
+		[Test]
+		public void TestIncorrectAttribute()
+		{
+			OnlyAttributesSuffixAttributeRule rule = new OnlyAttributesSuffixAttributeRule();
+			Assertion.AssertNotNull(rule.Check(typeof(MyAttribute)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyCollectionsSuffixCollectionRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyCollectionsSuffixCollectionRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyCollectionsSuffixCollectionRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,135 +1,136 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Collections;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of CheckCollectionSuffix.	
-	/// </summary>
-	public class OnlyCollectionsSuffixCollectionRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyCollectionsSuffixCollection.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyCollectionsSuffixCollection.Details}";
-			}
-		}
-		
-		public OnlyCollectionsSuffixCollectionRule()
-		{
-			base.certainty = 99;
-			base.priorityLevel = PriorityLevel.CriticalError;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (!typeof(ICollection).IsAssignableFrom(type) && !typeof(IEnumerable).IsAssignableFrom(type)) {
-				if (!typeof(Queue).IsAssignableFrom(type) && type.Name.EndsWith("Queue")) {
-					return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyCollectionsSuffixCollection.Resolution1}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-				} else if (!typeof(Stack).IsAssignableFrom(type) && type.Name.EndsWith("Stack")) {
-					return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyCollectionsSuffixCollection.Resolution2}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-				} else if (type.Name.EndsWith("Collection")) {
-					return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyCollectionsSuffixCollection.Resolution3}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-				}
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class OnlyCollectionsSuffixCollectionRuleTest
-	{
-		#region Collection suffix tests
-		class MyCollection : System.Collections.ArrayList
-		{
-		}
-		class OtherClass 
-		{
-		}
-		[Test]
-		public void TestCorrectCollection()
-		{
-			OnlyCollectionsSuffixCollectionRule rule = new OnlyCollectionsSuffixCollectionRule();
-			Assertion.AssertNull(rule.Check(typeof(MyCollection)));
-			Assertion.AssertNull(rule.Check(typeof(OtherClass)));
-		}
-		
-		class My2Collection
-		{
-		}
-		[Test]
-		public void TestIncorrectCollection()
-		{
-			OnlyCollectionsSuffixCollectionRule rule = new OnlyCollectionsSuffixCollectionRule();
-			Assertion.AssertNotNull(rule.Check(typeof(My2Collection)));
-		}
-		#endregion
-		
-		#region Queue suffix tests
-		class MyQueue : System.Collections.Queue
-		{
-		}
-		[Test]
-		public void TestCorrectQueue()
-		{
-			OnlyCollectionsSuffixCollectionRule rule = new OnlyCollectionsSuffixCollectionRule();
-			Assertion.AssertNull(rule.Check(typeof(MyQueue)));
-		}
-		
-		class My2Queue
-		{
-		}
-		[Test]
-		public void TestIncorrectQueue()
-		{
-			OnlyCollectionsSuffixCollectionRule rule = new OnlyCollectionsSuffixCollectionRule();
-			Assertion.AssertNotNull(rule.Check(typeof(My2Queue)));
-		}
-		#endregion 
-		
-		#region Stack suffix tests
-		class MyStack : System.Collections.Stack
-		{
-		}
-		[Test]
-		public void TestCorrectStack()
-		{
-			OnlyCollectionsSuffixCollectionRule rule = new OnlyCollectionsSuffixCollectionRule();
-			Assertion.AssertNull(rule.Check(typeof(MyStack)));
-		}
-		
-		class My2Stack
-		{
-		}
-		[Test]
-		public void TestIncorrectStack()
-		{
-			OnlyCollectionsSuffixCollectionRule rule = new OnlyCollectionsSuffixCollectionRule();
-			Assertion.AssertNotNull(rule.Check(typeof(My2Stack)));
-		}
-		#endregion
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Collections;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of OnlyCollectionsSuffixCollectionRule.	
+	/// </summary>
+	public class OnlyCollectionsSuffixCollectionRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Only collection names should have the suffix 'Collection', 'Queue' or 'Stack'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type that does not implement <code><a href='help://types/System.Collections.ICollection'>ICollection</a></code> or <code><a href='help://types/System.Collections.IEnumerable'>IEnumerable</a></code> should never have the suffix <i>Collection</i>.<BR>A type that doesn't extend <code><a href='help://types/System.Collections.Queue'>Queue</a></code> should never have the suffix <i>Queue</i> and a type that doesn't extend <code><a href='help://types/System.Collections.Stack'>Stack</a></code> should never have a <i>Stack</i> suffix.";
+			}
+		}
+		
+		public OnlyCollectionsSuffixCollectionRule()
+		{
+			base.certainty = 99;
+			base.priorityLevel = PriorityLevel.CriticalError;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (!typeof(ICollection).IsAssignableFrom(type) && !typeof(IEnumerable).IsAssignableFrom(type)) {
+				// FIXME: I18N
+				if (!typeof(Queue).IsAssignableFrom(type) && type.Name.EndsWith("Queue")) {
+					return new Resolution (this, String.Format ("Change the name of <code>{0}</code> so that it does not end with <i>Queue</i>.", type.FullName), type.FullName);
+				} else if (!typeof(Stack).IsAssignableFrom(type) && type.Name.EndsWith("Stack")) {
+					return new Resolution (this, String.Format ("Change the name of <code>{0}</code> so that it does not end with <i>Stack</i>.", type.FullName), type.FullName);
+				} else if (type.Name.EndsWith("Collection")) {
+					return new Resolution (this, String.Format ("Change the name of <code>{0}</code> so that it does not end with <i>Collection</i>.", type.FullName), type.FullName);
+				}
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class OnlyCollectionsSuffixCollectionRuleTest
+	{
+		#region Collection suffix tests
+		class MyCollection : System.Collections.ArrayList
+		{
+		}
+		class OtherClass 
+		{
+		}
+		[Test]
+		public void TestCorrectCollection()
+		{
+			OnlyCollectionsSuffixCollectionRule rule = new OnlyCollectionsSuffixCollectionRule();
+			Assertion.AssertNull(rule.Check(typeof(MyCollection)));
+			Assertion.AssertNull(rule.Check(typeof(OtherClass)));
+		}
+		
+		class My2Collection
+		{
+		}
+		[Test]
+		public void TestIncorrectCollection()
+		{
+			OnlyCollectionsSuffixCollectionRule rule = new OnlyCollectionsSuffixCollectionRule();
+			Assertion.AssertNotNull(rule.Check(typeof(My2Collection)));
+		}
+		#endregion
+		
+		#region Queue suffix tests
+		class MyQueue : System.Collections.Queue
+		{
+		}
+		[Test]
+		public void TestCorrectQueue()
+		{
+			OnlyCollectionsSuffixCollectionRule rule = new OnlyCollectionsSuffixCollectionRule();
+			Assertion.AssertNull(rule.Check(typeof(MyQueue)));
+		}
+		
+		class My2Queue
+		{
+		}
+		[Test]
+		public void TestIncorrectQueue()
+		{
+			OnlyCollectionsSuffixCollectionRule rule = new OnlyCollectionsSuffixCollectionRule();
+			Assertion.AssertNotNull(rule.Check(typeof(My2Queue)));
+		}
+		#endregion 
+		
+		#region Stack suffix tests
+		class MyStack : System.Collections.Stack
+		{
+		}
+		[Test]
+		public void TestCorrectStack()
+		{
+			OnlyCollectionsSuffixCollectionRule rule = new OnlyCollectionsSuffixCollectionRule();
+			Assertion.AssertNull(rule.Check(typeof(MyStack)));
+		}
+		
+		class My2Stack
+		{
+		}
+		[Test]
+		public void TestIncorrectStack()
+		{
+			OnlyCollectionsSuffixCollectionRule rule = new OnlyCollectionsSuffixCollectionRule();
+			Assertion.AssertNotNull(rule.Check(typeof(My2Stack)));
+		}
+		#endregion
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyEventArgsSuffixEventArgsRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyEventArgsSuffixEventArgsRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyEventArgsSuffixEventArgsRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,87 +1,88 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of OnlyEventArgsSuffixEventArgsRule.	
-	/// </summary>
-	public class OnlyEventArgsSuffixEventArgsRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyEventArgsSuffixEventArgs.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyEventArgsSuffixEventArgs.Details}";
-			}
-		}
-		
-		public OnlyEventArgsSuffixEventArgsRule()
-		{
-			base.certainty = 99;
-			base.priorityLevel = PriorityLevel.CriticalError;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (!typeof(System.EventArgs).IsAssignableFrom(type) && type.Name.EndsWith("EventArgs")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyEventArgsSuffixEventArgs.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class OnlyEventArgsSuffixEventArgsRuleTest
-	{
-		class CorrectEventArgs : System.EventArgs
-		{
-		}
-		class OtherClass
-		{
-		}
-		class MyEventArgs : CorrectEventArgs
-		{
-		}
-		[Test]
-		public void TestCorrectEventArgs()
-		{
-			OnlyEventArgsSuffixEventArgsRule rule = new OnlyEventArgsSuffixEventArgsRule();
-			Assertion.AssertNull(rule.Check(typeof(CorrectEventArgs)));
-			Assertion.AssertNull(rule.Check(typeof(OtherClass)));
-			Assertion.AssertNull(rule.Check(typeof(MyEventArgs)));
-		}
-		
-		class IncorrectEventArgs
-		{
-		}
-		[Test]
-		public void TestIncorrectEventArgs()
-		{
-			OnlyEventArgsSuffixEventArgsRule rule = new OnlyEventArgsSuffixEventArgsRule();
-			Assertion.AssertNotNull(rule.Check(typeof(IncorrectEventArgs)));
-		}
-		
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of OnlyEventArgsSuffixEventArgsRule.	
+	/// </summary>
+	public class OnlyEventArgsSuffixEventArgsRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Only event argument names have the suffix 'EventArgs'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type that does not extend from <code><a href='help://types/System.EventArgs'>EventArgs</a></code> should never have the suffix <i>EventArgs</i>.";
+			}
+		}
+		
+		public OnlyEventArgsSuffixEventArgsRule()
+		{
+			base.certainty = 99;
+			base.priorityLevel = PriorityLevel.CriticalError;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (!typeof(System.EventArgs).IsAssignableFrom(type) && type.Name.EndsWith("EventArgs")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the name of the type <code>{0}</code> so that it does not end with <i>EventArgs</i>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class OnlyEventArgsSuffixEventArgsRuleTest
+	{
+		class CorrectEventArgs : System.EventArgs
+		{
+		}
+		class OtherClass
+		{
+		}
+		class MyEventArgs : CorrectEventArgs
+		{
+		}
+		[Test]
+		public void TestCorrectEventArgs()
+		{
+			OnlyEventArgsSuffixEventArgsRule rule = new OnlyEventArgsSuffixEventArgsRule();
+			Assertion.AssertNull(rule.Check(typeof(CorrectEventArgs)));
+			Assertion.AssertNull(rule.Check(typeof(OtherClass)));
+			Assertion.AssertNull(rule.Check(typeof(MyEventArgs)));
+		}
+		
+		class IncorrectEventArgs
+		{
+		}
+		[Test]
+		public void TestIncorrectEventArgs()
+		{
+			OnlyEventArgsSuffixEventArgsRule rule = new OnlyEventArgsSuffixEventArgsRule();
+			Assertion.AssertNotNull(rule.Check(typeof(IncorrectEventArgs)));
+		}
+		
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyEventHandlerSuffixIsEventHandlerRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyEventHandlerSuffixIsEventHandlerRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyEventHandlerSuffixIsEventHandlerRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,50 +1,53 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of OnlyEventHandlerSuffixIsEventHandlerRule.	
-	/// </summary>
-	public class OnlyEventHandlerSuffixIsEventHandlerRule : AbstractReflectionRule, IMemberRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyEventHandlerSuffixIsEventHandler.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyEventHandlerSuffixIsEventHandler.Details}";
-			}
-		}
-		
-		public OnlyEventHandlerSuffixIsEventHandlerRule()
-		{
-			base.certainty = 99;
-			base.priorityLevel = PriorityLevel.CriticalError;
-		}
-		
-		public Resolution Check(Module module, MemberInfo member)
-		{
-			if (member is MethodInfo) {
-				MethodInfo mi = (MethodInfo)member;
-				if (mi.IsSpecialName) {
-					return null;
-				}
-			}
-			if (member.Name.EndsWith("EventHandler")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyEventHandlerSuffixIsEventHandler.Resolution}", NamingUtilities.Combine(member.ReflectedType.FullName, member.Name), new string[,] { {"MemberName", member.Name}, {"DeclaringType", member.DeclaringType.FullName} });
-			}
-			return null;
-		}
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of OnlyEventHandlerSuffixIsEventHandlerRule.	
+	/// </summary>
+	public class OnlyEventHandlerSuffixIsEventHandlerRule : AbstractReflectionRule, IMemberRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Only event handler names have the suffix 'EventHandler'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Only delegates that get used in events have the suffix <i>EventHandler</i>.";
+			}
+		}
+		
+		public OnlyEventHandlerSuffixIsEventHandlerRule()
+		{
+			base.certainty = 99;
+			base.priorityLevel = PriorityLevel.CriticalError;
+		}
+		
+		public Resolution Check(Module module, MemberInfo member)
+		{
+			if (member is MethodInfo) {
+				MethodInfo mi = (MethodInfo)member;
+				if (mi.IsSpecialName) {
+					return null;
+				}
+			}
+			if (member.Name.EndsWith("EventHandler")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("", member.Name, member.DeclaringType.FullName), NamingUtilities.Combine (member.ReflectedType.FullName, member.Name));
+			}
+			return null;
+		}
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyExceptionsSuffixExceptionRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyExceptionsSuffixExceptionRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyExceptionsSuffixExceptionRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,82 +1,83 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of OnlyExceptionsSuffixExceptionRule.	
-	/// </summary>
-	public class OnlyExceptionsSuffixExceptionRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyExceptionsSuffixException.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyExceptionsSuffixException.Details}";
-			}
-		}
-		
-		public OnlyExceptionsSuffixExceptionRule()
-		{
-			base.certainty = 99;
-			base.priorityLevel = PriorityLevel.CriticalError;
-		}
-		
-		
-		public Resolution Check(Type type)
-		{
-			if (!typeof(System.Exception).IsAssignableFrom(type) && type.Name.EndsWith("Exception")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyExceptionsSuffixException.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class OnlyExceptionsSuffixExceptionRuleTest
-	{
-		class MyException : System.Exception
-		{
-		}
-		class OtherClass
-		{}
-		[Test]
-		public void TestCorrectException()
-		{
-			OnlyExceptionsSuffixExceptionRule rule = new OnlyExceptionsSuffixExceptionRule();
-			Assertion.AssertNull(rule.Check(typeof(MyException)));
-			Assertion.AssertNull(rule.Check(typeof(OtherClass)));
-		}
-		
-		class NotAnException
-		{
-		}
-		[Test]
-		public void TestIncorrectException()
-		{
-			OnlyExceptionsSuffixExceptionRule rule = new OnlyExceptionsSuffixExceptionRule();
-			Assertion.AssertNotNull(rule.Check(typeof(NotAnException)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of OnlyExceptionsSuffixExceptionRule.	
+	/// </summary>
+	public class OnlyExceptionsSuffixExceptionRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Only exception names have the suffix 'Exception'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type that does not extend from <code><a href='help://types/System.Exception'>Exception</a></code> should never have the suffix <i>Exception</i>.";
+			}
+		}
+		
+		public OnlyExceptionsSuffixExceptionRule()
+		{
+			base.certainty = 99;
+			base.priorityLevel = PriorityLevel.CriticalError;
+		}
+		
+		
+		public Resolution Check(Type type)
+		{
+			if (!typeof(System.Exception).IsAssignableFrom(type) && type.Name.EndsWith("Exception")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the name of the type <code>{0}</code> so that it doesn't end with <i>Exception</i>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class OnlyExceptionsSuffixExceptionRuleTest
+	{
+		class MyException : System.Exception
+		{
+		}
+		class OtherClass
+		{}
+		[Test]
+		public void TestCorrectException()
+		{
+			OnlyExceptionsSuffixExceptionRule rule = new OnlyExceptionsSuffixExceptionRule();
+			Assertion.AssertNull(rule.Check(typeof(MyException)));
+			Assertion.AssertNull(rule.Check(typeof(OtherClass)));
+		}
+		
+		class NotAnException
+		{
+		}
+		[Test]
+		public void TestIncorrectException()
+		{
+			OnlyExceptionsSuffixExceptionRule rule = new OnlyExceptionsSuffixExceptionRule();
+			Assertion.AssertNotNull(rule.Check(typeof(NotAnException)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyPermissionsSuffixPermissionRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyPermissionsSuffixPermissionRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyPermissionsSuffixPermissionRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,79 +1,80 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of OnlyExceptionsSuffixException.	
-	/// </summary>
-	public class OnlyPermissionsSuffixPermissionRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyPermissionsSuffixPermission.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyPermissionsSuffixPermission.Details}";
-			}
-		}
-		
-		public OnlyPermissionsSuffixPermissionRule()
-		{
-			base.certainty = 99;
-			base.priorityLevel = PriorityLevel.CriticalError;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (!typeof(System.Security.IPermission).IsAssignableFrom(type) && type.Name.EndsWith("Permission")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyPermissionsSuffixPermission.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class OnlyPermissionsSuffixPermissionRuleTest
-	{
-		class OtherClass
-		{}
-		[Test]
-		public void TestCorrectPermission()
-		{
-			OnlyPermissionsSuffixPermissionRule rule = new OnlyPermissionsSuffixPermissionRule();
-			Assertion.AssertNull(rule.Check(typeof(System.Security.Permissions.EnvironmentPermission)));
-			Assertion.AssertNull(rule.Check(typeof(System.Security.Permissions.FileIOPermission)));
-			Assertion.AssertNull(rule.Check(typeof(OtherClass)));
-		}
-		
-		class NotAnPermission
-		{
-		}
-		[Test]
-		public void TestIncorrectPermission()
-		{
-			OnlyPermissionsSuffixPermissionRule rule = new OnlyPermissionsSuffixPermissionRule();
-			Assertion.AssertNotNull(rule.Check(typeof(NotAnPermission)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of OnlyPermissionSuffixPermissionRule.	
+	/// </summary>
+	public class OnlyPermissionsSuffixPermissionRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Only permission names have the suffix 'Permission'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type that does not implement <code><a href='help://types/System.Security.IPermission'>IPermission</a></code> should never have the suffix <i>Permission</i>.";
+			}
+		}
+		
+		public OnlyPermissionsSuffixPermissionRule()
+		{
+			base.certainty = 99;
+			base.priorityLevel = PriorityLevel.CriticalError;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (!typeof(System.Security.IPermission).IsAssignableFrom(type) && type.Name.EndsWith("Permission")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the name of the type <code>{0}</code> so that it does not end with <i>Permission</i>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class OnlyPermissionsSuffixPermissionRuleTest
+	{
+		class OtherClass
+		{}
+		[Test]
+		public void TestCorrectPermission()
+		{
+			OnlyPermissionsSuffixPermissionRule rule = new OnlyPermissionsSuffixPermissionRule();
+			Assertion.AssertNull(rule.Check(typeof(System.Security.Permissions.EnvironmentPermission)));
+			Assertion.AssertNull(rule.Check(typeof(System.Security.Permissions.FileIOPermission)));
+			Assertion.AssertNull(rule.Check(typeof(OtherClass)));
+		}
+		
+		class NotAnPermission
+		{
+		}
+		[Test]
+		public void TestIncorrectPermission()
+		{
+			OnlyPermissionsSuffixPermissionRule rule = new OnlyPermissionsSuffixPermissionRule();
+			Assertion.AssertNotNull(rule.Check(typeof(NotAnPermission)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyStreamsSuffixStreamRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyStreamsSuffixStreamRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/OnlyStreamsSuffixStreamRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,86 +1,87 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of OnlyStreamsSuffixStreamRule.	
-	/// </summary>
-	public class OnlyStreamsSuffixStreamRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyStreamsSuffixStream.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyStreamsSuffixStream.Details}";
-			}
-		}
-		
-		public OnlyStreamsSuffixStreamRule()
-		{
-			base.certainty = 99;
-			base.priorityLevel = PriorityLevel.CriticalError;
-		}
-		
-		
-		public Resolution Check(Type type)
-		{
-			if (!typeof(System.IO.Stream).IsAssignableFrom(type) && type.Name.EndsWith("Stream")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.OnlyStreamsSuffixStream.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using System.IO;
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class OnlyStreamsSuffixStreamRuleTest
-	{
-		class MyOtherClass
-		{
-		}
-		class RealStream : System.IO.FileStream  
-		{
-			public RealStream(string path,FileMode mode) : base(path, mode)
-			{}
-		}
-		[Test]
-		public void TestCorrectStream()
-		{
-			OnlyStreamsSuffixStreamRule rule = new OnlyStreamsSuffixStreamRule();
-			Assertion.AssertNull(rule.Check(typeof(MyOtherClass)));
-			Assertion.AssertNull(rule.Check(typeof(RealStream)));
-		}
-		
-		class MyStream
-		{
-		}
-		[Test]
-		public void TestIncorrectStream()
-		{
-			OnlyStreamsSuffixStreamRule rule = new OnlyStreamsSuffixStreamRule();
-			Assertion.AssertNotNull(rule.Check(typeof(MyStream)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of OnlyStreamsSuffixStreamRule.	
+	/// </summary>
+	public class OnlyStreamsSuffixStreamRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Only stream names have the suffix 'Stream'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type that does not extend from <code><a href='help://types/System.IO.Stream'>Stream</a></code> should never have the suffix <i>Stream</i>.";
+			}
+		}
+		
+		public OnlyStreamsSuffixStreamRule()
+		{
+			base.certainty = 99;
+			base.priorityLevel = PriorityLevel.CriticalError;
+		}
+		
+		
+		public Resolution Check(Type type)
+		{
+			if (!typeof(System.IO.Stream).IsAssignableFrom(type) && type.Name.EndsWith("Stream")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the name of the type <code>{0}</code> so that it does not end with <i>Stream</i>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using System.IO;
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class OnlyStreamsSuffixStreamRuleTest
+	{
+		class MyOtherClass
+		{
+		}
+		class RealStream : System.IO.FileStream  
+		{
+			public RealStream(string path,FileMode mode) : base(path, mode)
+			{}
+		}
+		[Test]
+		public void TestCorrectStream()
+		{
+			OnlyStreamsSuffixStreamRule rule = new OnlyStreamsSuffixStreamRule();
+			Assertion.AssertNull(rule.Check(typeof(MyOtherClass)));
+			Assertion.AssertNull(rule.Check(typeof(RealStream)));
+		}
+		
+		class MyStream
+		{
+		}
+		[Test]
+		public void TestIncorrectStream()
+		{
+			OnlyStreamsSuffixStreamRule rule = new OnlyStreamsSuffixStreamRule();
+			Assertion.AssertNotNull(rule.Check(typeof(MyStream)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/ParameterNamesDoNotHaveUnderscores.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/ParameterNamesDoNotHaveUnderscores.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/ParameterNamesDoNotHaveUnderscores.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,100 +1,101 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-using System.Collections;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of ParameterNamesDoNotHaveUnderscores.	
-	/// </summary>
-	public class ParameterNamesDoNotHaveUnderscores : AbstractReflectionRule, IParameterRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.ParameterNamesDoNotHaveUnderscores.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.ParameterNamesDoNotHaveUnderscores.Details}";
-			}
-		}
-		
-		public ParameterNamesDoNotHaveUnderscores()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(Module module, ParameterInfo param)
-		{
-			if (param.Name != null && param.Name.IndexOf('_') >= 0) {
-				string memberName = NamingUtilities.Combine(param.Member.DeclaringType.FullName, param.Member.Name);
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.ParameterNamesDoNotHaveUnderscores.Resolution}", memberName, new string[,] {{"ParameterName", param.Name}, {"MemberName", memberName}});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class ParameterNamesDoNotHaveUnderscoresTest
-	{
-		public class A {
-			public void TestMethod1(int right)
-			{
-			}
-			public void TestMethod2(int a, int b, int c, int d)
-			{
-			}
-			public void TestMethod3(int wrong_)
-			{
-			}
-			public void TestMethod4(int _a, int b_c, int ____, int wrong_)
-			{
-			}
-			public static void TestMethod(MethodInfo methodInfo, bool isNull)
-			{
-				ParameterNamesDoNotHaveUnderscores parameterNamesDoNotHaveUnderscores = new ParameterNamesDoNotHaveUnderscores();
-				foreach (ParameterInfo parameter in methodInfo.GetParameters()) {
-					if (isNull) {
-						Assertion.AssertNull(parameterNamesDoNotHaveUnderscores.Check(null, parameter));
-					} else {
-						Assertion.AssertNotNull(parameterNamesDoNotHaveUnderscores.Check(null, parameter));
-					}
-				}
-			}
-		}
-		
-		
-		[Test]
-		public void TestCorrectParameters()
-		{
-			A.TestMethod(typeof(A).GetMethod("TestMethod1"), true);
-			A.TestMethod(typeof(A).GetMethod("TestMethod2"), true);
-		}
-		
-		[Test]
-		public void TestIncorrectParameters()
-		{
-			A.TestMethod(typeof(A).GetMethod("TestMethod3"), false);
-			A.TestMethod(typeof(A).GetMethod("TestMethod4"), false);
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+using System.Collections;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of ParameterNamesDoNotHaveUnderscores.	
+	/// </summary>
+	public class ParameterNamesDoNotHaveUnderscores : AbstractReflectionRule, IParameterRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Parameter names do not contain underscores '_'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Underscores should never be used inside parameter names.";
+			}
+		}
+		
+		public ParameterNamesDoNotHaveUnderscores()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(Module module, ParameterInfo param)
+		{
+			if (param.Name != null && param.Name.IndexOf('_') >= 0) {
+				string memberName = NamingUtilities.Combine(param.Member.DeclaringType.FullName, param.Member.Name);
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Remove all underscores in parameter <code>{0}</code> inside member <code>{1}</code>.", param.Name, memberName), memberName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class ParameterNamesDoNotHaveUnderscoresTest
+	{
+		public class A {
+			public void TestMethod1(int right)
+			{
+			}
+			public void TestMethod2(int a, int b, int c, int d)
+			{
+			}
+			public void TestMethod3(int wrong_)
+			{
+			}
+			public void TestMethod4(int _a, int b_c, int ____, int wrong_)
+			{
+			}
+			public static void TestMethod(MethodInfo methodInfo, bool isNull)
+			{
+				ParameterNamesDoNotHaveUnderscores parameterNamesDoNotHaveUnderscores = new ParameterNamesDoNotHaveUnderscores();
+				foreach (ParameterInfo parameter in methodInfo.GetParameters()) {
+					if (isNull) {
+						Assertion.AssertNull(parameterNamesDoNotHaveUnderscores.Check(null, parameter));
+					} else {
+						Assertion.AssertNotNull(parameterNamesDoNotHaveUnderscores.Check(null, parameter));
+					}
+				}
+			}
+		}
+		
+		
+		[Test]
+		public void TestCorrectParameters()
+		{
+			A.TestMethod(typeof(A).GetMethod("TestMethod1"), true);
+			A.TestMethod(typeof(A).GetMethod("TestMethod2"), true);
+		}
+		
+		[Test]
+		public void TestIncorrectParameters()
+		{
+			A.TestMethod(typeof(A).GetMethod("TestMethod3"), false);
+			A.TestMethod(typeof(A).GetMethod("TestMethod4"), false);
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/ParametersAreCamelCased.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/ParametersAreCamelCased.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/ParametersAreCamelCased.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,100 +1,101 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-using System.Collections;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of NamespacesArePascalCased.	
-	/// </summary>
-	public class ParametersAreCamelCased : AbstractReflectionRule, IParameterRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.ParametersAreCamelCased.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.ParametersAreCamelCased.Details}";
-			}
-		}
-		
-		public ParametersAreCamelCased()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(Module module, ParameterInfo param)
-		{
-			if (!NamingUtilities.IsCamelCase(param.Name)) {
-				string memberName = NamingUtilities.Combine(param.Member.DeclaringType.FullName, param.Member.Name);
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.ParametersAreCamelCased.Resolution}", memberName, new string[,] {{"ParameterName", param.Name}, {"MemberName", memberName}, {"AlternateName", NamingUtilities.CamelCase(param.Name)}});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class ParametersAreCamelCasedTest
-	{
-		public class A {
-			public void TestMethod1(int right)
-			{
-			}
-			public void TestMethod2(int a, int b, int c, int d)
-			{
-			}
-			public void TestMethod3(int Wrong)
-			{
-			}
-			public void TestMethod4(int A, int B, int C, int D)
-			{
-			}
-			public static void TestMethod(MethodInfo methodInfo, bool isNull)
-			{
-				ParametersAreCamelCased parametersAreCamelCased = new ParametersAreCamelCased();
-				foreach (ParameterInfo parameter in methodInfo.GetParameters()) {
-					if (isNull) {
-						Assertion.AssertNull(parametersAreCamelCased.Check(null, parameter));
-					} else {
-						Assertion.AssertNotNull(parametersAreCamelCased.Check(null, parameter));
-					}
-				}
-			}
-		}
-		
-		
-		[Test]
-		public void TestCorrectParameters()
-		{
-			A.TestMethod(typeof(A).GetMethod("TestMethod1"), true);
-			A.TestMethod(typeof(A).GetMethod("TestMethod2"), true);
-		}
-		
-		[Test]
-		public void TestIncorrectParameters()
-		{
-			A.TestMethod(typeof(A).GetMethod("TestMethod3"), false);
-			A.TestMethod(typeof(A).GetMethod("TestMethod4"), false);
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+using System.Collections;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of ParametersArePascalCased.	
+	/// </summary>
+	public class ParametersAreCamelCased : AbstractReflectionRule, IParameterRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Parameter names should be camel cased";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Camel casing lowercase the first letter like in <code><b>m</b>ousePosition</code> but the starting letters of all subsequent words are capitalized. Use camel casing for all parameters.";
+			}
+		}
+		
+		public ParametersAreCamelCased()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(Module module, ParameterInfo param)
+		{
+			if (!NamingUtilities.IsCamelCase(param.Name)) {
+				string memberName = NamingUtilities.Combine(param.Member.DeclaringType.FullName, param.Member.Name);
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Use camel casing for the parameter <code>{0}</code> inside member <code>{1}</code>.<BR>For example: <code>{2}</code>.", param.Name, memberName, NamingUtilities.CamelCase (param.Name)), memberName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class ParametersAreCamelCasedTest
+	{
+		public class A {
+			public void TestMethod1(int right)
+			{
+			}
+			public void TestMethod2(int a, int b, int c, int d)
+			{
+			}
+			public void TestMethod3(int Wrong)
+			{
+			}
+			public void TestMethod4(int A, int B, int C, int D)
+			{
+			}
+			public static void TestMethod(MethodInfo methodInfo, bool isNull)
+			{
+				ParametersAreCamelCased parametersAreCamelCased = new ParametersAreCamelCased();
+				foreach (ParameterInfo parameter in methodInfo.GetParameters()) {
+					if (isNull) {
+						Assertion.AssertNull(parametersAreCamelCased.Check(null, parameter));
+					} else {
+						Assertion.AssertNotNull(parametersAreCamelCased.Check(null, parameter));
+					}
+				}
+			}
+		}
+		
+		
+		[Test]
+		public void TestCorrectParameters()
+		{
+			A.TestMethod(typeof(A).GetMethod("TestMethod1"), true);
+			A.TestMethod(typeof(A).GetMethod("TestMethod2"), true);
+		}
+		
+		[Test]
+		public void TestIncorrectParameters()
+		{
+			A.TestMethod(typeof(A).GetMethod("TestMethod3"), false);
+			A.TestMethod(typeof(A).GetMethod("TestMethod4"), false);
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/PermissionSuffixIsPermissionRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/PermissionSuffixIsPermissionRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/PermissionSuffixIsPermissionRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,64 +1,65 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of PermissionSuffixIsPermissionRule.	
-	/// </summary>
-	public class PermissionSuffixIsPermissionRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.PermissionSuffixIsPermission.Description}";
-			}
-		}
-		
-		// System.Attribute
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.PermissionSuffixIsPermission.Details}";
-			}
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (typeof(System.Security.IPermission).IsAssignableFrom(type) && !type.Name.EndsWith("Permission")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.PermissionSuffixIsPermission.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class PermissionSuffixIsPermissionRuleTest
-	{
-		[Test]
-		public void TestCorrectPermission()
-		{
-			PermissionSuffixIsPermissionRule rule = new PermissionSuffixIsPermissionRule();
-			Assertion.AssertNull(rule.Check(typeof(System.Security.Permissions.EnvironmentPermission)));
-			Assertion.AssertNull(rule.Check(typeof(System.Security.Permissions.FileIOPermission)));
-			Assertion.AssertNull(rule.Check(typeof(PermissionSuffixIsPermissionRuleTest)));
-		}
-		
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of PermissionSuffixIsPermissionRule.	
+	/// </summary>
+	public class PermissionSuffixIsPermissionRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Permission names have the suffix 'Permission'";
+			}
+		}
+		
+		// System.Attribute
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type that extends <code><a href='help://types/System.Security.IPermission'>IPermission</a></code> is a permission and its name should always end with <i>Permission</i> like in <code>FileIOPermission</code>.";
+			}
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (typeof(System.Security.IPermission).IsAssignableFrom(type) && !type.Name.EndsWith("Permission")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the name of the type <code>{0}</code> so that it ends with <I>Permission</I>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class PermissionSuffixIsPermissionRuleTest
+	{
+		[Test]
+		public void TestCorrectPermission()
+		{
+			PermissionSuffixIsPermissionRule rule = new PermissionSuffixIsPermissionRule();
+			Assertion.AssertNull(rule.Check(typeof(System.Security.Permissions.EnvironmentPermission)));
+			Assertion.AssertNull(rule.Check(typeof(System.Security.Permissions.FileIOPermission)));
+			Assertion.AssertNull(rule.Check(typeof(PermissionSuffixIsPermissionRuleTest)));
+		}
+		
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/StreamSuffixIsStreamRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/StreamSuffixIsStreamRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/StreamSuffixIsStreamRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,86 +1,87 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of StreamSuffixIsStreamRule.	
-	/// </summary>
-	public class StreamSuffixIsStreamRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.StreamSuffixIsStream.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.StreamSuffixIsStream.Details}";
-			}
-		}
-		
-		public StreamSuffixIsStreamRule()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (typeof(System.IO.Stream).IsAssignableFrom(type) && !type.Name.EndsWith("Stream")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.StreamSuffixIsStream.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using System.IO;
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class StreamSuffixIsStreamRuleTest
-	{
-		class MyOtherClass
-		{
-		}
-		class RealStream : System.IO.FileStream  
-		{
-			public RealStream(string path,FileMode mode) : base(path, mode)
-			{}
-		}
-		[Test]
-		public void TestCorrectStream()
-		{
-			StreamSuffixIsStreamRule rule = new StreamSuffixIsStreamRule();
-			Assertion.AssertNull(rule.Check(typeof(MyOtherClass)));
-			Assertion.AssertNull(rule.Check(typeof(RealStream)));
-		}
-		
-		class WrongStrm : System.IO.FileStream  
-		{
-			public WrongStrm(string path,FileMode mode) : base(path, mode)
-			{}
-		}
-		[Test]
-		public void TestIncorrectStream()
-		{
-			StreamSuffixIsStreamRule rule = new StreamSuffixIsStreamRule();
-			Assertion.AssertNotNull(rule.Check(typeof(WrongStrm)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of StreamSuffixIsStreamRule.	
+	/// </summary>
+	public class StreamSuffixIsStreamRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Stream names have the suffix 'Stream'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "A type that extends <code><a href='help://types/System.IO.Stream'>Stream</a></code> is a stream and its name should always end with <i>Stream</i> like in <code>FileStream</code>.";
+			}
+		}
+		
+		public StreamSuffixIsStreamRule()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (typeof(System.IO.Stream).IsAssignableFrom(type) && !type.Name.EndsWith("Stream")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the name of the type <code>{0}</code> so that it ends with <I>Stream</I>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using System.IO;
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class StreamSuffixIsStreamRuleTest
+	{
+		class MyOtherClass
+		{
+		}
+		class RealStream : System.IO.FileStream  
+		{
+			public RealStream(string path,FileMode mode) : base(path, mode)
+			{}
+		}
+		[Test]
+		public void TestCorrectStream()
+		{
+			StreamSuffixIsStreamRule rule = new StreamSuffixIsStreamRule();
+			Assertion.AssertNull(rule.Check(typeof(MyOtherClass)));
+			Assertion.AssertNull(rule.Check(typeof(RealStream)));
+		}
+		
+		class WrongStrm : System.IO.FileStream  
+		{
+			public WrongStrm(string path,FileMode mode) : base(path, mode)
+			{}
+		}
+		[Test]
+		public void TestIncorrectStream()
+		{
+			StreamSuffixIsStreamRule rule = new StreamSuffixIsStreamRule();
+			Assertion.AssertNotNull(rule.Check(typeof(WrongStrm)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/TypeNamesDoNotContainUnderscores.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/TypeNamesDoNotContainUnderscores.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/TypeNamesDoNotContainUnderscores.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,77 +1,78 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AttributeSuffixIsAttribute.	
-	/// </summary>
-	public class TypeNamesDoNotContainUnderscores : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.TypeNamesDoNotContainUnderscores.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.TypeNamesDoNotContainUnderscores.Details}";
-			}
-		}
-		
-		public TypeNamesDoNotContainUnderscores()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (NamingUtilities.ContainsUnderscore(type.Name)) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.TypeNamesDoNotContainUnderscores.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class TypeNamesDoNotContainUnderscoresTest
-	{
-		interface ICorrectInterface
-		{
-		}
-		[Test]
-		public void TestCorrectTypenames()
-		{
-			TypeNamesDoNotContainUnderscores typeNamesDoNotContainUnderscores = new TypeNamesDoNotContainUnderscores();
-			Assertion.AssertNull(typeNamesDoNotContainUnderscores.Check(typeof(ICorrectInterface)));
-		}
-		
-		class Wrong_Class
-		{
-		}
-		[Test]
-		public void TestIncorrectTypenames()
-		{
-			TypeNamesDoNotContainUnderscores typeNamesDoNotContainUnderscores = new TypeNamesDoNotContainUnderscores();
-			Assertion.AssertNotNull(typeNamesDoNotContainUnderscores.Check(typeof(Wrong_Class)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of TypeNamesDoNotContainUnderscores.
+	/// </summary>
+	public class TypeNamesDoNotContainUnderscores : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Type names do not contain underscores '_'";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Underscores should never be used inside type names.";
+			}
+		}
+		
+		public TypeNamesDoNotContainUnderscores()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (NamingUtilities.ContainsUnderscore(type.Name)) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Remove all underscores in the type name <code>{0}</code>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class TypeNamesDoNotContainUnderscoresTest
+	{
+		interface ICorrectInterface
+		{
+		}
+		[Test]
+		public void TestCorrectTypenames()
+		{
+			TypeNamesDoNotContainUnderscores typeNamesDoNotContainUnderscores = new TypeNamesDoNotContainUnderscores();
+			Assertion.AssertNull(typeNamesDoNotContainUnderscores.Check(typeof(ICorrectInterface)));
+		}
+		
+		class Wrong_Class
+		{
+		}
+		[Test]
+		public void TestIncorrectTypenames()
+		{
+			TypeNamesDoNotContainUnderscores typeNamesDoNotContainUnderscores = new TypeNamesDoNotContainUnderscores();
+			Assertion.AssertNotNull(typeNamesDoNotContainUnderscores.Check(typeof(Wrong_Class)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/TypesArePascalCased.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/TypesArePascalCased.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/TypesArePascalCased.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,83 +1,84 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of AttributeSuffixIsAttribute.	
-	/// </summary>
-	public class TypesArePascalCased : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.TypesArePascalCased.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.TypesArePascalCased.Details}";
-			}
-		}
-		
-		public TypesArePascalCased()
-		{
-			base.certainty = 99;
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (!NamingUtilities.IsPascalCase(type.Name)) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.TypesArePascalCased.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }, {"AlternateName", NamingUtilities.PascalCase(type.Name)}});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class TypesArePascalCasedTest
-	{
-		interface IInterface
-		{
-		}
-		class AClassImplTest
-		{
-			
-		}
-		[Test]
-		public void TestCorrectTypenames()
-		{
-			TypesArePascalCased typesArePascalCased = new TypesArePascalCased();
-			Assertion.AssertNull(typesArePascalCased.Check(typeof(IInterface)));
-			Assertion.AssertNull(typesArePascalCased.Check(typeof(AClassImplTest)));
-		}
-		
-		class wrong
-		{
-			
-		}
-		[Test]
-		public void TestIncorrectTypenames()
-		{
-			TypesArePascalCased typesArePascalCased = new TypesArePascalCased();
-			Assertion.AssertNotNull(typesArePascalCased.Check(typeof(wrong)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of TypesArePascalCased.	
+	/// </summary>
+	public class TypesArePascalCased : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Type names should be pascal cased";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Pascal casing capitalized the first letter like in <code><b>A</b>ppDomain</code>. Use pascal casing for all type names.";
+			}
+		}
+		
+		public TypesArePascalCased()
+		{
+			base.certainty = 99;
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (!NamingUtilities.IsPascalCase(type.Name)) {
+				// FIXME: I18N
+				return new Resolution(this, String.Format ("Use pascal casing for the type <code>{0}</code>.<BR>For example: <code>{1}</code>.", type.FullName, NamingUtilities.PascalCase (type.FullName)),  type.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class TypesArePascalCasedTest
+	{
+		interface IInterface
+		{
+		}
+		class AClassImplTest
+		{
+			
+		}
+		[Test]
+		public void TestCorrectTypenames()
+		{
+			TypesArePascalCased typesArePascalCased = new TypesArePascalCased();
+			Assertion.AssertNull(typesArePascalCased.Check(typeof(IInterface)));
+			Assertion.AssertNull(typesArePascalCased.Check(typeof(AClassImplTest)));
+		}
+		
+		class wrong
+		{
+			
+		}
+		[Test]
+		public void TestIncorrectTypenames()
+		{
+			TypesArePascalCased typesArePascalCased = new TypesArePascalCased();
+			Assertion.AssertNotNull(typesArePascalCased.Check(typeof(wrong)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/TypesImplementingInterfacesHaveNoSuffixImplRule.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/TypesImplementingInterfacesHaveNoSuffixImplRule.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingRules/TypesImplementingInterfacesHaveNoSuffixImplRule.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,77 +1,78 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of TypesImplementingInterfacesHaveNoSuffixImplRule.	
-	/// </summary>
-	public class TypesImplementingInterfacesHaveNoSuffixImplRule : AbstractReflectionRule, ITypeRule
-	{
-		public override string Description {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.TypesImplementingInterfacesHaveNoSuffixImpl.Description}";
-			}
-		}
-		
-		public override string Details {
-			get {
-				return "${res:MonoDevelop.AssemblyAnalyser.Rules.TypesImplementingInterfacesHaveNoSuffixImpl.Details}";
-			}
-		}
-		
-		public Resolution Check(Type type)
-		{
-			if (type.GetInterfaces().Length > 0 && type.Name.EndsWith("Impl")) {
-				return new Resolution(this, "${res:MonoDevelop.AssemblyAnalyser.Rules.TypesImplementingInterfacesHaveNoSuffixImpl.Resolution}", type.FullName, new string[,] { { "TypeName", type.FullName }});
-			}
-			return null;
-		}
-	}
-}
-#region Unit Test
-#if TEST
-/*
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	using NUnit.Framework;
-
-	[TestFixture]
-	public class TypesImplementingInterfacesHaveNoSuffixImplRuleTest
-	{
-		interface IInterface
-		{
-		}
-		class AClassImplTest : IInterface
-		{
-			
-		}
-		[Test]
-		public void TestCorrectTypenames()
-		{
-			TypesImplementingInterfacesHaveNoSuffixImplRule rule = new TypesImplementingInterfacesHaveNoSuffixImplRule();
-			Assertion.AssertNull(rule.Check(typeof(AClassImplTest)));
-		}
-		
-		class BImpl : IInterface
-		{
-			
-		}
-		[Test]
-		public void TestIncorrectTypenames()
-		{
-			TypesImplementingInterfacesHaveNoSuffixImplRule rule = new TypesImplementingInterfacesHaveNoSuffixImplRule();
-			Assertion.AssertNotNull(rule.Check(typeof(BImpl)));
-		}
-	}
-}
-*/
-#endif
-#endregion
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of TypesImplementingInterfacesHaveNoSuffixImplRule.	
+	/// </summary>
+	public class TypesImplementingInterfacesHaveNoSuffixImplRule : AbstractReflectionRule, ITypeRule
+	{
+		public override string Description {
+			get {
+				// FIXME: I18N
+				return "Types that implement interfaces have no 'Impl' suffix";
+			}
+		}
+		
+		public override string Details {
+			get {
+				// FIXME: I18N
+				return "Do not use the <i>Impl</i> suffix for providing an interface implementation. Consider using the interface name without the <i>I</i> like <code>Component</code> that implements <code>IComponent</code>.";
+			}
+		}
+		
+		public Resolution Check(Type type)
+		{
+			if (type.GetInterfaces().Length > 0 && type.Name.EndsWith("Impl")) {
+				// FIXME: I18N
+				return new Resolution (this, String.Format ("Change the name of the type <code>{0}</code> so that it does not end with <i>Impl</i>.", type.FullName), type.FullName);
+			}
+			return null;
+		}
+	}
+}
+#region Unit Test
+#if TEST
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class TypesImplementingInterfacesHaveNoSuffixImplRuleTest
+	{
+		interface IInterface
+		{
+		}
+		class AClassImplTest : IInterface
+		{
+			
+		}
+		[Test]
+		public void TestCorrectTypenames()
+		{
+			TypesImplementingInterfacesHaveNoSuffixImplRule rule = new TypesImplementingInterfacesHaveNoSuffixImplRule();
+			Assertion.AssertNull(rule.Check(typeof(AClassImplTest)));
+		}
+		
+		class BImpl : IInterface
+		{
+			
+		}
+		[Test]
+		public void TestIncorrectTypenames()
+		{
+			TypesImplementingInterfacesHaveNoSuffixImplRule rule = new TypesImplementingInterfacesHaveNoSuffixImplRule();
+			Assertion.AssertNotNull(rule.Check(typeof(BImpl)));
+		}
+	}
+}
+#endif
+#endregion

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingUtilities.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingUtilities.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/NamingUtilities.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,73 +1,73 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of NamingUtilities.	
-	/// </summary>
-	public sealed class NamingUtilities
-	{
-		/// <summary>
-		/// Pascal casing is like 'PascalCase'
-		/// </summary>
-		public static bool IsPascalCase(string name)
-		{
-			if (name == null || name.Length == 0) {
-				return true;
-			}
-			return Char.IsUpper(name[0]);
-		}
-		
-		public static string PascalCase(string name)
-		{
-			if (name == null || name.Length == 0) {
-				return name;
-			}
-			return Char.ToUpper(name[0]) + name.Substring(1);
-		}
-		
-		
-		/// <summary>
-		/// Camel casing is like 'camelCase'
-		/// </summary>
-		public static bool IsCamelCase(string name)
-		{
-			if (name == null || name.Length == 0) {
-				return true;
-			}
-			return Char.IsLower(name[0]);
-		}
-		
-		
-		public static string CamelCase(string name)
-		{
-			if (name == null || name.Length == 0) {
-				return name;
-			}
-			return Char.ToLower(name[0]) + name.Substring(1);
-		}
-		
-		public static bool ContainsUnderscore(string name)
-		{
-			if (name == null || name.Length == 0) {
-				return false;
-			}
-			return name.IndexOf('_') >= 0;
-		}
-		
-		public static string Combine(string typeName, string memberName)
-		{
-			return String.Concat(typeName, 
-			                     '.',
-			                     memberName);
-		}
-		
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of NamingUtilities.	
+	/// </summary>
+	public sealed class NamingUtilities
+	{
+		/// <summary>
+		/// Pascal casing is like 'PascalCase'
+		/// </summary>
+		public static bool IsPascalCase(string name)
+		{
+			if (name == null || name.Length == 0) {
+				return true;
+			}
+			return Char.IsUpper(name[0]);
+		}
+		
+		public static string PascalCase(string name)
+		{
+			if (name == null || name.Length == 0) {
+				return name;
+			}
+			return Char.ToUpper(name[0]) + name.Substring(1);
+		}
+		
+		
+		/// <summary>
+		/// Camel casing is like 'camelCase'
+		/// </summary>
+		public static bool IsCamelCase(string name)
+		{
+			if (name == null || name.Length == 0) {
+				return true;
+			}
+			return Char.IsLower(name[0]);
+		}
+		
+		
+		public static string CamelCase(string name)
+		{
+			if (name == null || name.Length == 0) {
+				return name;
+			}
+			return Char.ToLower(name[0]) + name.Substring(1);
+		}
+		
+		public static bool ContainsUnderscore(string name)
+		{
+			if (name == null || name.Length == 0) {
+				return false;
+			}
+			return name.IndexOf('_') >= 0;
+		}
+		
+		public static string Combine(string typeName, string memberName)
+		{
+			return String.Concat(typeName, 
+			                     '.',
+			                     memberName);
+		}
+		
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/PriorityLevel.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/PriorityLevel.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/PriorityLevel.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,24 +1,24 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	/// <summary>
-	/// Description of IAssemblyRule.	
-	/// </summary>
-	public enum PriorityLevel
-	{
-		Information,
-		Warning,
-		CriticalWarning,
-		Error,
-		CriticalError
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	/// <summary>
+	/// Description of IAssemblyRule.	
+	/// </summary>
+	public enum PriorityLevel
+	{
+		Information,
+		Warning,
+		CriticalWarning,
+		Error,
+		CriticalError
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/ProtectionLevels.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/ProtectionLevels.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer/Rules/ProtectionLevels.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -1,35 +1,35 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
-//     <version value="$version"/>
-// </file>
-
-using System;
-using System.Reflection;
-
-namespace MonoDevelop.AssemblyAnalyser.Rules
-{
-	[Flags]
-	public enum ProtectionLevels
-	{
-		None = 0,
-		
-		Public   = 1,
-		Family   = 2,
-		Private  = 4,
-		Assembly = 8,
-		FamilyAndAssembly = 16,
-		FamilyOrAssembly  = 32,
-		
-		NestedPublic   = 64,
-		NestedFamily   = 128,
-		NestedPrivate  = 256,
-		NestedAssembly = 512,
-		NestedFamilyAndAssembly = 1024,
-		NestedFamilyOrAssembly = 2048,
-		
-		All = Public | Family | Private | Assembly | FamilyAndAssembly | FamilyOrAssembly |
-		      NestedPublic | NestedFamily | NestedPrivate | NestedAssembly | NestedFamilyAndAssembly | NestedFamilyOrAssembly,
-	}
-}
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Mike Krueger" email="mike at icsharpcode.net"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Reflection;
+
+namespace ICSharpCode.AssemblyAnalyser.Rules
+{
+	[Flags]
+	public enum ProtectionLevels
+	{
+		None = 0,
+		
+		Public   = 1,
+		Family   = 2,
+		Private  = 4,
+		Assembly = 8,
+		FamilyAndAssembly = 16,
+		FamilyOrAssembly  = 32,
+		
+		NestedPublic   = 64,
+		NestedFamily   = 128,
+		NestedPrivate  = 256,
+		NestedAssembly = 512,
+		NestedFamilyAndAssembly = 1024,
+		NestedFamilyOrAssembly = 2048,
+		
+		All = Public | Family | Private | Assembly | FamilyAndAssembly | FamilyOrAssembly |
+		      NestedPublic | NestedFamily | NestedPrivate | NestedAssembly | NestedFamilyAndAssembly | NestedFamilyOrAssembly,
+	}
+}

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Commands.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Commands.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Commands.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -7,10 +7,11 @@
 using System;
 using System.Reflection;
 
-using MonoDevelop.AssemblyAnalyser.Rules;
 using MonoDevelop.Core.AddIns.Codons;
 using MonoDevelop.Gui;
 
+using ICSharpCode.AssemblyAnalyser.Rules;
+
 namespace MonoDevelop.AssemblyAnalyser
 {
 	public class ShowAssemblyAnalyser : AbstractMenuCommand

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/AssemblyAnalyserControl.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/AssemblyAnalyserControl.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/AssemblyAnalyserControl.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -11,6 +11,8 @@
 using System.Reflection;
 using Gtk;
 
+using AssemblyAnalyser = ICSharpCode.AssemblyAnalyser.AssemblyAnalyser;
+
 namespace MonoDevelop.AssemblyAnalyser
 {
 	public class AssemblyAnalyserControl : Frame

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/AssemblyAnalyserView.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/AssemblyAnalyserView.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/AssemblyAnalyserView.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -19,6 +19,8 @@
 using MonoDevelop.Core.Services;
 using MonoDevelop.Internal.Project;
 
+using AssemblyAnalyser = ICSharpCode.AssemblyAnalyser.AssemblyAnalyser;
+
 namespace MonoDevelop.AssemblyAnalyser
 {
 	public class AssemblyAnalyserView : AbstractViewContent

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/Panels/AssemblyTreeControl.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/Panels/AssemblyTreeControl.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/Panels/AssemblyTreeControl.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -15,6 +15,8 @@
 using MonoDevelop.Core.Services;
 using MonoDevelop.Services;
 
+using AssemblyAnalyser = ICSharpCode.AssemblyAnalyser.AssemblyAnalyser;
+
 namespace MonoDevelop.AssemblyAnalyser
 {
 	public class AssemblyTreeControl : TreeView

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/Panels/ResultDetailsView.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/Panels/ResultDetailsView.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/Panels/ResultDetailsView.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -15,9 +15,12 @@
 using MonoDevelop.Core;
 using MonoDevelop.Services;
 using MonoDevelop.Core.Services;
-using MonoDevelop.AssemblyAnalyser.Rules;
 using MonoDevelop.Gui.Pads;
 
+using AssemblyAnalyser = ICSharpCode.AssemblyAnalyser.AssemblyAnalyser;
+using Resolution = ICSharpCode.AssemblyAnalyser.Resolution;
+using ICSharpCode.AssemblyAnalyser.Rules;
+
 namespace MonoDevelop.AssemblyAnalyser
 {
 	public class ResultDetailsView : Frame

Modified: trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/Panels/ResultListControl.cs
===================================================================
--- trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/Panels/ResultListControl.cs	2004-10-24 02:16:32 UTC (rev 1996)
+++ trunk/MonoDevelop/Core/src/AddIns/Misc/AssemblyAnalyser/ICSharpCode.AssemblyAnalyzer.AddIn/Gui/Panels/ResultListControl.cs	2004-10-26 03:51:03 UTC (rev 1997)
@@ -12,9 +12,12 @@
 using Gtk;
 
 using MonoDevelop.Core.Services;
-using MonoDevelop.AssemblyAnalyser.Rules;
 using MonoDevelop.Services;
 
+using AssemblyAnalyser = ICSharpCode.AssemblyAnalyser.AssemblyAnalyser;
+using Resolution = ICSharpCode.AssemblyAnalyser.Resolution;
+using ICSharpCode.AssemblyAnalyser.Rules;
+
 namespace MonoDevelop.AssemblyAnalyser
 {
 	public class ResultListControl : TreeView