Menu
▾
▴
[Nhibernate-commit] SF.net SVN: nhibernate:[3644] trunk/nhibernate/src/NHibernate
|
From: <fab...@us...> - 2008-07-21 15:21:29
|
Revision: 3644
http://nhibernate.svn.sourceforge.net/nhibernate/?rev=3644&view=rev
Author: fabiomaulo
Date: 2008-07-21 15:21:34 +0000 (Mon, 21 Jul 2008)
Log Message:
-----------
- Support for EntityMode.Map (NH-1401)
- Support DefaultEntityMode in Settings (NH-1401)
- Support Cache for Dynamic entities (NH-1402)
BREAKING CHANGE:
- see Configuration.cs for method related with Cache Concurrency Strategy
Modified Paths:
--------------
trunk/nhibernate/src/NHibernate/Cfg/ClassExtractor.cs
trunk/nhibernate/src/NHibernate/Cfg/Configuration.cs
trunk/nhibernate/src/NHibernate/Cfg/Environment.cs
trunk/nhibernate/src/NHibernate/Cfg/MappingsQueueEntry.cs
trunk/nhibernate/src/NHibernate/Cfg/SettingsFactory.cs
trunk/nhibernate/src/NHibernate/Cfg/XmlHbmBinding/ClassBinder.cs
trunk/nhibernate/src/NHibernate/Cfg/XmlHbmBinding/ClassIdBinder.cs
trunk/nhibernate/src/NHibernate/Cfg/XmlHbmBinding/CollectionBinder.cs
trunk/nhibernate/src/NHibernate/Tuple/Entity/EntityMetamodel.cs
trunk/nhibernate/src/NHibernate/nhibernate-configuration.xsd
trunk/nhibernate/src/NHibernate.Test/NHibernate.Test-2.0.csproj
trunk/nhibernate/src/NHibernate.Test/TestCase.cs
Added Paths:
-----------
trunk/nhibernate/src/NHibernate.Test/EntityModeTest/
trunk/nhibernate/src/NHibernate.Test/EntityModeTest/Map/
trunk/nhibernate/src/NHibernate.Test/EntityModeTest/Map/Basic/
trunk/nhibernate/src/NHibernate.Test/EntityModeTest/Map/Basic/DynamicClassFixture.cs
trunk/nhibernate/src/NHibernate.Test/EntityModeTest/Map/Basic/ProductLine.hbm.xml
Modified: trunk/nhibernate/src/NHibernate/Cfg/ClassExtractor.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cfg/ClassExtractor.cs 2008-07-21 05:23:55 UTC (rev 3643)
+++ trunk/nhibernate/src/NHibernate/Cfg/ClassExtractor.cs 2008-07-21 15:21:34 UTC (rev 3644)
@@ -1,4 +1,3 @@
-using System;
using System.Collections;
using System.Xml;
using Iesi.Collections;
@@ -23,7 +22,7 @@
public ClassEntry(string extends, string className, string assembly, string @namespace)
{
_fullExtends = extends == null ? null : TypeNameParser.Parse(extends, @namespace, assembly);
- _fullClassName = TypeNameParser.Parse(className, @namespace, assembly);
+ _fullClassName = className == null ? null : TypeNameParser.Parse(className, @namespace, assembly);
}
public AssemblyQualifiedTypeName FullExtends
Modified: trunk/nhibernate/src/NHibernate/Cfg/Configuration.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cfg/Configuration.cs 2008-07-21 05:23:55 UTC (rev 3643)
+++ trunk/nhibernate/src/NHibernate/Cfg/Configuration.cs 2008-07-21 15:21:34 UTC (rev 3644)
@@ -444,25 +444,25 @@
/// </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,
+ return new Mappings(classes,
+ collections,
+ tables,
+ namedQueries,
+ namedSqlQueries,
+ sqlResultSetMappings,
+ imports,
+ secondPasses,
+ propertyReferences,
+ namingStrategy,
+ typeDefs,
+ filterDefinitions,
+ extendsQueue,
+ auxiliaryDatabaseObjects,
+ tableNameBinding,
columnNameBindingPerTable,
defaultAssembly,
defaultNamespace,
- dialect
+ dialect
);
}
@@ -1291,19 +1291,9 @@
// Load class-cache
foreach (ClassCacheConfiguration ccc in hc.SessionFactory.ClassesCache)
{
- System.Type clazz;
- try
- {
- clazz = ReflectHelper.ClassForName(ccc.Class);
- }
- catch (TypeLoadException tle)
- {
- throw new HibernateConfigException("class-cache Configuration: Could not find class " + ccc.Class, tle);
- }
-
string region = string.IsNullOrEmpty(ccc.Region) ? ccc.Class : ccc.Region;
bool includeLazy = (ccc.Include != ClassCacheInclude.NonLazy);
- SetCacheConcurrencyStrategy(clazz, CfgXmlHelper.ClassCacheUsageConvertToString(ccc.Usage), region, includeLazy);
+ SetCacheConcurrencyStrategy(ccc.Class, CfgXmlHelper.ClassCacheUsageConvertToString(ccc.Usage), region, includeLazy);
}
// Load collection-cache
@@ -1317,7 +1307,7 @@
}
string region = string.IsNullOrEmpty(ccc.Region) ? role : ccc.Region;
- SetCacheConcurrencyStrategy(role, CfgXmlHelper.ClassCacheUsageConvertToString(ccc.Usage), region);
+ SetCollectionCacheConcurrencyStrategy(role, CfgXmlHelper.ClassCacheUsageConvertToString(ccc.Usage), region);
}
// Events
@@ -1347,6 +1337,20 @@
return this;
}
+ internal RootClass GetRootClassMapping(string clazz)
+ {
+ try
+ {
+ 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 + ")");
+ }
+ }
+
internal RootClass GetRootClassMapping(System.Type clazz)
{
PersistentClass persistentClass = GetClassMapping(clazz);
@@ -1371,36 +1375,40 @@
/// <summary>
/// Set up a cache for an entity class
/// </summary>
- public Configuration SetCacheConcurrencyStrategy(System.Type clazz, string concurrencyStrategy)
+ public Configuration SetCacheConcurrencyStrategy(String clazz, String concurrencyStrategy)
{
- SetCacheConcurrencyStrategy(clazz, concurrencyStrategy, clazz.FullName);
+ SetCacheConcurrencyStrategy(clazz, concurrencyStrategy, clazz);
return this;
}
- internal void SetCacheConcurrencyStrategy(System.Type clazz, string concurrencyStrategy, string region)
+ public void SetCacheConcurrencyStrategy(String clazz, String concurrencyStrategy, String region)
{
SetCacheConcurrencyStrategy(clazz, concurrencyStrategy, region, true);
}
- internal void SetCacheConcurrencyStrategy(System.Type clazz, string concurrencyStrategy,
- string region, bool includeLazy)
+ internal void SetCacheConcurrencyStrategy(String clazz, String concurrencyStrategy, String region, bool includeLazy)
{
- RootClass rootClass = GetRootClassMapping(clazz);
+ RootClass rootClass = GetRootClassMapping(StringHelper.GetFullClassname(clazz));
+ if (rootClass == null)
+ {
+ throw new HibernateConfigException("Cannot cache an unknown entity: " + clazz);
+ }
rootClass.CacheConcurrencyStrategy = concurrencyStrategy;
rootClass.CacheRegionName = region;
rootClass.SetLazyPropertiesCacheable(includeLazy);
}
+
/// <summary>
/// Set up a cache for a collection role
/// </summary>
- public Configuration SetCacheConcurrencyStrategy(string collectionRole, string concurrencyStrategy)
+ public Configuration SetCollectionCacheConcurrencyStrategy(string collectionRole, string concurrencyStrategy)
{
- SetCacheConcurrencyStrategy(collectionRole, concurrencyStrategy, collectionRole);
+ SetCollectionCacheConcurrencyStrategy(collectionRole, concurrencyStrategy, collectionRole);
return this;
}
- internal void SetCacheConcurrencyStrategy(string collectionRole, string concurrencyStrategy, string region)
+ internal void SetCollectionCacheConcurrencyStrategy(string collectionRole, string concurrencyStrategy, string region)
{
NHibernate.Mapping.Collection collection = GetCollectionMapping(collectionRole);
collection.CacheConcurrencyStrategy = concurrencyStrategy;
@@ -1613,7 +1621,7 @@
else
{
object[] listeners =
- (object[]) System.Array.CreateInstance(eventListeners.GetListenerClassFor(type), listenerClasses.Length);
+ (object[])System.Array.CreateInstance(eventListeners.GetListenerClassFor(type), listenerClasses.Length);
for (int i = 0; i < listeners.Length; i++)
{
try
@@ -1657,88 +1665,88 @@
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;
default:
log.Warn("Unrecognized listener type [" + type + "]");
@@ -1760,88 +1768,88 @@
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;
default:
log.Warn("Unrecognized listener type [" + type + "]");
@@ -1865,7 +1873,7 @@
{
if (table.IsPhysicalTable)
{
- ITableMetadata tableInfo = databaseMetadata.GetTableMetadata(table.Name, table.Schema ?? defaultSchema,
+ ITableMetadata tableInfo = databaseMetadata.GetTableMetadata(table.Name, table.Schema ?? defaultSchema,
table.Catalog ?? defaultCatalog, table.IsQuoted);
if (tableInfo == null)
{
@@ -1897,7 +1905,7 @@
if (fk.HasPhysicalConstraint)
{
bool create = tableInfo == null || (
- tableInfo.GetForeignKeyMetadata(fk.Name) == null &&
+ tableInfo.GetForeignKeyMetadata(fk.Name) == null &&
(!(dialect is MySQLDialect) || tableInfo.GetIndexMetadata(fk.Name) == null)
);
if (create)
@@ -1939,7 +1947,7 @@
if (!pc.IsInherited)
{
IPersistentIdentifierGenerator ig =
- pc.Identifier.CreateIdentifierGenerator(dialect, defaultCatalog, defaultSchema, (RootClass) pc) as
+ pc.Identifier.CreateIdentifierGenerator(dialect, defaultCatalog, defaultSchema, (RootClass)pc) as
IPersistentIdentifierGenerator;
if (ig != null)
@@ -1952,8 +1960,8 @@
if (collection.IsIdentified)
{
IPersistentIdentifierGenerator ig =
- ((IdentifierCollection) collection).Identifier.CreateIdentifierGenerator(dialect, defaultCatalog, defaultSchema,
- null) as IPersistentIdentifierGenerator;
+ ((IdentifierCollection)collection).Identifier.CreateIdentifierGenerator(dialect, defaultCatalog, defaultSchema,
+ null) as IPersistentIdentifierGenerator;
if (ig != null)
generators[ig.GeneratorKey()] = ig;
Modified: trunk/nhibernate/src/NHibernate/Cfg/Environment.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cfg/Environment.cs 2008-07-21 05:23:55 UTC (rev 3643)
+++ trunk/nhibernate/src/NHibernate/Cfg/Environment.cs 2008-07-21 15:21:34 UTC (rev 3644)
@@ -49,8 +49,8 @@
{
Assembly thisAssembly = Assembly.GetExecutingAssembly();
AssemblyInformationalVersionAttribute[] attrs = (AssemblyInformationalVersionAttribute[])
- thisAssembly.GetCustomAttributes(
- typeof(AssemblyInformationalVersionAttribute), false);
+ thisAssembly.GetCustomAttributes(
+ typeof(AssemblyInformationalVersionAttribute), false);
if (attrs != null && attrs.Length > 0)
{
@@ -85,6 +85,9 @@
/// <summary> A default database catalog name to use for unqualified tablenames</summary>
public const string DefaultCatalog = "default_catalog";
+ /// <summary>The EntityMode in which set the Session opened from the SessionFactory.</summary>
+ public const string DefaultEntityMode = "default_entity_mode";
+
public const string ShowSql = "show_sql";
public const string MaxFetchDepth = "max_fetch_depth";
public const string CurrentSessionContextClass = "current_session_context_class";
@@ -192,7 +195,7 @@
if (config == null)
{
- log.Info(string.Format("{0} section not found in application configuration file",CfgXmlHelper.CfgSectionName));
+ log.Info(string.Format("{0} section not found in application configuration file", CfgXmlHelper.CfgSectionName));
return;
}
@@ -246,7 +249,7 @@
/// </remarks>
public static IDictionary<string, string> Properties
{
- get { return new Dictionary<string,string>(GlobalProperties); }
+ get { return new Dictionary<string, string>(GlobalProperties); }
}
[Obsolete]
@@ -293,7 +296,7 @@
{
string defaultBytecodeProvider = "lcg";
string provider = PropertiesHelper.GetString(PropertyBytecodeProvider, properties,
- defaultBytecodeProvider);
+ defaultBytecodeProvider);
log.Info("Bytecode provider name : " + provider);
return BuildBytecodeProvider(provider);
}
Modified: trunk/nhibernate/src/NHibernate/Cfg/MappingsQueueEntry.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cfg/MappingsQueueEntry.cs 2008-07-21 05:23:55 UTC (rev 3643)
+++ trunk/nhibernate/src/NHibernate/Cfg/MappingsQueueEntry.cs 2008-07-21 15:21:34 UTC (rev 3644)
@@ -33,7 +33,8 @@
foreach (ClassExtractor.ClassEntry ce in classEntries)
{
- result.Add(ce.FullClassName);
+ if (ce.FullClassName != null)
+ result.Add(ce.FullClassName);
}
return result;
@@ -69,4 +70,4 @@
get { return containedClassNames; }
}
}
-}
\ No newline at end of file
+}
Modified: trunk/nhibernate/src/NHibernate/Cfg/SettingsFactory.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cfg/SettingsFactory.cs 2008-07-21 05:23:55 UTC (rev 3643)
+++ trunk/nhibernate/src/NHibernate/Cfg/SettingsFactory.cs 2008-07-21 15:21:34 UTC (rev 3644)
@@ -99,12 +99,12 @@
log.Info("Default schema: " + defaultSchema);
if (defaultCatalog != null)
log.Info("Default catalog: " + defaultCatalog);
- settings.DefaultSchemaName=defaultSchema;
- settings.DefaultCatalogName=defaultCatalog;
+ settings.DefaultSchemaName = defaultSchema;
+ settings.DefaultCatalogName = defaultCatalog;
int batchFetchSize = PropertiesHelper.GetInt32(Environment.DefaultBatchFetchSize, properties, 1);
log.Info("Default batch fetch size: " + batchFetchSize);
- settings.DefaultBatchFetchSize= batchFetchSize;
+ settings.DefaultBatchFetchSize = batchFetchSize;
//Statistics and logging:
@@ -126,11 +126,11 @@
settings.QueryTranslatorFactory = CreateQueryTranslatorFactory(properties);
- IDictionary<string, string> querySubstitutions =
- PropertiesHelper.ToDictionary(Environment.QuerySubstitutions, " ,=;:\n\t\r\f", properties);
+ IDictionary<string, string> querySubstitutions = PropertiesHelper.ToDictionary(Environment.QuerySubstitutions,
+ " ,=;:\n\t\r\f", properties);
if (log.IsInfoEnabled)
{
- log.Info("Query language substitutions: " + CollectionPrinter.ToString((IDictionary)querySubstitutions));
+ log.Info("Query language substitutions: " + CollectionPrinter.ToString((IDictionary) querySubstitutions));
}
string autoSchemaExport = PropertiesHelper.GetString(Environment.Hbm2ddlAuto, properties, null);
@@ -169,13 +169,13 @@
if (useQueryCache)
{
- string queryCacheFactoryClassName =
- PropertiesHelper.GetString(Environment.QueryCacheFactory, properties, typeof(StandardQueryCacheFactory).FullName);
+ string queryCacheFactoryClassName = PropertiesHelper.GetString(Environment.QueryCacheFactory, properties,
+ typeof (StandardQueryCacheFactory).FullName);
log.Info("query cache factory: " + queryCacheFactoryClassName);
try
{
- settings.QueryCacheFactory = (IQueryCacheFactory) Activator.CreateInstance(
- ReflectHelper.ClassForName(queryCacheFactoryClassName));
+ settings.QueryCacheFactory =
+ (IQueryCacheFactory) Activator.CreateInstance(ReflectHelper.ClassForName(queryCacheFactoryClassName));
}
catch (Exception cnfe)
{
@@ -200,18 +200,23 @@
{
try
{
- isolation = (IsolationLevel) Enum.Parse(typeof(IsolationLevel), isolationString);
+ isolation = (IsolationLevel) Enum.Parse(typeof (IsolationLevel), isolationString);
log.Info("Using Isolation Level: " + isolation);
}
catch (ArgumentException ae)
{
log.Error("error configuring IsolationLevel " + isolationString, ae);
throw new HibernateException(
- "The isolation level of " + isolationString + " is not a valid IsolationLevel. Please " +
- "use one of the Member Names from the IsolationLevel.", ae);
+ "The isolation level of " + isolationString + " is not a valid IsolationLevel. Please "
+ + "use one of the Member Names from the IsolationLevel.", ae);
}
}
+ EntityMode defaultEntityMode =
+ EntityModeHelper.Parse(PropertiesHelper.GetString(Environment.DefaultEntityMode, properties, "poco"));
+ log.Info("Default entity-mode: " + defaultEntityMode);
+ settings.DefaultEntityMode = defaultEntityMode;
+
bool namedQueryChecking = PropertiesHelper.GetBoolean(Environment.QueryStartupChecking, properties, true);
log.Info("Named query checking : " + EnabledDisabled(namedQueryChecking));
settings.IsNamedQueryStartupCheckingEnabled = namedQueryChecking;
Modified: trunk/nhibernate/src/NHibernate/Cfg/XmlHbmBinding/ClassBinder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cfg/XmlHbmBinding/ClassBinder.cs 2008-07-21 05:23:55 UTC (rev 3643)
+++ trunk/nhibernate/src/NHibernate/Cfg/XmlHbmBinding/ClassBinder.cs 2008-07-21 15:21:34 UTC (rev 3644)
@@ -147,9 +147,11 @@
// IMPORT
// For entities, the EntityName is the key to find a persister
// NH Different behavior: we are using the association between EntityName and its more certain implementation (AssemblyQualifiedName)
- mappings.AddImport(model.MappedClass.AssemblyQualifiedName, model.EntityName);
+ // Dynamic entities have no class, reverts to EntityName. -AK
+ string qualifiedName = model.MappedClass == null ? model.EntityName : model.MappedClass.AssemblyQualifiedName;
+ mappings.AddImport(qualifiedName, model.EntityName);
if (mappings.IsAutoImport && model.EntityName.IndexOf('.') > 0)
- mappings.AddImport(model.MappedClass.AssemblyQualifiedName, StringHelper.Unqualify(model.EntityName));
+ mappings.AddImport(qualifiedName, StringHelper.Unqualify(model.EntityName));
// BATCH SIZE
XmlAttribute batchNode = node.Attributes["batch-size"];
@@ -1175,20 +1177,14 @@
return type;
}
- private static string GetEntityName(XmlNode elem, Mappings model)
+ protected static string GetEntityName(XmlNode elem, Mappings model)
{
string entityName = XmlHelper.GetAttributeValue(elem, "entity-name");
- if (entityName == null)
- {
- XmlAttribute att = elem.Attributes["class"];
+ string className = XmlHelper.GetAttributeValue(elem, "class");
+ entityName = entityName
+ ?? (className == null ? null : StringHelper.GetFullClassname(FullClassName(className, model)));
- return att == null ? null : GetClassName(att.Value, model);
- }
- else
- {
- return entityName;
- }
-
+ return entityName;
}
protected XmlNodeList SelectNodes(XmlNode node, string xpath)
Modified: trunk/nhibernate/src/NHibernate/Cfg/XmlHbmBinding/ClassIdBinder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cfg/XmlHbmBinding/ClassIdBinder.cs 2008-07-21 05:23:55 UTC (rev 3643)
+++ trunk/nhibernate/src/NHibernate/Cfg/XmlHbmBinding/ClassIdBinder.cs 2008-07-21 15:21:34 UTC (rev 3644)
@@ -1,10 +1,7 @@
-using System.Collections;
using System.Collections.Generic;
using System.Xml;
-
using NHibernate.Cfg.MappingSchema;
using NHibernate.Mapping;
-using NHibernate.Type;
using NHibernate.Util;
namespace NHibernate.Cfg.XmlHbmBinding
@@ -29,7 +26,7 @@
AddColumns(idSchema, id);
CreateIdentifierProperty(idSchema, rootClass, id);
- VerifiyIdTypeIsValid(id, rootClass.MappedClass.Name);
+ VerifiyIdTypeIsValid(id, rootClass.EntityName);
BindGenerator(idSchema, id);
id.Table.SetIdentifierValue(id);
BindUnsavedValue(idSchema, id);
@@ -61,9 +58,10 @@
if (idSchema.name != null)
{
string access = idSchema.access ?? mappings.DefaultAccess;
- id.SetTypeUsingReflection(rootClass.MappedClass.AssemblyQualifiedName, idSchema.name, access);
+ id.SetTypeUsingReflection(rootClass.MappedClass == null ? null : rootClass.MappedClass.AssemblyQualifiedName,
+ idSchema.name, access);
- Mapping.Property property = new Mapping.Property(id);
+ Property property = new Property(id);
property.Name = idSchema.name;
if (property.Value.Type == null)
@@ -230,4 +228,4 @@
return column;
}
}
-}
\ No newline at end of file
+}
Modified: trunk/nhibernate/src/NHibernate/Cfg/XmlHbmBinding/CollectionBinder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cfg/XmlHbmBinding/CollectionBinder.cs 2008-07-21 05:23:55 UTC (rev 3643)
+++ trunk/nhibernate/src/NHibernate/Cfg/XmlHbmBinding/CollectionBinder.cs 2008-07-21 15:21:34 UTC (rev 3644)
@@ -451,8 +451,7 @@
private void BindOneToMany(XmlNode node, OneToMany model)
{
- model.ReferencedEntityName = ClassForNameChecked(node.Attributes["class"].Value, mappings,
- "associated class not found: {0}").FullName;
+ model.ReferencedEntityName = GetEntityName(node, mappings);
string notFound = XmlHelper.GetAttributeValue(node, "not-found");
model.IsIgnoreNotFound = "ignore".Equals(notFound);
Modified: trunk/nhibernate/src/NHibernate/Tuple/Entity/EntityMetamodel.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Tuple/Entity/EntityMetamodel.cs 2008-07-21 05:23:55 UTC (rev 3643)
+++ trunk/nhibernate/src/NHibernate/Tuple/Entity/EntityMetamodel.cs 2008-07-21 15:21:34 UTC (rev 3644)
@@ -91,14 +91,15 @@
entityType = TypeFactory.ManyToOne(name);
type = persistentClass.MappedClass;
rootType = persistentClass.RootClazz.MappedClass;
- rootTypeAssemblyQualifiedName = rootType.AssemblyQualifiedName;
+ rootTypeAssemblyQualifiedName = rootType == null ? null : rootType.AssemblyQualifiedName;
- identifierProperty =
- PropertyFactory.BuildIdentifierProperty(persistentClass, sessionFactory.GetIdentifierGenerator(rootName));
+ identifierProperty = PropertyFactory.BuildIdentifierProperty(persistentClass,
+ sessionFactory.GetIdentifierGenerator(rootName));
versioned = persistentClass.IsVersioned;
- bool lazyAvailable = persistentClass.HasPocoRepresentation && FieldInterceptionHelper.IsInstrumented(persistentClass.MappedClass);
+ bool lazyAvailable = persistentClass.HasPocoRepresentation
+ && FieldInterceptionHelper.IsInstrumented(persistentClass.MappedClass);
bool hasLazy = false;
propertySpan = persistentClass.PropertyClosureSpan;
@@ -155,6 +156,7 @@
}
#region temporary
+
bool lazyProperty = prop.IsLazy && lazyAvailable;
if (lazyProperty)
hasLazy = true;
@@ -169,11 +171,13 @@
updateInclusions[i] = DetermineUpdateValueGenerationType(prop, properties[i]);
propertyVersionability[i] = properties[i].IsVersionable;
nonlazyPropertyUpdateability[i] = properties[i].IsUpdateable && !lazyProperty;
- propertyCheckability[i] = propertyUpdateability[i] ||
- (propertyTypes[i].IsAssociationType &&
- ((IAssociationType) propertyTypes[i]).IsAlwaysDirtyChecked);
+ propertyCheckability[i] = propertyUpdateability[i]
+ ||
+ (propertyTypes[i].IsAssociationType
+ && ((IAssociationType) propertyTypes[i]).IsAlwaysDirtyChecked);
cascadeStyles[i] = properties[i].CascadeStyle;
+
#endregion
if (properties[i].IsLazy)
@@ -224,24 +228,23 @@
hasLazyProperties = hasLazy;
if (hasLazyProperties) log.Info("lazy property fetching available for: " + name);
- lazy = persistentClass.IsLazy &&
- (!persistentClass.HasPocoRepresentation || !ReflectHelper.IsFinalClass(persistentClass.ProxyInterface));
+ lazy = persistentClass.IsLazy
+ && (!persistentClass.HasPocoRepresentation || !ReflectHelper.IsFinalClass(persistentClass.ProxyInterface));
mutable = persistentClass.IsMutable;
if (!persistentClass.IsAbstract.HasValue)
{
// legacy behavior (with no abstract attribute specified)
- isAbstract = persistentClass.HasPocoRepresentation &&
- ReflectHelper.IsAbstractClass(persistentClass.MappedClass);
+ isAbstract = persistentClass.HasPocoRepresentation && ReflectHelper.IsAbstractClass(persistentClass.MappedClass);
}
else
{
isAbstract = persistentClass.IsAbstract.Value;
- if (!isAbstract && persistentClass.HasPocoRepresentation &&
- ReflectHelper.IsAbstractClass(persistentClass.MappedClass))
+ if (!isAbstract && persistentClass.HasPocoRepresentation
+ && ReflectHelper.IsAbstractClass(persistentClass.MappedClass))
{
- log.Warn("entity [" + type.FullName +
- "] is abstract-class/interface explicitly mapped as non-abstract; be sure to supply entity-names");
+ log.Warn("entity [" + type.FullName
+ + "] is abstract-class/interface explicitly mapped as non-abstract; be sure to supply entity-names");
}
}
selectBeforeUpdate = persistentClass.SelectBeforeUpdate;
@@ -252,9 +255,7 @@
explicitPolymorphism = persistentClass.IsExplicitPolymorphism;
inherited = persistentClass.IsInherited;
superclass = inherited ? persistentClass.Superclass.EntityName : null;
- superclassType = inherited ?
- persistentClass.Superclass.MappedClass :
- null;
+ superclassType = inherited ? persistentClass.Superclass.MappedClass : null;
hasSubclasses = persistentClass.HasSubclasses;
optimisticLockMode = persistentClass.OptimisticLockMode;
@@ -675,4 +676,4 @@
get { return naturalIdPropertyNumbers; }
}
}
-}
\ No newline at end of file
+}
Modified: trunk/nhibernate/src/NHibernate/nhibernate-configuration.xsd
===================================================================
--- trunk/nhibernate/src/NHibernate/nhibernate-configuration.xsd 2008-07-21 05:23:55 UTC (rev 3643)
+++ trunk/nhibernate/src/NHibernate/nhibernate-configuration.xsd 2008-07-21 15:21:34 UTC (rev 3644)
@@ -97,6 +97,7 @@
<xs:enumeration value="proxyfactory.factory_class" />
<xs:enumeration value="adonet.factory_class" />
<xs:enumeration value="default_batch_fetch_size" />
+ <xs:enumeration value="default_entity_mode" />
</xs:restriction>
</xs:simpleType>
</xs:attribute>
Added: trunk/nhibernate/src/NHibernate.Test/EntityModeTest/Map/Basic/DynamicClassFixture.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/EntityModeTest/Map/Basic/DynamicClassFixture.cs (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/EntityModeTest/Map/Basic/DynamicClassFixture.cs 2008-07-21 15:21:34 UTC (rev 3644)
@@ -0,0 +1,98 @@
+using System.Collections;
+using System.Collections.Generic;
+using NHibernate.Cfg;
+using NHibernate.Engine;
+using NUnit.Framework;
+
+namespace NHibernate.Test.EntityModeTest.Map.Basic
+{
+ [TestFixture]
+ public class DynamicClassFixture : TestCase
+ {
+ protected override string MappingsAssembly
+ {
+ get { return "NHibernate.Test"; }
+ }
+
+ protected override IList Mappings
+ {
+ get { return new string[] {"EntityModeTest.Map.Basic.ProductLine.hbm.xml"}; }
+ }
+
+ protected override void Configure(Configuration configuration)
+ {
+ configuration.SetProperty(Environment.DefaultEntityMode, EntityModeHelper.ToString(EntityMode.Map));
+ }
+
+ [Test]
+ public void TestLazyDynamicClass()
+ {
+ ITransaction t;
+ using(ISession s = OpenSession())
+ {
+ ISessionImplementor si = (ISessionImplementor) s;
+ Assert.IsTrue(si.EntityMode == EntityMode.Map, "Incorrectly handled default_entity_mode");
+ ISession other = s.GetSession(EntityMode.Poco);
+ other.Close();
+ Assert.IsFalse(other.IsOpen);
+ }
+ IDictionary cars;
+ IList models;
+ using (ISession s = OpenSession())
+ {
+ t = s.BeginTransaction();
+
+ cars = new Hashtable();
+ cars["Description"] = "Cars";
+
+ IDictionary monaro = new Hashtable();
+ monaro["ProductLine"] = cars;
+ monaro["Name"] = "Monaro";
+ monaro["Description"] = "Holden Monaro";
+
+ IDictionary hsv = new Hashtable();
+ hsv["ProductLine"] = cars;
+ hsv["Name"] = "hsv";
+ hsv["Description"] = "Holden hsv";
+
+ models = new List<IDictionary>();
+ models.Add(monaro);
+ models.Add(hsv);
+
+ cars["Models"] = models;
+
+ s.Save("ProductLine", cars);
+ t.Commit();
+ }
+
+ using (ISession s = OpenSession())
+ {
+ t = s.BeginTransaction();
+ cars = (IDictionary) s.CreateQuery("from ProductLine pl order by pl.Description").UniqueResult();
+ models = (IList) cars["Models"];
+ Assert.IsFalse(NHibernateUtil.IsInitialized(models));
+ Assert.AreEqual(2, models.Count);
+ Assert.IsTrue(NHibernateUtil.IsInitialized(models));
+ s.Clear();
+ IList list = s.CreateQuery("from Model m").List();
+ foreach (IDictionary ht in list)
+ {
+ Assert.IsFalse(NHibernateUtil.IsInitialized(ht["ProductLine"]));
+ }
+ IDictionary model = (IDictionary) list[0];
+ Assert.IsTrue(((IList) ((IDictionary) model["ProductLine"])["Models"]).Contains(model));
+ s.Clear();
+
+ t.Commit();
+ }
+
+ using (ISession s = OpenSession())
+ {
+ t = s.BeginTransaction();
+ cars = (IDictionary) s.CreateQuery("from ProductLine pl order by pl.Description").UniqueResult();
+ s.Delete(cars);
+ t.Commit();
+ }
+ }
+ }
+}
\ No newline at end of file
Property changes on: trunk/nhibernate/src/NHibernate.Test/EntityModeTest/Map/Basic/DynamicClassFixture.cs
___________________________________________________________________
Added: svn:mergeinfo
+
Added: trunk/nhibernate/src/NHibernate.Test/EntityModeTest/Map/Basic/ProductLine.hbm.xml
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/EntityModeTest/Map/Basic/ProductLine.hbm.xml (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/EntityModeTest/Map/Basic/ProductLine.hbm.xml 2008-07-21 15:21:34 UTC (rev 3644)
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8" ?>
+
+<!--
+ This mapping demonstrates "dynamic" entities.
+-->
+
+<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">
+ <class entity-name="ProductLine">
+ <id name="Id" column="productId" type="System.Int32">
+ <generator class="native"/>
+ </id>
+ <property name="Description" not-null="true" length="200" type="string"/>
+
+ <bag name="Models" cascade="all" inverse="true">
+ <key column="productId"/>
+ <one-to-many class="Model"/>
+ </bag>
+
+ </class>
+ <class entity-name="Model">
+ <id name="Id" column="modelId" type="System.Int32">
+ <generator class="native"/>
+ </id>
+
+ <property name="Name" not-null="true" length="25" type="string"/>
+ <property name="Description" not-null="true" length="200" type="string"/>
+ <many-to-one name="ProductLine" column="productId" not-null="true" class="ProductLine"/>
+
+ </class>
+
+
+</hibernate-mapping>
Property changes on: trunk/nhibernate/src/NHibernate.Test/EntityModeTest/Map/Basic/ProductLine.hbm.xml
___________________________________________________________________
Added: svn:mergeinfo
+
Modified: trunk/nhibernate/src/NHibernate.Test/NHibernate.Test-2.0.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHibernate.Test-2.0.csproj 2008-07-21 05:23:55 UTC (rev 3643)
+++ trunk/nhibernate/src/NHibernate.Test/NHibernate.Test-2.0.csproj 2008-07-21 15:21:34 UTC (rev 3644)
@@ -134,6 +134,7 @@
<Compile Include="DynamicEntity\Tuplizer\MyEntityTuplizer.cs" />
<Compile Include="DynamicEntity\Tuplizer\TuplizerDynamicEntity.cs" />
<Compile Include="EngineTest\TypedValueFixture.cs" />
+ <Compile Include="EntityModeTest\Map\Basic\DynamicClassFixture.cs" />
<Compile Include="ExceptionsTest\Group.cs" />
<Compile Include="ExceptionsTest\MSSQLExceptionConverterExample.cs" />
<Compile Include="ExceptionsTest\PropertyAccessExceptionFixture.cs" />
@@ -1360,6 +1361,7 @@
<ItemGroup>
<EmbeddedResource Include="DynamicEntity\Interceptor\Customer.hbm.xml" />
<Content Include="DynamicEntity\package.html" />
+ <EmbeddedResource Include="EntityModeTest\Map\Basic\ProductLine.hbm.xml" />
<EmbeddedResource Include="DynamicEntity\Tuplizer\Customer.hbm.xml" />
</ItemGroup>
<ItemGroup>
Modified: trunk/nhibernate/src/NHibernate.Test/TestCase.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/TestCase.cs 2008-07-21 05:23:55 UTC (rev 3643)
+++ trunk/nhibernate/src/NHibernate.Test/TestCase.cs 2008-07-21 15:21:34 UTC (rev 3644)
@@ -253,7 +253,7 @@
protected ISessionFactoryImplementor Sfi
{
- get { return (ISessionFactoryImplementor) sessions; }
+ get { return sessions; }
}
protected virtual ISession OpenSession()
@@ -278,11 +278,11 @@
foreach (PersistentClass clazz in configuration.ClassMappings)
{
bool hasLob = false;
- foreach (Mapping.Property prop in clazz.PropertyClosureIterator)
+ foreach (Property prop in clazz.PropertyClosureIterator)
{
if (prop.Value.IsSimpleValue)
{
- IType type = ((SimpleValue) prop.Value).Type;
+ IType type = ((SimpleValue)prop.Value).Type;
if (type == NHibernateUtil.BinaryBlob)
{
hasLob = true;
@@ -291,13 +291,13 @@
}
if (!hasLob && !clazz.IsInherited)
{
- configuration.SetCacheConcurrencyStrategy(clazz.MappedClass, CacheConcurrencyStrategy);
+ configuration.SetCacheConcurrencyStrategy(clazz.EntityName, CacheConcurrencyStrategy);
}
}
foreach (Mapping.Collection coll in configuration.CollectionMappings)
{
- configuration.SetCacheConcurrencyStrategy(coll.Role, CacheConcurrencyStrategy);
+ configuration.SetCollectionCacheConcurrencyStrategy(coll.Role, CacheConcurrencyStrategy);
}
}
@@ -320,4 +320,4 @@
#endregion
}
-}
\ No newline at end of file
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
