[Nhibernate-commit] SF.net SVN: nhibernate:[3842] trunk/nhibernate

[<fab...@us...>]

Revision: 3842
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=3842&view=rev
Author:   fabiomaulo
Date:     2008-10-11 12:59:51 +0000 (Sat, 11 Oct 2008)

Log Message:
-----------
- Fix NH-1515 (BREAKING CHANGE)
- Minor refactoring of proxy validation stuff

Modified Paths:
--------------
    trunk/nhibernate/releasenotes.txt
    trunk/nhibernate/src/NHibernate/Cfg/Configuration.cs
    trunk/nhibernate/src/NHibernate/InvalidProxyTypeException.cs
    trunk/nhibernate/src/NHibernate/Proxy/ProxyTypeValidator.cs
    trunk/nhibernate/src/NHibernate/Tuple/Entity/PocoEntityTuplizer.cs
    trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH1408/DbResourceKey.cs
    trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH1464/Fixture.cs
    trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/ProxyValidator/Fixture.cs
    trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj

Added Paths:
-----------
    trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH1515/
    trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH1515/Fixture.cs

Modified: trunk/nhibernate/releasenotes.txt
===================================================================
--- trunk/nhibernate/releasenotes.txt	2008-10-11 05:54:37 UTC (rev 3841)
+++ trunk/nhibernate/releasenotes.txt	2008-10-11 12:59:51 UTC (rev 3842)
@@ -4,6 +4,10 @@
 	##### Possible Breaking Changes for external frameworks #####
 		* ISession interface have additional methods
 
+	##### Initialization time #####
+		* The ProxyTypeValidator check for "internal virtual" (to be proxied need "protected internal virtual")
+		
+
 Build 2.0.1.GA
 ========================
 ** Bug

Modified: trunk/nhibernate/src/NHibernate/Cfg/Configuration.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cfg/Configuration.cs	2008-10-11 05:54:37 UTC (rev 3841)
+++ trunk/nhibernate/src/NHibernate/Cfg/Configuration.cs	2008-10-11 12:59:51 UTC (rev 3842)
@@ -25,6 +25,7 @@
 using NHibernate.Tool.hbm2ddl;
 using NHibernate.Type;
 using NHibernate.Util;
+using Array=System.Array;
 
 namespace NHibernate.Cfg
 {
@@ -77,7 +78,7 @@
 		protected IDictionary<string, Mappings.TableDescription> tableNameBinding;
 		protected IDictionary<Table, Mappings.ColumnNames> columnNameBindingPerTable;
 
-		private static readonly ILog log = LogManager.GetLogger(typeof(Configuration));
+		private static readonly ILog log = LogManager.GetLogger(typeof (Configuration));
 
 		protected internal SettingsFactory settingsFactory;
 
@@ -160,8 +161,7 @@
 			}
 		}
 
-		[NonSerialized]
-		private IMapping mapping;
+		[NonSerialized] private IMapping mapping;
 
 		protected Configuration(SettingsFactory settingsFactory)
 		{
@@ -183,10 +183,7 @@
 		/// <summary>
 		/// Create a new Configuration object.
 		/// </summary>
-		public Configuration()
-			: this(new SettingsFactory())
-		{
-		}
+		public Configuration() : this(new SettingsFactory()) {}
 
 		/// <summary>
 		/// The class mappings 
@@ -260,7 +257,9 @@
 		private static void LogAndThrow(Exception exception)
 		{
 			if (log.IsErrorEnabled)
+			{
 				log.Error(exception.Message, exception);
+			}
 
 			throw exception;
 		}
@@ -393,7 +392,7 @@
 
 			try
 			{
-				using (MemoryStream ms = new MemoryStream())
+				using (var ms = new MemoryStream())
 				{
 					doc.Save(ms);
 					ms.Position = 0;
@@ -425,7 +424,7 @@
 				// selects as their prefix in the document.  It is the prefix we use to 
 				// build the XPath and the nsmgr takes care of translating our prefix into
 				// the user defined prefix...
-				XmlNamespaceManager namespaceManager = new XmlNamespaceManager(doc.Document.NameTable);
+				var namespaceManager = new XmlNamespaceManager(doc.Document.NameTable);
 				namespaceManager.AddNamespace(HbmConstants.nsPrefix, MappingSchemaXMLNS);
 
 				Dialect.Dialect dialect = Dialect.Dialect.GetDialect(properties);
@@ -446,26 +445,10 @@
 		/// </summary>
 		public Mappings CreateMappings(Dialect.Dialect dialect)
 		{
-			return new Mappings(classes,
-				collections,
-				tables,
-				namedQueries,
-				namedSqlQueries,
-				sqlResultSetMappings,
-				imports,
-				secondPasses,
-				propertyReferences,
-				namingStrategy,
-				typeDefs,
-				filterDefinitions,
-				extendsQueue,
-				auxiliaryDatabaseObjects,
-				tableNameBinding,
-				columnNameBindingPerTable,
-				defaultAssembly,
-				defaultNamespace,
-								dialect
-				);
+			return new Mappings(classes, collections, tables, namedQueries, namedSqlQueries, sqlResultSetMappings, imports,
+			                    secondPasses, propertyReferences, namingStrategy, typeDefs, filterDefinitions, extendsQueue,
+			                    auxiliaryDatabaseObjects, tableNameBinding, columnNameBindingPerTable, defaultAssembly,
+			                    defaultNamespace, dialect);
 		}
 
 		/// <summary>
@@ -555,7 +538,9 @@
 			finally
 			{
 				if (rsrc != null)
+				{
 					rsrc.Close();
+				}
 			}
 		}
 
@@ -616,8 +601,8 @@
 			if (resourceNames.Count == 0)
 			{
 				log.Warn("No mapped documents found in assembly: " + assembly.FullName);
-			} 
-			foreach (string name in resourceNames)
+			}
+			foreach (var name in resourceNames)
 			{
 				AddResource(name, assembly);
 			}
@@ -626,9 +611,9 @@
 
 		private static IList<string> GetAllHbmXmlResourceNames(Assembly assembly)
 		{
-			List<string> result = new List<string>();
+			var result = new List<string>();
 
-			foreach (string resource in assembly.GetManifestResourceNames())
+			foreach (var resource in assembly.GetManifestResourceNames())
 			{
 				if (resource.EndsWith(".hbm.xml"))
 				{
@@ -646,12 +631,12 @@
 		/// <param name="dir">a directory</param>
 		public Configuration AddDirectory(DirectoryInfo dir)
 		{
-			foreach (DirectoryInfo subDirectory in dir.GetDirectories())
+			foreach (var subDirectory in dir.GetDirectories())
 			{
 				AddDirectory(subDirectory);
 			}
 
-			foreach (FileInfo hbmXml in dir.GetFiles("*.hbm.xml"))
+			foreach (var hbmXml in dir.GetFiles("*.hbm.xml"))
 			{
 				AddFile(hbmXml);
 			}
@@ -670,7 +655,7 @@
 			string defaultCatalog = PropertiesHelper.GetString(Environment.DefaultCatalog, properties, null);
 			string defaultSchema = PropertiesHelper.GetString(Environment.DefaultSchema, properties, null);
 
-			List<string> script = new List<string>();
+			var script = new List<string>();
 
 			// drop them in reverse order in case db needs it done that way...
 			for (int i = auxiliaryDatabaseObjects.Count - 1; i >= 0; i--)
@@ -684,32 +669,36 @@
 
 			if (dialect.DropConstraints)
 			{
-				foreach (Table table in TableMappings)
+				foreach (var table in TableMappings)
 				{
 					if (table.IsPhysicalTable)
 					{
-						foreach (ForeignKey fk in table.ForeignKeyIterator)
+						foreach (var fk in table.ForeignKeyIterator)
 						{
 							if (fk.HasPhysicalConstraint)
+							{
 								script.Add(fk.SqlDropString(dialect, defaultCatalog, defaultSchema));
+							}
 						}
 					}
 				}
 			}
 
-			foreach (Table table in TableMappings)
+			foreach (var table in TableMappings)
 			{
 				if (table.IsPhysicalTable)
+				{
 					script.Add(table.SqlDropString(dialect, defaultCatalog, defaultSchema));
+				}
 			}
 
 			IEnumerable<IPersistentIdentifierGenerator> pIDg = IterateGenerators(dialect);
-			foreach (IPersistentIdentifierGenerator idGen in pIDg)
+			foreach (var idGen in pIDg)
 			{
 				string[] lines = idGen.SqlDropString(dialect);
 				if (lines != null)
 				{
-					foreach (string line in lines)
+					foreach (var line in lines)
 					{
 						script.Add(line);
 					}
@@ -730,9 +719,9 @@
 			string defaultCatalog = PropertiesHelper.GetString(Environment.DefaultCatalog, properties, null);
 			string defaultSchema = PropertiesHelper.GetString(Environment.DefaultSchema, properties, null);
 
-			List<string> script = new List<string>();
+			var script = new List<string>();
 
-			foreach (Table table in TableMappings)
+			foreach (var table in TableMappings)
 			{
 				if (table.IsPhysicalTable)
 				{
@@ -741,39 +730,47 @@
 				}
 			}
 
-			foreach (Table table in TableMappings)
+			foreach (var table in TableMappings)
 			{
 				if (table.IsPhysicalTable)
 				{
 					if (!dialect.SupportsUniqueConstraintInCreateAlterTable)
 					{
-						foreach (UniqueKey uk in table.UniqueKeyIterator)
+						foreach (var uk in table.UniqueKeyIterator)
 						{
 							string constraintString = uk.SqlCreateString(dialect, mapping, defaultCatalog, defaultSchema);
 							if (constraintString != null)
+							{
 								script.Add(constraintString);
+							}
 						}
 					}
 
-					foreach (Index index in table.IndexIterator)
+					foreach (var index in table.IndexIterator)
+					{
 						script.Add(index.SqlCreateString(dialect, mapping, defaultCatalog, defaultSchema));
+					}
 
 					if (dialect.HasAlterTable)
 					{
-						foreach (ForeignKey fk in table.ForeignKeyIterator)
+						foreach (var fk in table.ForeignKeyIterator)
 						{
 							if (fk.HasPhysicalConstraint)
+							{
 								script.Add(fk.SqlCreateString(dialect, mapping, defaultCatalog, defaultSchema));
+							}
 						}
 					}
 				}
 			}
 
 			IEnumerable<IPersistentIdentifierGenerator> pIDg = IterateGenerators(dialect);
-			foreach (IPersistentIdentifierGenerator idGen in pIDg)
+			foreach (var idGen in pIDg)
+			{
 				script.AddRange(idGen.SqlCreateStrings(dialect));
+			}
 
-			foreach (IAuxiliaryDatabaseObject auxDbObj in auxiliaryDatabaseObjects)
+			foreach (var auxDbObj in auxiliaryDatabaseObjects)
 			{
 				if (auxDbObj.AppliesToDialect(dialect))
 				{
@@ -787,19 +784,19 @@
 		private void Validate()
 		{
 			bool validateProxy = PropertiesHelper.GetBoolean(Environment.UseProxyValidator, properties, true);
-			HashedSet allProxyErrors = null;
+			HashedSet<string> allProxyErrors = null;
 
-			foreach (PersistentClass clazz in classes.Values)
+			foreach (var clazz in classes.Values)
 			{
 				clazz.Validate(mapping);
 				if (validateProxy)
 				{
-					ICollection errors = ValidateProxyInterface(clazz);
+					ICollection<string> errors = ValidateProxyInterface(clazz);
 					if (errors != null)
 					{
 						if (allProxyErrors == null)
 						{
-							allProxyErrors = new HashedSet(errors);
+							allProxyErrors = new HashedSet<string>(errors);
 						}
 						else
 						{
@@ -814,13 +811,13 @@
 				throw new InvalidProxyTypeException(allProxyErrors);
 			}
 
-			foreach (NHibernate.Mapping.Collection col in collections.Values)
+			foreach (var col in collections.Values)
 			{
 				col.Validate(mapping);
 			}
 		}
 
-		private static ICollection ValidateProxyInterface(PersistentClass persistentClass)
+		private static ICollection<string> ValidateProxyInterface(PersistentClass persistentClass)
 		{
 			if (!persistentClass.IsLazy)
 			{
@@ -857,7 +854,7 @@
 
 			log.Info("processing one-to-many association mappings");
 
-			foreach (SecondPassCommand command in secondPasses)
+			foreach (var command in secondPasses)
 			{
 				command(classes);
 			}
@@ -866,7 +863,7 @@
 
 			log.Info("processing one-to-one association property references");
 
-			foreach (Mappings.PropertyReference upr in propertyReferences)
+			foreach (var upr in propertyReferences)
 			{
 				PersistentClass clazz = GetClassMapping(upr.referencedClass);
 				if (clazz == null)
@@ -875,7 +872,7 @@
 				}
 
 				Property prop = clazz.GetReferencedProperty(upr.propertyName);
-				((SimpleValue)prop.Value).IsAlternateUniqueKey = true;
+				((SimpleValue) prop.Value).IsAlternateUniqueKey = true;
 			}
 
 			//TODO: Somehow add the newly created foreign keys to the internal collection
@@ -883,7 +880,7 @@
 			log.Info("processing foreign key constraints");
 
 			ISet done = new HashedSet();
-			foreach (Table table in TableMappings)
+			foreach (var table in TableMappings)
 			{
 				SecondPassCompileForeignKeys(table, done);
 			}
@@ -893,7 +890,7 @@
 		{
 			table.CreateForeignKeys();
 
-			foreach (ForeignKey fk in table.ForeignKeyIterator)
+			foreach (var fk in table.ForeignKeyIterator)
 			{
 				if (!done.Contains(fk))
 				{
@@ -902,7 +899,8 @@
 					string referencedEntityName = fk.ReferencedEntityName;
 					if (string.IsNullOrEmpty(referencedEntityName))
 					{
-						throw new MappingException(string.Format("An association from the table {0} does not specify the referenced entity", fk.Table.Name));
+						throw new MappingException(
+							string.Format("An association from the table {0} does not specify the referenced entity", fk.Table.Name));
 					}
 
 					if (log.IsDebugEnabled)
@@ -913,8 +911,8 @@
 					PersistentClass referencedClass;
 					if (!classes.TryGetValue(referencedEntityName, out referencedClass))
 					{
-						string message = string.Format("An association from the table {0} refers to an unmapped class: {1}",
-							fk.Table.Name, referencedEntityName);
+						string message = string.Format("An association from the table {0} refers to an unmapped class: {1}", fk.Table.Name,
+						                               referencedEntityName);
 
 						LogAndThrow(new MappingException(message));
 					}
@@ -962,11 +960,7 @@
 		/// located by specified id.  This is mainly intended for EJB3 implementations to be able to
 		/// control how proxy initialization errors should be handled...
 		/// </remarks>
-		public IEntityNotFoundDelegate EntityNotFoundDelegate
-		{
-			get { return entityNotFoundDelegate; }
-			set { entityNotFoundDelegate = value; }
-		}
+		public IEntityNotFoundDelegate EntityNotFoundDelegate { get; set; }
 
 		public EventListeners EventListeners
 		{
@@ -986,9 +980,10 @@
 		public ISessionFactory BuildSessionFactory()
 		{
 			#region Way for the user to specify their own ProxyFactory
+
 			//http://jira.nhibernate.org/browse/NH-975
 
-			IInjectableProxyFactoryFactory ipff = Environment.BytecodeProvider as IInjectableProxyFactoryFactory;
+			var ipff = Environment.BytecodeProvider as IInjectableProxyFactoryFactory;
 			string pffClassName;
 			properties.TryGetValue(Environment.ProxyFactoryFactoryClass, out pffClassName);
 			if (ipff != null && !string.IsNullOrEmpty(pffClassName))
@@ -1096,7 +1091,7 @@
 		/// </returns>
 		public Configuration AddProperties(IDictionary<string, string> additionalProperties)
 		{
-			foreach (KeyValuePair<string, string> de in additionalProperties)
+			foreach (var de in additionalProperties)
 			{
 				properties.Add(de.Key, de.Value);
 			}
@@ -1129,7 +1124,7 @@
 
 		private void AddProperties(IHibernateConfiguration hc)
 		{
-			foreach (KeyValuePair<string, string> kvp in hc.SessionFactory.Properties)
+			foreach (var kvp in hc.SessionFactory.Properties)
 			{
 				if (log.IsDebugEnabled)
 				{
@@ -1157,7 +1152,7 @@
 		/// </remarks>
 		public Configuration Configure()
 		{
-			IHibernateConfiguration hc = ConfigurationManager.GetSection(CfgXmlHelper.CfgSectionName) as IHibernateConfiguration;
+			var hc = ConfigurationManager.GetSection(CfgXmlHelper.CfgSectionName) as IHibernateConfiguration;
 			if (hc != null && hc.SessionFactory != null)
 			{
 				return DoConfigure(hc);
@@ -1216,12 +1211,14 @@
 		public Configuration Configure(Assembly assembly, string resourceName)
 		{
 			if (assembly == null)
-				throw new HibernateException("Could not configure NHibernate.",
-					new ArgumentNullException("assembly"));
+			{
+				throw new HibernateException("Could not configure NHibernate.", new ArgumentNullException("assembly"));
+			}
 
 			if (resourceName == null)
-				throw new HibernateException("Could not configure NHibernate.",
-					new ArgumentNullException("resourceName"));
+			{
+				throw new HibernateException("Could not configure NHibernate.", new ArgumentNullException("resourceName"));
+			}
 
 			Stream stream = null;
 			try
@@ -1230,9 +1227,8 @@
 				if (stream == null)
 				{
 					// resource does not exist - throw appropriate exception 
-					throw new HibernateException("A ManifestResourceStream could not be created for the resource " +
-						resourceName +
-							" in Assembly " + assembly.FullName);
+					throw new HibernateException("A ManifestResourceStream could not be created for the resource " + resourceName
+					                             + " in Assembly " + assembly.FullName);
 				}
 
 				return Configure(new XmlTextReader(stream));
@@ -1259,7 +1255,7 @@
 			if (textReader == null)
 			{
 				throw new HibernateConfigException("Could not configure NHibernate.",
-					new ArgumentException("A null value was passed in.", "textReader"));
+				                                   new ArgumentException("A null value was passed in.", "textReader"));
 			}
 
 			try
@@ -1286,10 +1282,12 @@
 			AddProperties(hc);
 
 			// Load mappings
-			foreach (MappingConfiguration mc in hc.SessionFactory.Mappings)
+			foreach (var mc in hc.SessionFactory.Mappings)
 			{
 				if (mc.IsEmpty())
+				{
 					throw new HibernateConfigException("<mapping> element in configuration specifies no attributes");
+				}
 				if (!string.IsNullOrEmpty(mc.Resource))
 				{
 					log.Debug(hc.SessionFactory.Name + "<-" + mc.Resource + " in " + mc.Assembly);
@@ -1308,7 +1306,7 @@
 			}
 
 			// Load class-cache
-			foreach (ClassCacheConfiguration ccc in hc.SessionFactory.ClassesCache)
+			foreach (var ccc in hc.SessionFactory.ClassesCache)
 			{
 				string region = string.IsNullOrEmpty(ccc.Region) ? ccc.Class : ccc.Region;
 				bool includeLazy = (ccc.Include != ClassCacheInclude.NonLazy);
@@ -1316,13 +1314,14 @@
 			}
 
 			// Load collection-cache
-			foreach (CollectionCacheConfiguration ccc in hc.SessionFactory.CollectionsCache)
+			foreach (var ccc in hc.SessionFactory.CollectionsCache)
 			{
 				string role = ccc.Collection;
 				NHibernate.Mapping.Collection collection = GetCollectionMapping(role);
 				if (collection == null)
 				{
-					throw new HibernateConfigException("collection-cache Configuration: Cannot configure cache for unknown collection role " + role);
+					throw new HibernateConfigException(
+						"collection-cache Configuration: Cannot configure cache for unknown collection role " + role);
 				}
 
 				string region = string.IsNullOrEmpty(ccc.Region) ? role : ccc.Region;
@@ -1330,9 +1329,9 @@
 			}
 
 			// Events
-			foreach (EventConfiguration ec in hc.SessionFactory.Events)
+			foreach (var ec in hc.SessionFactory.Events)
 			{
-				string[] listenerClasses = new string[ec.Listeners.Count];
+				var listenerClasses = new string[ec.Listeners.Count];
 				for (int i = 0; i < ec.Listeners.Count; i++)
 				{
 					listenerClasses[i] = ec.Listeners[i].Class;
@@ -1341,10 +1340,10 @@
 				SetListeners(ec.Type, listenerClasses);
 			}
 			// Listeners
-			foreach (ListenerConfiguration lc in hc.SessionFactory.Listeners)
+			foreach (var lc in hc.SessionFactory.Listeners)
 			{
 				log.Debug("Event listener: " + lc.Type + "=" + lc.Class);
-				SetListeners(lc.Type, new string[] { lc.Class });
+				SetListeners(lc.Type, new[] {lc.Class});
 			}
 
 			if (!string.IsNullOrEmpty(hc.SessionFactory.Name))
@@ -1360,13 +1359,13 @@
 		{
 			try
 			{
-				return (RootClass)GetClassMapping(clazz);
+				return (RootClass) GetClassMapping(clazz);
 			}
 			catch (InvalidCastException)
 			{
 				throw new HibernateConfigException(
-						"class-cache Configuration: You may only specify a cache for root <class> mappings "
-								+ "(cache was specified for " + clazz + ")");
+					"class-cache Configuration: You may only specify a cache for root <class> mappings " + "(cache was specified for "
+					+ clazz + ")");
 			}
 		}
 
@@ -1379,13 +1378,13 @@
 				throw new HibernateConfigException("class-cache Configuration: Cache specified for unmapped class " + clazz);
 			}
 
-			RootClass rootClass = persistentClass as RootClass;
+			var rootClass = persistentClass as RootClass;
 
 			if (rootClass == null)
 			{
 				throw new HibernateConfigException(
-					"class-cache Configuration: You may only specify a cache for root <class> mappings "
-						+ "(cache was specified for " + clazz + ")");
+					"class-cache Configuration: You may only specify a cache for root <class> mappings " + "(cache was specified for "
+					+ clazz + ")");
 			}
 
 			return rootClass;
@@ -1417,7 +1416,6 @@
 			rootClass.SetLazyPropertiesCacheable(includeLazy);
 		}
 
-
 		/// <summary>
 		/// Set up a cache for a collection role
 		/// </summary>
@@ -1535,7 +1533,7 @@
 
 				try
 				{
-					XmlDocument hbmDocument = new XmlDocument();
+					var hbmDocument = new XmlDocument();
 					hbmDocument.Load(reader);
 					return new NamedXmlDocument(name, hbmDocument);
 				}
@@ -1589,13 +1587,8 @@
 
 		private void ValidationHandler(object o, ValidationEventArgs args)
 		{
-			string message =
-				string.Format(
-					"{0}({1},{2}): XML validation error: {3}",
-					currentDocumentName,
-					args.Exception.LineNumber,
-					args.Exception.LinePosition,
-					args.Exception.Message);
+			string message = string.Format("{0}({1},{2}): XML validation error: {3}", currentDocumentName,
+			                               args.Exception.LineNumber, args.Exception.LinePosition, args.Exception.Message);
 			LogAndThrow(new MappingException(message, args.Exception));
 		}
 
@@ -1610,7 +1603,6 @@
 		#endregion
 
 		private XmlSchemas schemas;
-		private IEntityNotFoundDelegate entityNotFoundDelegate;
 
 		private XmlSchemas Schemas
 		{
@@ -1639,8 +1631,7 @@
 			}
 			else
 			{
-				object[] listeners =
-					(object[])System.Array.CreateInstance(eventListeners.GetListenerClassFor(type), listenerClasses.Length);
+				var listeners = (object[]) Array.CreateInstance(eventListeners.GetListenerClassFor(type), listenerClasses.Length);
 				for (int i = 0; i < listeners.Length; i++)
 				{
 					try
@@ -1672,7 +1663,7 @@
 			}
 			else
 			{
-				object[] listeners = (object[])System.Array.CreateInstance(eventListeners.GetListenerClassFor(type), 1);
+				var listeners = (object[]) Array.CreateInstance(eventListeners.GetListenerClassFor(type), 1);
 				listeners[0] = listener;
 				SetListeners(type, listeners);
 			}
@@ -1683,106 +1674,106 @@
 			switch (type)
 			{
 				case ListenerType.Autoflush:
-					eventListeners.AutoFlushEventListeners = new IAutoFlushEventListener[] { };
+					eventListeners.AutoFlushEventListeners = new IAutoFlushEventListener[] {};
 					break;
 				case ListenerType.Merge:
-					eventListeners.MergeEventListeners = new IMergeEventListener[] { };
+					eventListeners.MergeEventListeners = new IMergeEventListener[] {};
 					break;
 				case ListenerType.Create:
-					eventListeners.PersistEventListeners = new IPersistEventListener[] { };
+					eventListeners.PersistEventListeners = new IPersistEventListener[] {};
 					break;
 				case ListenerType.CreateOnFlush:
-					eventListeners.PersistOnFlushEventListeners = new IPersistEventListener[] { };
+					eventListeners.PersistOnFlushEventListeners = new IPersistEventListener[] {};
 					break;
 				case ListenerType.Delete:
-					eventListeners.DeleteEventListeners = new IDeleteEventListener[] { };
+					eventListeners.DeleteEventListeners = new IDeleteEventListener[] {};
 					break;
 				case ListenerType.DirtyCheck:
-					eventListeners.DirtyCheckEventListeners = new IDirtyCheckEventListener[] { };
+					eventListeners.DirtyCheckEventListeners = new IDirtyCheckEventListener[] {};
 					break;
 				case ListenerType.Evict:
-					eventListeners.EvictEventListeners = new IEvictEventListener[] { };
+					eventListeners.EvictEventListeners = new IEvictEventListener[] {};
 					break;
 				case ListenerType.Flush:
-					eventListeners.FlushEventListeners = new IFlushEventListener[] { };
+					eventListeners.FlushEventListeners = new IFlushEventListener[] {};
 					break;
 				case ListenerType.FlushEntity:
-					eventListeners.FlushEntityEventListeners = new IFlushEntityEventListener[] { };
+					eventListeners.FlushEntityEventListeners = new IFlushEntityEventListener[] {};
 					break;
 				case ListenerType.Load:
-					eventListeners.LoadEventListeners = new ILoadEventListener[] { };
+					eventListeners.LoadEventListeners = new ILoadEventListener[] {};
 					break;
 				case ListenerType.LoadCollection:
-					eventListeners.InitializeCollectionEventListeners = new IInitializeCollectionEventListener[] { };
+					eventListeners.InitializeCollectionEventListeners = new IInitializeCollectionEventListener[] {};
 					break;
 				case ListenerType.Lock:
-					eventListeners.LockEventListeners = new ILockEventListener[] { };
+					eventListeners.LockEventListeners = new ILockEventListener[] {};
 					break;
 				case ListenerType.Refresh:
-					eventListeners.RefreshEventListeners = new IRefreshEventListener[] { };
+					eventListeners.RefreshEventListeners = new IRefreshEventListener[] {};
 					break;
 				case ListenerType.Replicate:
-					eventListeners.ReplicateEventListeners = new IReplicateEventListener[] { };
+					eventListeners.ReplicateEventListeners = new IReplicateEventListener[] {};
 					break;
 				case ListenerType.SaveUpdate:
-					eventListeners.SaveOrUpdateEventListeners = new ISaveOrUpdateEventListener[] { };
+					eventListeners.SaveOrUpdateEventListeners = new ISaveOrUpdateEventListener[] {};
 					break;
 				case ListenerType.Save:
-					eventListeners.SaveEventListeners = new ISaveOrUpdateEventListener[] { };
+					eventListeners.SaveEventListeners = new ISaveOrUpdateEventListener[] {};
 					break;
 				case ListenerType.PreUpdate:
-					eventListeners.PreUpdateEventListeners = new IPreUpdateEventListener[] { };
+					eventListeners.PreUpdateEventListeners = new IPreUpdateEventListener[] {};
 					break;
 				case ListenerType.Update:
-					eventListeners.UpdateEventListeners = new ISaveOrUpdateEventListener[] { };
+					eventListeners.UpdateEventListeners = new ISaveOrUpdateEventListener[] {};
 					break;
 				case ListenerType.PreLoad:
-					eventListeners.PreLoadEventListeners = new IPreLoadEventListener[] { };
+					eventListeners.PreLoadEventListeners = new IPreLoadEventListener[] {};
 					break;
 				case ListenerType.PreDelete:
-					eventListeners.PreDeleteEventListeners = new IPreDeleteEventListener[] { };
+					eventListeners.PreDeleteEventListeners = new IPreDeleteEventListener[] {};
 					break;
 				case ListenerType.PreInsert:
-					eventListeners.PreInsertEventListeners = new IPreInsertEventListener[] { };
+					eventListeners.PreInsertEventListeners = new IPreInsertEventListener[] {};
 					break;
 				case ListenerType.PostLoad:
-					eventListeners.PostLoadEventListeners = new IPostLoadEventListener[] { };
+					eventListeners.PostLoadEventListeners = new IPostLoadEventListener[] {};
 					break;
 				case ListenerType.PostInsert:
-					eventListeners.PostInsertEventListeners = new IPostInsertEventListener[] { };
+					eventListeners.PostInsertEventListeners = new IPostInsertEventListener[] {};
 					break;
 				case ListenerType.PostUpdate:
-					eventListeners.PostUpdateEventListeners = new IPostUpdateEventListener[] { };
+					eventListeners.PostUpdateEventListeners = new IPostUpdateEventListener[] {};
 					break;
 				case ListenerType.PostDelete:
-					eventListeners.PostDeleteEventListeners = new IPostDeleteEventListener[] { };
+					eventListeners.PostDeleteEventListeners = new IPostDeleteEventListener[] {};
 					break;
 				case ListenerType.PostCommitUpdate:
-					eventListeners.PostCommitUpdateEventListeners = new IPostUpdateEventListener[] { };
+					eventListeners.PostCommitUpdateEventListeners = new IPostUpdateEventListener[] {};
 					break;
 				case ListenerType.PostCommitInsert:
-					eventListeners.PostCommitInsertEventListeners = new IPostInsertEventListener[] { };
+					eventListeners.PostCommitInsertEventListeners = new IPostInsertEventListener[] {};
 					break;
 				case ListenerType.PostCommitDelete:
-					eventListeners.PostCommitDeleteEventListeners = new IPostDeleteEventListener[] { };
+					eventListeners.PostCommitDeleteEventListeners = new IPostDeleteEventListener[] {};
 					break;
 				case ListenerType.PreCollectionRecreate:
-					eventListeners.PreCollectionRecreateEventListeners = new IPreCollectionRecreateEventListener[] { };
+					eventListeners.PreCollectionRecreateEventListeners = new IPreCollectionRecreateEventListener[] {};
 					break;
 				case ListenerType.PreCollectionRemove:
-					eventListeners.PreCollectionRemoveEventListeners = new IPreCollectionRemoveEventListener[] { };
+					eventListeners.PreCollectionRemoveEventListeners = new IPreCollectionRemoveEventListener[] {};
 					break;
 				case ListenerType.PreCollectionUpdate:
-					eventListeners.PreCollectionUpdateEventListeners = new IPreCollectionUpdateEventListener[] { };
+					eventListeners.PreCollectionUpdateEventListeners = new IPreCollectionUpdateEventListener[] {};
 					break;
 				case ListenerType.PostCollectionRecreate:
-					eventListeners.PostCollectionRecreateEventListeners = new IPostCollectionRecreateEventListener[] { };
+					eventListeners.PostCollectionRecreateEventListeners = new IPostCollectionRecreateEventListener[] {};
 					break;
 				case ListenerType.PostCollectionRemove:
-					eventListeners.PostCollectionRemoveEventListeners = new IPostCollectionRemoveEventListener[] { };
+					eventListeners.PostCollectionRemoveEventListeners = new IPostCollectionRemoveEventListener[] {};
 					break;
 				case ListenerType.PostCollectionUpdate:
-					eventListeners.PostCollectionUpdateEventListeners = new IPostCollectionUpdateEventListener[] { };
+					eventListeners.PostCollectionUpdateEventListeners = new IPostCollectionUpdateEventListener[] {};
 					break;
 				default:
 					log.Warn("Unrecognized listener type [" + type + "]");
@@ -1800,110 +1791,112 @@
 		public void SetListeners(ListenerType type, object[] listeners)
 		{
 			if (listeners == null)
+			{
 				ClearListeners(type);
+			}
 			switch (type)
 			{
 				case ListenerType.Autoflush:
-					eventListeners.AutoFlushEventListeners = (IAutoFlushEventListener[])listeners;
+					eventListeners.AutoFlushEventListeners = (IAutoFlushEventListener[]) listeners;
 					break;
 				case ListenerType.Merge:
-					eventListeners.MergeEventListeners = (IMergeEventListener[])listeners;
+					eventListeners.MergeEventListeners = (IMergeEventListener[]) listeners;
 					break;
 				case ListenerType.Create:
-					eventListeners.PersistEventListeners = (IPersistEventListener[])listeners;
+					eventListeners.PersistEventListeners = (IPersistEventListener[]) listeners;
 					break;
 				case ListenerType.CreateOnFlush:
-					eventListeners.PersistOnFlushEventListeners = (IPersistEventListener[])listeners;
+					eventListeners.PersistOnFlushEventListeners = (IPersistEventListener[]) listeners;
 					break;
 				case ListenerType.Delete:
-					eventListeners.DeleteEventListeners = (IDeleteEventListener[])listeners;
+					eventListeners.DeleteEventListeners = (IDeleteEventListener[]) listeners;
 					break;
 				case ListenerType.DirtyCheck:
-					eventListeners.DirtyCheckEventListeners = (IDirtyCheckEventListener[])listeners;
+					eventListeners.DirtyCheckEventListeners = (IDirtyCheckEventListener[]) listeners;
 					break;
 				case ListenerType.Evict:
-					eventListeners.EvictEventListeners = (IEvictEventListener[])listeners;
+					eventListeners.EvictEventListeners = (IEvictEventListener[]) listeners;
 					break;
 				case ListenerType.Flush:
-					eventListeners.FlushEventListeners = (IFlushEventListener[])listeners;
+					eventListeners.FlushEventListeners = (IFlushEventListener[]) listeners;
 					break;
 				case ListenerType.FlushEntity:
-					eventListeners.FlushEntityEventListeners = (IFlushEntityEventListener[])listeners;
+					eventListeners.FlushEntityEventListeners = (IFlushEntityEventListener[]) listeners;
 					break;
 				case ListenerType.Load:
-					eventListeners.LoadEventListeners = (ILoadEventListener[])listeners;
+					eventListeners.LoadEventListeners = (ILoadEventListener[]) listeners;
 					break;
 				case ListenerType.LoadCollection:
-					eventListeners.InitializeCollectionEventListeners = (IInitializeCollectionEventListener[])listeners;
+					eventListeners.InitializeCollectionEventListeners = (IInitializeCollectionEventListener[]) listeners;
 					break;
 				case ListenerType.Lock:
-					eventListeners.LockEventListeners = (ILockEventListener[])listeners;
+					eventListeners.LockEventListeners = (ILockEventListener[]) listeners;
 					break;
 				case ListenerType.Refresh:
-					eventListeners.RefreshEventListeners = (IRefreshEventListener[])listeners;
+					eventListeners.RefreshEventListeners = (IRefreshEventListener[]) listeners;
 					break;
 				case ListenerType.Replicate:
-					eventListeners.ReplicateEventListeners = (IReplicateEventListener[])listeners;
+					eventListeners.ReplicateEventListeners = (IReplicateEventListener[]) listeners;
 					break;
 				case ListenerType.SaveUpdate:
-					eventListeners.SaveOrUpdateEventListeners = (ISaveOrUpdateEventListener[])listeners;
+					eventListeners.SaveOrUpdateEventListeners = (ISaveOrUpdateEventListener[]) listeners;
 					break;
 				case ListenerType.Save:
-					eventListeners.SaveEventListeners = (ISaveOrUpdateEventListener[])listeners;
+					eventListeners.SaveEventListeners = (ISaveOrUpdateEventListener[]) listeners;
 					break;
 				case ListenerType.PreUpdate:
-					eventListeners.PreUpdateEventListeners = (IPreUpdateEventListener[])listeners;
+					eventListeners.PreUpdateEventListeners = (IPreUpdateEventListener[]) listeners;
 					break;
 				case ListenerType.Update:
-					eventListeners.UpdateEventListeners = (ISaveOrUpdateEventListener[])listeners;
+					eventListeners.UpdateEventListeners = (ISaveOrUpdateEventListener[]) listeners;
 					break;
 				case ListenerType.PreLoad:
-					eventListeners.PreLoadEventListeners = (IPreLoadEventListener[])listeners;
+					eventListeners.PreLoadEventListeners = (IPreLoadEventListener[]) listeners;
 					break;
 				case ListenerType.PreDelete:
-					eventListeners.PreDeleteEventListeners = (IPreDeleteEventListener[])listeners;
+					eventListeners.PreDeleteEventListeners = (IPreDeleteEventListener[]) listeners;
 					break;
 				case ListenerType.PreInsert:
-					eventListeners.PreInsertEventListeners = (IPreInsertEventListener[])listeners;
+					eventListeners.PreInsertEventListeners = (IPreInsertEventListener[]) listeners;
 					break;
 				case ListenerType.PostLoad:
-					eventListeners.PostLoadEventListeners = (IPostLoadEventListener[])listeners;
+					eventListeners.PostLoadEventListeners = (IPostLoadEventListener[]) listeners;
 					break;
 				case ListenerType.PostInsert:
-					eventListeners.PostInsertEventListeners = (IPostInsertEventListener[])listeners;
+					eventListeners.PostInsertEventListeners = (IPostInsertEventListener[]) listeners;
 					break;
 				case ListenerType.PostUpdate:
-					eventListeners.PostUpdateEventListeners = (IPostUpdateEventListener[])listeners;
+					eventListeners.PostUpdateEventListeners = (IPostUpdateEventListener[]) listeners;
 					break;
 				case ListenerType.PostDelete:
-					eventListeners.PostDeleteEventListeners = (IPostDeleteEventListener[])listeners;
+					eventListeners.PostDeleteEventListeners = (IPostDeleteEventListener[]) listeners;
 					break;
 				case ListenerType.PostCommitUpdate:
-					eventListeners.PostCommitUpdateEventListeners = (IPostUpdateEventListener[])listeners;
+					eventListeners.PostCommitUpdateEventListeners = (IPostUpdateEventListener[]) listeners;
 					break;
 				case ListenerType.PostCommitInsert:
-					eventListeners.PostCommitInsertEventListeners = (IPostInsertEventListener[])listeners;
+					eventListeners.PostCommitInsertEventListeners = (IPostInsertEventListener[]) listeners;
 					break;
 				case ListenerType.PostCommitDelete:
-					eventListeners.PostCommitDeleteEventListeners = (IPostDeleteEventListener[])listeners;
+					eventListeners.PostCommitDeleteEventListeners = (IPostDeleteEventListener[]) listeners;
 					break;
 				case ListenerType.PreCollectionRecreate:
-					eventListeners.PreCollectionRecreateEventListeners = (IPreCollectionRecreateEventListener[])listeners;
+					eventListeners.PreCollectionRecreateEventListeners = (IPreCollectionRecreateEventListener[]) listeners;
 					break;
 				case ListenerType.PreCollectionRemove:
-					eventListeners.PreCollectionRemoveEventListeners = (IPreCollectionRemoveEventListener[])listeners;
+					eventListeners.PreCollectionRemoveEventListeners = (IPreCollectionRemoveEventListener[]) listeners;
 					break;
 				case ListenerType.PreCollectionUpdate:
-					eventListeners.PreCollectionUpdateEventListeners = (IPreCollectionUpdateEventListener[])listeners;
+					eventListeners.PreCollectionUpdateEventListeners = (IPreCollectionUpdateEventListener[]) listeners;
 					break;
 				case ListenerType.PostCollectionRecreate:
-					eventListeners.PostCollectionRecreateEventListeners = (IPostCollectionRecreateEventListener[])listeners;
+					eventListeners.PostCollectionRecreateEventListeners = (IPostCollectionRecreateEventListener[]) listeners;
 					break;
 				case ListenerType.PostCollectionRemove:
-					eventListeners.PostCollectionRemoveEventListeners = (IPostCollectionRemoveEventListener[])listeners;
+					eventListeners.PostCollectionRemoveEventListeners = (IPostCollectionRemoveEventListener[]) listeners;
 					break;
 				case ListenerType.PostCollectionUpdate:
-					eventListeners.PostCollectionUpdateEventListeners = (IPostCollectionUpdateEventListener[])listeners;
+					eventListeners.PostCollectionUpdateEventListeners = (IPostCollectionUpdateEventListener[]) listeners;
 					break;
 				default:
 					log.Warn("Unrecognized listener type [" + type + "]");
@@ -1922,13 +1915,13 @@
 			string defaultCatalog = PropertiesHelper.GetString(Environment.DefaultCatalog, properties, null);
 			string defaultSchema = PropertiesHelper.GetString(Environment.DefaultSchema, properties, null);
 
-			List<string> script = new List<string>(50);
-			foreach (Table table in TableMappings)
+			var script = new List<string>(50);
+			foreach (var table in TableMappings)
 			{
 				if (table.IsPhysicalTable)
 				{
 					ITableMetadata tableInfo = databaseMetadata.GetTableMetadata(table.Name, table.Schema ?? defaultSchema,
-						table.Catalog ?? defaultCatalog, table.IsQuoted);
+					                                                             table.Catalog ?? defaultCatalog, table.IsQuoted);
 					if (tableInfo == null)
 					{
 						script.Add(table.SqlCreateString(dialect, mapping, defaultCatalog, defaultSchema));
@@ -1941,27 +1934,26 @@
 
 					string[] comments = table.SqlCommentStrings(dialect, defaultCatalog, defaultSchema);
 					script.AddRange(comments);
-
 				}
 			}
 
-			foreach (Table table in TableMappings)
+			foreach (var table in TableMappings)
 			{
 				if (table.IsPhysicalTable)
 				{
-					ITableMetadata tableInfo =
-						databaseMetadata.GetTableMetadata(table.Name, table.Schema, table.Catalog, table.IsQuoted);
+					ITableMetadata tableInfo = databaseMetadata.GetTableMetadata(table.Name, table.Schema, table.Catalog,
+					                                                             table.IsQuoted);
 
 					if (dialect.HasAlterTable)
 					{
-						foreach (ForeignKey fk in table.ForeignKeyIterator)
+						foreach (var fk in table.ForeignKeyIterator)
 						{
 							if (fk.HasPhysicalConstraint)
 							{
-								bool create = tableInfo == null || (
-										tableInfo.GetForeignKeyMetadata(fk.Name) == null &&
-										(!(dialect is MySQLDialect) || tableInfo.GetIndexMetadata(fk.Name) == null)
-									);
+								bool create = tableInfo == null
+								              ||
+								              (tableInfo.GetForeignKeyMetadata(fk.Name) == null
+								               && (!(dialect is MySQLDialect) || tableInfo.GetIndexMetadata(fk.Name) == null));
 								if (create)
 								{
 									script.Add(fk.SqlCreateString(dialect, mapping, defaultCatalog, defaultSchema));
@@ -1969,11 +1961,10 @@
 							}
 						}
 					}
-
 				}
 			}
 
-			foreach (IPersistentIdentifierGenerator generator in IterateGenerators(dialect))
+			foreach (var generator in IterateGenerators(dialect))
 			{
 				string key = generator.GeneratorKey();
 				if (!databaseMetadata.IsSequence(key) && !databaseMetadata.IsTable(key))
@@ -1991,38 +1982,41 @@
 
 		private IEnumerable<IPersistentIdentifierGenerator> IterateGenerators(Dialect.Dialect dialect)
 		{
-			Dictionary<string, IPersistentIdentifierGenerator> generators =
-				new Dictionary<string, IPersistentIdentifierGenerator>();
+			var generators = new Dictionary<string, IPersistentIdentifierGenerator>();
 			string defaultCatalog = PropertiesHelper.GetString(Environment.DefaultCatalog, properties, null);
 			string defaultSchema = PropertiesHelper.GetString(Environment.DefaultSchema, properties, null);
 
-			foreach (PersistentClass pc in classes.Values)
+			foreach (var pc in classes.Values)
 			{
 				if (!pc.IsInherited)
 				{
-					IPersistentIdentifierGenerator ig =
-						pc.Identifier.CreateIdentifierGenerator(dialect, defaultCatalog, defaultSchema, (RootClass)pc) as
+					var ig =
+						pc.Identifier.CreateIdentifierGenerator(dialect, defaultCatalog, defaultSchema, (RootClass) pc) as
 						IPersistentIdentifierGenerator;
 
 					if (ig != null)
+					{
 						generators[ig.GeneratorKey()] = ig;
+					}
 				}
 			}
 
-			foreach (NHibernate.Mapping.Collection collection in collections.Values)
+			foreach (var collection in collections.Values)
 			{
 				if (collection.IsIdentified)
 				{
-					IPersistentIdentifierGenerator ig =
-						((IdentifierCollection)collection).Identifier.CreateIdentifierGenerator(dialect, defaultCatalog, defaultSchema,
-																																										 null) as IPersistentIdentifierGenerator;
+					var ig =
+						((IdentifierCollection) collection).Identifier.CreateIdentifierGenerator(dialect, defaultCatalog, defaultSchema,
+						                                                                         null) as IPersistentIdentifierGenerator;
 
 					if (ig != null)
+					{
 						generators[ig.GeneratorKey()] = ig;
+					}
 				}
 			}
 
 			return generators.Values;
 		}
 	}
-}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/InvalidProxyTypeException.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/InvalidProxyTypeException.cs	2008-10-11 05:54:37 UTC (rev 3841)
+++ trunk/nhibernate/src/NHibernate/InvalidProxyTypeException.cs	2008-10-11 12:59:51 UTC (rev 3842)
@@ -3,6 +3,7 @@
 using System.Runtime.Serialization;
 using System.Security.Permissions;
 using System.Text;
+using System.Collections.Generic;
 
 namespace NHibernate
 {
@@ -14,22 +15,17 @@
 	[Serializable]
 	public class InvalidProxyTypeException : MappingException
 	{
-		private ICollection errors;
-
-		public InvalidProxyTypeException(ICollection errors)
+		public InvalidProxyTypeException(ICollection<string> errors)
 			: base(FormatMessage(errors))
 		{
-			this.errors = errors;
+			Errors = errors;
 		}
 
-		public ICollection Errors
-		{
-			get { return errors; }
-		}
+		public ICollection<string> Errors { get; private set; }
 
-		private static string FormatMessage(ICollection errors)
+		private static string FormatMessage(IEnumerable<string> errors)
 		{
-			StringBuilder result = new StringBuilder("The following types may not be used as proxies:");
+			var result = new StringBuilder("The following types may not be used as proxies:");
 			foreach (string error in errors)
 			{
 				result.Append('\n').Append(error);
@@ -42,7 +38,7 @@
 		public InvalidProxyTypeException(SerializationInfo info, StreamingContext context)
 			: base(info, context)
 		{
-			this.errors = (ICollection) info.GetValue("errors", typeof(ICollection));
+			Errors = (ICollection<string>)info.GetValue("errors", typeof(ICollection));
 		}
 
 		[SecurityPermission(SecurityAction.LinkDemand,
@@ -50,7 +46,7 @@
 		public override void GetObjectData(SerializationInfo info, StreamingContext context)
 		{
 			base.GetObjectData(info, context);
-			info.AddValue("errors", errors, typeof(ICollection));
+			info.AddValue("errors", Errors, typeof(ICollection));
 		}
 
 		#endregion

Modified: trunk/nhibernate/src/NHibernate/Proxy/ProxyTypeValidator.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Proxy/ProxyTypeValidator.cs	2008-10-11 05:54:37 UTC (rev 3841)
+++ trunk/nhibernate/src/NHibernate/Proxy/ProxyTypeValidator.cs	2008-10-11 12:59:51 UTC (rev 3842)
@@ -1,6 +1,5 @@
-using System;
 using System.Collections;
-using System.Collections.Specialized;
+using System.Collections.Generic;
 using System.Reflection;
 using NHibernate.Util;
 
@@ -8,9 +7,7 @@
 {
 	public class ProxyTypeValidator
 	{
-		private ProxyTypeValidator()
-		{
-		}
+		private ProxyTypeValidator() {}
 
 		/// <summary>
 		/// Validates whether <paramref name="type"/> can be specified as the base class
@@ -20,9 +17,9 @@
 		/// A collection of errors, if any, or <see langword="null" /> if none were found.
 		/// </returns>
 		/// <param name="type">The type to validate.</param>
-		public static ICollection ValidateType(System.Type type)
+		public static ICollection<string> ValidateType(System.Type type)
 		{
-			StringCollection errors = new StringCollection();
+			var errors = new List<string>();
 
 			if (type.IsInterface)
 			{
@@ -60,7 +57,7 @@
 			{
 				if (member is PropertyInfo)
 				{
-					PropertyInfo property = (PropertyInfo) member;
+					var property = (PropertyInfo) member;
 					MethodInfo[] accessors = property.GetAccessors(false);
 
 					foreach (MethodInfo accessor in accessors)
@@ -70,8 +67,7 @@
 				}
 				else if (member is MethodInfo)
 				{
-					if (member.DeclaringType == typeof(object)
-					    && member.Name == "GetType")
+					if (member.DeclaringType == typeof (object) && member.Name == "GetType")
 					{
 						// object.GetType is ignored
 						continue;
@@ -80,7 +76,7 @@
 				}
 				else if (member is FieldInfo)
 				{
-					FieldInfo memberField = (FieldInfo) member;
+					var memberField = (FieldInfo) member;
 					if (memberField.IsPublic || memberField.IsAssembly || memberField.IsFamilyOrAssembly)
 					{
 						Error(errors, type, "field " + member.Name + " should not be public nor internal");
@@ -91,12 +87,12 @@
 
 		private static void CheckMethodIsVirtual(System.Type type, MethodInfo method, IList errors)
 		{
-			if (method.DeclaringType != typeof(object) && !IsDisposeMethod(method) &&
-				method.IsPublic || method.IsAssembly || method.IsFamilyOrAssembly)
+			if (method.DeclaringType != typeof (object) && !IsDisposeMethod(method) && method.IsPublic || method.IsAssembly
+			    || method.IsFamilyOrAssembly)
 			{
-				if (!method.IsVirtual || method.IsFinal)
+				if (!method.IsVirtual || method.IsFinal || (method.IsVirtual && method.IsAssembly))
 				{
-					Error(errors, type, "method " + method.Name + " should be virtual");
+					Error(errors, type, "method " + method.Name + " should be 'public/protected virtual' or 'protected internal virtual'");
 				}
 			}
 		}
@@ -108,12 +104,11 @@
 
 		private static bool HasVisibleDefaultConstructor(System.Type type)
 		{
-			ConstructorInfo constructor = type.GetConstructor(
-				BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
-				null, System.Type.EmptyTypes, null);
+			ConstructorInfo constructor =
+				type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null,
+				                    System.Type.EmptyTypes, null);
 
-			return constructor != null
-			       && !constructor.IsPrivate;
+			return constructor != null && !constructor.IsPrivate;
 		}
 
 		private static void CheckNotSealed(System.Type type, IList errors)
@@ -124,4 +119,4 @@
 			}
 		}
 	}
-}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Tuple/Entity/PocoEntityTuplizer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Tuple/Entity/PocoEntityTuplizer.cs	2008-10-11 05:54:37 UTC (rev 3841)
+++ trunk/nhibernate/src/NHibernate/Tuple/Entity/PocoEntityTuplizer.cs	2008-10-11 12:59:51 UTC (rev 3842)
@@ -92,8 +92,7 @@
 
 			// determine the id getter and setter methods from the proxy interface (if any)
 			// determine all interfaces needed by the resulting proxy
-			HashedSet<System.Type> proxyInterfaces = new HashedSet<System.Type>();
-			proxyInterfaces.Add(typeof(INHibernateProxy));
+			var proxyInterfaces = new HashedSet<System.Type> {typeof (INHibernateProxy)};
 
 			System.Type _mappedClass = persistentClass.MappedClass;
 			System.Type _proxyInterface = persistentClass.ProxyInterface;
@@ -167,20 +166,18 @@
 		private static void LogPropertyAccessorsErrors(PersistentClass persistentClass)
 		{
 			// This method work when Environment.UseProxyValidator is off
-
 			System.Type clazz = persistentClass.MappedClass;
 			foreach (Mapping.Property property in persistentClass.PropertyIterator)
 			{
 				MethodInfo method = property.GetGetter(clazz).Method;
-				// In NET if IsVirtual is false or IsFinal is true, then the method cannot be overridden.
-				if (method != null && (!method.IsVirtual || method.IsFinal))
+				if (ShouldLogError(method))
 				{
 					log.Error(
 						string.Format("Getters of lazy classes cannot be final: {0}.{1}", persistentClass.MappedClass.FullName,
 						              property.Name));
 				}
 				method = property.GetSetter(clazz).Method;
-				if (method != null && (!method.IsVirtual || method.IsFinal))
+				if (ShouldLogError(method))
 				{
 					log.Error(
 						string.Format("Setters of lazy classes cannot be final: {0}.{1}", persistentClass.MappedClass.FullName,
@@ -189,6 +186,12 @@
 			}
 		}
 
+		private static bool ShouldLogError(MethodBase method)
+		{
+			// In NET if IsVirtual is false or IsFinal is true, then the method cannot be overridden.
+			return method != null && (!method.IsVirtual || method.IsFinal || (method.IsVirtual && method.IsAssembly));
+		}
+
 		protected virtual IProxyFactory BuildProxyFactoryInternal(PersistentClass @class, IGetter getter, ISetter setter)
 		{
 			return Cfg.Environment.BytecodeProvider.ProxyFactoryFactory.BuildProxyFactory();
@@ -284,7 +287,7 @@
 
 		public override EntityMode EntityMode
 		{
-			get { return NHibernate.EntityMode.Poco; }
+			get { return EntityMode.Poco; }
 		}
 	}
 }

Modified: trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH1408/DbResourceKey.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH1408/DbResourceKey.cs	2008-10-11 05:54:37 UTC (rev 3841)
+++ trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH1408/DbResourceKey.cs	2008-10-11 12:59:51 UTC (rev 3842)
@@ -31,7 +31,7 @@
 		public virtual DbResource Resource
 		{
 			get { return resource; }
-			internal set { resource = value; }
+			protected internal set { resource = value; }
 		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH1464/Fixture.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH1464/Fixture.cs	2008-10-11 05:54:37 UTC (rev 3841)
+++ trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH1464/Fixture.cs	2008-10-11 12:59:51 UTC (rev 3842)
@@ -1,8 +1,8 @@
 using System;
-using System.Collections;
 using NHibernate.Proxy;
 using NUnit.Framework;
 using NUnit.Framework.SyntaxHelpers;
+using System.Collections.Generic;
 
 namespace NHibernate.Test.NHSpecificTest.NH1464
 {
@@ -61,7 +61,7 @@
 		[Test]
 		public void NoExceptionForDispose()
 		{
-			ICollection errs = ProxyTypeValidator.ValidateType(typeof (CPPMimic));
+			ICollection<string> errs = ProxyTypeValidator.ValidateType(typeof (CPPMimic));
 			Assert.That(errs, Is.Null);
 			errs = ProxyTypeValidator.ValidateType(typeof(Another));
 			Assert.That(errs, Is.Null);

Added: trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH1515/Fixture.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH1515/Fixture.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH1515/Fixture.cs	2008-10-11 12:59:51 UTC (rev 3842)
@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using NHibernate.Proxy;
+using NUnit.Framework;
+using NUnit.Framework.SyntaxHelpers;
+
+namespace NHibernate.Test.NHSpecificTest.NH1515
+{
+	[TestFixture]
+	public class Fixture
+	{
+		public class ClassWithInternal
+		{
+			internal virtual void DoSomething() {}
+		}
+
+		public class ClassWithInternalProperty
+		{
+			internal virtual string DoSomething { get; set; }
+		}
+
+		[Test]
+		public void NoExceptionForMethod()
+		{
+			ICollection<string> errs = ProxyTypeValidator.ValidateType(typeof(ClassWithInternal));
+			Assert.That(errs, Is.Not.Null);
+			Assert.That(errs.Count, Is.EqualTo(1));
+		}
+
+		[Test]
+		public void NoExceptionForProperty()
+		{
+			ICollection<string> errs = ProxyTypeValidator.ValidateType(typeof(ClassWithInternalProperty));
+			Assert.That(errs, Is.Not.Null);
+			Assert.That(errs.Count, Is.EqualTo(2));
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/ProxyValidator/Fixture.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/ProxyValidator/Fixture.cs	2008-10-11 05:54:37 UTC (rev 3841)
+++ trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/ProxyValidator/Fixture.cs	2008-10-11 12:59:51 UTC (rev 3842)
@@ -2,6 +2,7 @@
 using System.Collections;
 using NHibernate.Proxy;
 using NUnit.Framework;
+using System.Collections.Generic;
 
 namespace NHibernate.Test.NHSpecificTest.ProxyValidator
 {
@@ -10,7 +11,7 @@
 	{
 		private void Validate(System.Type type)
 		{
-			ICollection errors = ProxyTypeValidator.ValidateType(type);
+			ICollection<string> errors = ProxyTypeValidator.ValidateType(type);
 			if (errors != null)
 			{
 				throw new InvalidProxyTypeException(errors);

Modified: trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2008-10-11 05:54:37 UTC (rev 3841)
+++ trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2008-10-11 12:59:51 UTC (rev 3842)
@@ -507,6 +507,7 @@
     <Compile Include="NHSpecificTest\NH1508\Document.cs" />
     <Compile Include="NHSpecificTest\NH1508\Fixture.cs" />
     <Compile Include="NHSpecificTest\NH1508\Person.cs" />
+    <Compile Include="NHSpecificTest\NH1515\Fixture.cs" />
     <Compile Include="NHSpecificTest\NH280\Fixture.cs" />
     <Compile Include="NHSpecificTest\NH280\Foo.cs" />
     <Compile Include="NHSpecificTest\NH1018\Employee.cs" />


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.