Skip to content
Browse files

XML documentation refinements for read-only entity APIs.

SVN: branches/ReadOnlyEntities@5396
  • Loading branch information...
1 parent 117af58 commit e78a8d5ff2d71b7baf6b9c7f4137e7f0b527cd35 @julian-maughan julian-maughan committed
View
82 src/NHibernate/Engine/IPersistenceContext.cs
@@ -55,38 +55,21 @@ public interface IPersistenceContext
bool Flushing { get; set;}
/// <summary>
- /// Change the default for entities and proxies loaded into this persistence
- /// context from modifiable to read-only mode, or from modifiable to read-only
- /// mode.
+ /// The read-only status for entities (and proxies) loaded into this persistence context.
/// </summary>
/// <remarks>
/// <para>
- /// Read-only entities are not dirty-checked and snapshots of persistent
- /// state are not maintained. Read-only entities can be modified, but
- /// changes are not persisted.
+ /// When a proxy is initialized, the loaded entity will have the same read-only
+ /// setting as the uninitialized proxy has, regardless of the persistence context's
+ /// current setting.
/// </para>
/// <para>
- /// When a proxy is initialized, the loaded entity will have the same
- /// read-only/modifiable setting as the uninitialized
- /// proxy has, regardless of the persistence context's current setting.
- /// </para>
- /// <para>
- /// To change the read-only/modifiable setting for a particular entity
- /// or proxy that is already in this session:
- /// <see cref="SetReadOnly(object, bool)" />
- /// <see cref="ISession.SetReadOnly(object, bool)" />
- /// </para>
- /// <para>
- /// To determine the read-only/modifiable setting for a particular entity or proxy:
- /// <see cref="IsReadOnly(object)" />
- /// <see cref="ISession.IsReadOnly(object)" />
- /// </para>
- /// <para>
- /// To override this session's read-only/modifiable setting for entities
- /// and proxies loaded by an IQuery:
- /// <see cref="IQuery.SetReadOnly(bool)" />
+ /// To change the read-only setting for a particular entity or proxy that is already
+ /// in the current persistence context, use <see cref="IPersistenceContext.SetReadOnly(object, bool)" />.
/// </para>
/// </remarks>
+ /// <seealso cref="IPersistenceContext.IsReadOnly(object)" />
+ /// <seealso cref="IPersistenceContext.SetReadOnly(object, bool)" />
bool DefaultReadOnly { get; set; }
/// <summary> Add a collection which has no owner loaded</summary>
@@ -377,53 +360,36 @@ public interface IPersistenceContext
bool IsPropertyNull(EntityKey ownerKey, string propertyName);
/// <summary>
- /// Set the entity or proxy to read only and discard it's snapshot.
- /// Set an unmodified persistent object to read-only mode, or a read-only
- /// object to modifiable mode.
+ /// Change the read-only status of an entity (or proxy).
/// </summary>
/// <remarks>
/// <para>
- /// Read-only entities are not dirty-checked and snapshots of persistent
- /// state are not maintained. Read-only entities can be modified, but
- /// changes are not persisted.
+ /// Read-only entities can be modified, but changes are not persisted. They are not dirty-checked
+ /// and snapshots of persistent state are not maintained.
/// </para>
/// <para>
- /// When a proxy is initialized, the loaded entity will have the same
- /// read-only/modifiable setting as the uninitialized
- /// proxy has, regardless of the session's current setting.
+ /// Immutable entities cannot be made read-only.
/// </para>
/// <para>
- /// If the entity or proxy already has the specified read-only/modifiable
- /// setting, then this method does nothing.
- /// </para>
- /// <para>
- /// To set the default read-only/modifiable setting used for
- /// entities and proxies that are loaded into this persistence context:
- /// <see cref="IPersistenceContext.DefaultReadOnly" />
- /// <see cref="ISession.DefaultReadOnly" />
- /// </para>
- /// <para>
- /// To override this persistence context's read-only/modifiable setting
- /// for entities and proxies loaded by a Query:
- /// <see cref="IQuery.SetReadOnly(bool)" />
+ /// To set the <em>default</em> read-only setting for entities and proxies that are loaded
+ /// into the persistence context, see <see cref="IPersistenceContext.DefaultReadOnly" />.
/// </para>
/// </remarks>
- /// <param name="entity">An entity or INHibernateProxy</param>
- /// <param name="readOnly">if <c>true</c>, the entity or proxy is made read-only; if <c>false</c>, the entity or proxy is made modifiable.</param>
- /// <seealso cref="ISession.SetReadOnly(object, bool)" />
- void SetReadOnly(object entity, bool readOnly);
+ /// <param name="entityOrProxy">An entity (or <see cref="NHibernate.Proxy.INHibernateProxy" />).</param>
+ /// <param name="readOnly">If <c>true</c>, the entity or proxy is made read-only; if <c>false</c>, it is made modifiable.</param>
+ /// <seealso cref="IPersistenceContext.DefaultReadOnly" />
+ /// <seealso cref="IPersistenceContext.IsReadOnly(object)" />
+ void SetReadOnly(object entityOrProxy, bool readOnly);
/// <summary>
- /// Is the entity or proxy read-only?
+ /// Is the specified entity (or proxy) read-only?
/// </summary>
- /// <remarks>
- /// To get the default read-only/modifiable setting used for
- /// entities and proxies that are loaded into the session:
- /// <see cref="ISession.DefaultReadOnly" />
- /// </remarks>
+ /// <param name="entityOrProxy">An entity (or <see cref="NHibernate.Proxy.INHibernateProxy" />)</param>
/// <returns>
- /// <c>true</c>, the object is read-only; <c>false</c>, the object is modifiable.
+ /// <c>true</c> if the entity or proxy is read-only, otherwise <c>false</c>.
/// </returns>
+ /// <seealso cref="IPersistenceContext.DefaultReadOnly" />
+ /// <seealso cref="IPersistenceContext.SetReadOnly(object, bool)" />
bool IsReadOnly(object entityOrProxy);
void ReplaceDelayedEntityIdentityInsertKeys(EntityKey oldKey, object generatedId);
View
2 src/NHibernate/Engine/ISessionImplementor.cs
@@ -16,7 +16,7 @@
namespace NHibernate.Engine
{
/// <summary>
- /// Defines the internal contract between the <c>Session</c> and other parts of Hibernate
+ /// Defines the internal contract between the <c>Session</c> and other parts of NHibernate
/// such as implementors of <c>Type</c> or <c>ClassPersister</c>
/// </summary>
public interface ISessionImplementor
View
34 src/NHibernate/Engine/QueryParameters.cs
@@ -168,14 +168,6 @@ public RowSelection RowSelection
set { _lockModes = value; }
}
- /// <summary>
- /// Has the read-only/modifiable mode been explicitly set?
- /// </summary>
- /// <value>
- /// <c>true</c>, the read-only/modifiable mode was explicitly set; <c>false</c>, the read-only/modifiable mode was not explicitly set
- /// </value>
- /// <seealso cref="ReadOnly" />
- /// <seealso cref="IsReadOnly(ISessionImplementor)" />
public bool IsReadOnlyInitialized
{
get { return _isReadOnlyInitialized; }
@@ -281,15 +273,6 @@ public object[] CollectionKeys
public bool Callable { get; set; }
- /// <summary>
- /// Should entities and proxies loaded by the query be put in read-only mode?
- /// </summary>
- /// <remarks>
- /// The read-only/modifiable setting has no impact on entities/proxies returned by the
- /// query that existed in the session before the query was executed.
- /// </remarks>
- /// <seealso cref="IsReadOnlyInitialized" />
- /// <seealso cref="IsReadOnly(ISessionImplementor)" />
public bool ReadOnly
{
get
@@ -693,23 +676,6 @@ public QueryParameters CreateCopyUsing(RowSelection selection)
return copy;
}
- /// <summary>
- /// Should entities and proxies loaded by the query be put in read-only mode? If the
- /// read-only/modifiable setting was not initialized
- /// (i.e. <see cref="IsReadOnlyInitialized" /> == false), then the default
- /// read-only/modifiable setting for the persistence context is returned instead.
- /// </summary>
- /// <remarks>
- /// The read-only/modifiable setting has no impact on entities/proxies returned by the
- /// query that existed in the session before the query was executed.
- /// </remarks>
- /// <seealso cref="IsReadOnlyInitialized" />
- /// <seealso cref="ReadOnly" />
- /// <seealso cref="IPersistenceContext.DefaultReadOnly" />
- /// <param name="session"></param>
- /// <returns>
- /// <c>true</c>, entities and proxies loaded by the query will be put in read-only mode; <c>false</c>, entities and proxies loaded by the query will be put in modifiable mode
- /// </returns>
public bool IsReadOnly(ISessionImplementor session)
{
return _isReadOnlyInitialized ? this.ReadOnly : session.PersistenceContext.DefaultReadOnly;
View
2 src/NHibernate/Engine/StatefulPersistenceContext.cs
@@ -1113,6 +1113,7 @@ public bool IsPropertyNull(EntityKey ownerKey, string propertyName)
return nullAssociations.Contains(new AssociationKey(ownerKey, propertyName));
}
+ /// <inheritdoc />
public void SetReadOnly(object entityOrProxy, bool readOnly)
{
if (entityOrProxy == null)
@@ -1164,6 +1165,7 @@ private void SetEntityReadOnly(object entity, bool readOnly)
hasNonReadOnlyEntities |= !readOnly;
}
+ /// <inheritdoc />
public bool IsReadOnly(object entityOrProxy)
{
if (entityOrProxy == null)
View
63 src/NHibernate/ICriteria.cs
@@ -61,26 +61,32 @@ public interface ICriteria : ICloneable
string Alias { get; }
/// <summary>
- /// Was the read-only/modifiable mode explicitly initialized?
+ /// Was the read-only mode explicitly initialized?
/// </summary>
- /// <seealso cref="SetReadOnly(bool)" />
- /// <returns><c>true</c>, the read-only/modifiable mode was explicitly initialized; <c>false</c>, otherwise.</returns>
+ /// <returns><c>true</c> if the read-only mode was explicitly initialized, otherwise <c>false</c>.</returns>
+ /// <seealso cref="ICriteria.SetReadOnly(bool)" />
+ /// <seealso cref="ICriteria.IsReadOnly" />///
bool IsReadOnlyInitialized { get; }
/// <summary>
- /// Should entities and proxies loaded by this Criteria be put in read-only mode? If the
- /// read-only/modifiable setting was not initialized, then the default
- /// read-only/modifiable setting for the persistence context is returned instead.
+ /// Will entities (and proxies) loaded by this Criteria be put in read-only mode?
/// </summary>
/// <remarks>
- /// The read-only/modifiable setting has no impact on entities/proxies returned by the
+ /// <para>
+ /// If the read-only setting was not initialized, then the value of the session's
+ /// <see cref="ISession.DefaultReadOnly" /> property is returned instead.
+ /// </para>
+ /// <para>
+ /// The read-only setting has no impact on entities or proxies returned by the
/// Criteria that existed in the session before the Criteria was executed.
+ /// </para>
/// </remarks>
- /// <seealso cref="SetReadOnly(bool)" />
- /// <seealso cref="NHibernate.Engine.IPersistenceContext.DefaultReadOnly" />
/// <returns>
- /// <c>true</c>, entities and proxies loaded by the criteria will be put in read-only mode; <c>false</c>, entities and proxies loaded by the criteria will be put in modifiable mode
+ /// <c>true</c> if entities and proxies loaded by the criteria will be put in read-only mode,
+ /// otherwise <c>false</c>.
/// </returns>
+ /// <seealso cref="ICriteria.SetReadOnly(bool)" />
+ /// <seealso cref="ICriteria.IsReadOnlyInitialized" />
bool IsReadOnly { get; }
/// <summary>
@@ -310,28 +316,33 @@ public interface ICriteria : ICloneable
IFutureValue<T> FutureValue<T>();
/// <summary>
- /// Set the read-only/modifiable mode for entities and proxies
- /// loaded by this Criteria. This setting overrides the default setting
- /// for the persistence context.
+ /// Set the read-only mode for entities (and proxies) loaded by this Criteria. This
+ /// setting overrides the default for the session (see <see cref="ISession.DefaultReadOnly" />).
/// </summary>
/// <remarks>
- /// <para>Use <see cref="NHibernate.Engine.IPersistenceContext.DefaultReadOnly" /> or
- /// <see cref="NHibernate.ISession.DefaultReadOnly" /> to set the default read-only/modifiable
- /// setting used for entities and proxies that are loaded into the session.</para>
- /// <para>Read-only entities are not dirty-checked and snapshots of persistent
- /// state are not maintained. Read-only entities can be modified, but
- /// changes are not persisted.</para>
- /// <para>When a proxy is initialized, the loaded entity will have the same
- /// read-only/modifiable setting as the uninitialized proxy has, regardless
- /// of the session's current setting.</para>
- /// <para>The read-only/modifiable setting has no impact on entities/proxies
- /// returned by the criteria that existed in the session before the criteria was
- /// executed.</para>
+ /// <para>
+ /// To set the <em>default</em> read-only setting for entities and proxies that are loaded
+ /// into the session, see <see cref="ISession.DefaultReadOnly" />.
+ /// </para>
+ /// <para>
+ /// Read-only entities can be modified, but changes are not persisted. They are not
+ /// dirty-checked and snapshots of persistent state are not maintained.
+ /// </para>
+ /// <para>
+ /// When a proxy is initialized, the loaded entity will have the same read-only setting
+ /// as the uninitialized proxy has, regardless of the session's current setting.
+ /// </para>
+ /// <para>
+ /// The read-only setting has no impact on entities or proxies returned by the criteria
+ /// that existed in the session before the criteria was executed.
+ /// </para>
/// </remarks>
/// <param name="readOnly">
- /// <c>true</c>, entities and proxies loaded by the criteria will be put in read-only mode; <c>false</c>, entities and proxies loaded by the criteria will be put in modifiable mode
+ /// If <c>true</c>, entities (and proxies) loaded by the criteria will be read-only.
/// </param>
/// <returns><c>this</c> (for method chaining)</returns>
+ /// <seealso cref="ICriteria.IsReadOnly" />
+ /// <seealso cref="ICriteria.IsReadOnlyInitialized" />
ICriteria SetReadOnly(bool readOnly);
#region NHibernate specific
View
43 src/NHibernate/IQuery.cs
@@ -67,7 +67,7 @@ public interface IQuery
IType[] ReturnTypes { get; }
/// <summary> Return the HQL select clause aliases (if any)</summary>
- /// <returns> an array of aliases as strings </returns>
+ /// <returns> An array of aliases as strings </returns>
string[] ReturnAliases { get; }
/// <summary>
@@ -77,19 +77,23 @@ public interface IQuery
string[] NamedParameters { get; }
/// <summary>
- /// Should entities and proxies loaded by this query be put in read-only mode? If the
- /// read-only/modifiable setting was not initialized, then the default
- /// read-only/modifiable setting for the persistence context is returned instead.
+ /// Will entities (and proxies) returned by the query be loaded in read-only mode?
/// </summary>
/// <remarks>
- /// The read-only/modifiable setting has no impact on entities/proxies returned by the
+ /// <para>
+ /// If the query's read-only setting is not initialized (with <see cref="SetReadOnly(bool)" />),
+ /// the value of the session's <see cref="ISession.DefaultReadOnly" /> property is
+ /// returned instead.
+ /// </para>
+ /// <para>
+ /// The value of this property has no effect on entities or proxies returned by the
/// query that existed in the session before the query was executed.
+ /// </para>
/// </remarks>
/// <returns>
- /// <c>true</c>, entities and proxies loaded by the query will be put in read-only mode; <c>false</c>, entities and proxies loaded by the query will be put in modifiable mode
+ /// <c>true</c> if entities and proxies loaded by the query will be put in read-only mode, otherwise <c>false</c>.
/// </returns>
- /// <seealso cref="SetReadOnly(bool)" />
- /// <seealso cref="NHibernate.Engine.IPersistenceContext.DefaultReadOnly()" />
+ /// <seealso cref="IQuery.SetReadOnly(bool)" />
bool IsReadOnly { get; }
/// <summary>
@@ -171,13 +175,28 @@ public interface IQuery
IQuery SetFirstResult(int firstResult);
/// <summary>
- /// Entities retrieved by this query will be loaded in
- /// a read-only mode where NHibernate will never dirty-check
- /// them or make changes persistent.
+ /// Set the read-only mode for entities (and proxies) loaded by this query. This setting
+ /// overrides the default setting for the session (see <see cref="ISession.DefaultReadOnly" />).
/// </summary>
+ /// <remarks>
+ /// <para>
+ /// Read-only entities can be modified, but changes are not persisted. They are not
+ /// dirty-checked and snapshots of persistent state are not maintained.
+ /// </para>
+ /// <para>
+ /// When a proxy is initialized, the loaded entity will have the same read-only setting
+ /// as the uninitialized proxy, regardless of the session's current setting.
+ /// </para>
+ /// <para>
+ /// The read-only setting has no impact on entities or proxies returned by the criteria
+ /// that existed in the session before the criteria was executed.
+ /// </para>
+ /// </remarks>
/// <param name="readOnly">
- /// <c>true</c>, entities and proxies loaded by the query will be put in read-only mode; <c>false</c>, entities and proxies loaded by the query will be put in modifiable mode
+ /// If <c>true</c>, entities (and proxies) loaded by the query will be read-only.
/// </param>
+ /// <returns><c>this</c> (for method chaining)</returns>
+ /// <seealso cref="IsReadOnly" />
IQuery SetReadOnly(bool readOnly);
/// <summary>
View
63 src/NHibernate/ISession.cs
@@ -179,71 +179,66 @@ public interface ISession : IDisposable
bool IsDirty();
/// <summary>
- /// Is the specified entity or proxy read-only?
+ /// Is the specified entity (or proxy) read-only?
/// </summary>
/// <remarks>
- /// To get the default read-only/modifiable setting used for
- /// entities and proxies that are loaded into the session:
- /// <see cref="DefaultReadOnly" />
+ /// Facade for <see cref="IPersistenceContext.IsReadOnly(object)" />.
/// </remarks>
- /// <param name="entityOrProxy">An entity or INHibernateProxy</param>
+ /// <param name="entityOrProxy">An entity (or <see cref="NHibernate.Proxy.INHibernateProxy" />)</param>
/// <returns>
- /// <c>true</c>, the entity or proxy is read-only; <c>false</c>, the entity or proxy is modifiable.
+ /// <c>true</c> if the entity (or proxy) is read-only, otherwise <c>false</c>.
/// </returns>
+ /// <seealso cref="ISession.DefaultReadOnly" />
+ /// <seealso cref="ISession.SetReadOnly(object, bool)" />
bool IsReadOnly(object entityOrProxy);
/// <summary>
- /// Set an unmodified persistent object to read-only mode, or a read-only
- /// object to modifiable mode. In read-only mode, no snapshot is maintained,
- /// the instance is never dirty checked, and changes are not persisted.
+ /// Change the read-only status of an entity (or proxy).
/// </summary>
/// <remarks>
/// <para>
- /// If the entity or proxy already has the specified read-only/modifiable
- /// setting, then this method does nothing.
+ /// Read-only entities can be modified, but changes are not persisted. They are not dirty-checked
+ /// and snapshots of persistent state are not maintained.
/// </para>
/// <para>
- /// To set the default read-only/modifiable setting used for
- /// entities and proxies that are loaded into the session:
- /// <see cref="ISession.DefaultReadOnly" />
+ /// Immutable entities cannot be made read-only.
/// </para>
/// <para>
- /// To override this session's read-only/modifiable setting for entities
- /// and proxies loaded by a query:
- /// <see cref="IQuery.SetReadOnly(bool)" />
+ /// To set the <em>default</em> read-only setting for entities and proxies that are loaded
+ /// into the session, see <see cref="ISession.DefaultReadOnly" />.
+ /// </para>
+ /// <para>
+ /// This method a facade for <see cref="IPersistenceContext.SetReadOnly(object, bool)" />.
/// </para>
/// </remarks>
- /// <param name="entityOrProxy">An entity or INHibernateProxy</param>
- /// <param name="readOnly">if <c>true</c>, the entity or proxy is made read-only; if <c>false</c>, the entity or proxy is made modifiable.</param>
+ /// <param name="entityOrProxy">An entity (or <see cref="NHibernate.Proxy.INHibernateProxy" />).</param>
+ /// <param name="readOnly">If <c>true</c>, the entity or proxy is made read-only; if <c>false</c>, it is made modifiable.</param>
+ /// <seealso cref="ISession.DefaultReadOnly" />
+ /// <seealso cref="ISession.IsReadOnly(object)" />
void SetReadOnly(object entityOrProxy, bool readOnly);
/// <summary>
- /// The default read-only status of the Session
- /// Will entities and proxies that are loaded into this session be made
- /// read-only by default?
+ /// The read-only status for entities (and proxies) loaded into this Session.
/// </summary>
/// <remarks>
/// <para>
- /// Read-only entities are not dirty-checked and snapshots of persistent
- /// state are not maintained. Read-only entities can be modified, but
- /// changes are not persisted.
+ /// When a proxy is initialized, the loaded entity will have the same read-only setting
+ /// as the uninitialized proxy, regardless of the session's current setting.
/// </para>
/// <para>
- /// When a proxy is initialized, the loaded entity will have the same
- /// read-only/modifiable setting as the uninitialized
- /// proxy has, regardless of the session's current setting.
+ /// To change the read-only setting for a particular entity or proxy that is already in
+ /// this session, see <see cref="ISession.SetReadOnly(object, bool)" />.
/// </para>
/// <para>
- /// To change the read-only/modifiable setting for a particular entity
- /// or proxy that is already in this session:
- /// <see cref="ISession.SetReadOnly(object, bool)" />
+ /// To override this session's read-only setting for entities and proxies loaded by a query,
+ /// see <see cref="IQuery.SetReadOnly(bool)" />.
/// </para>
/// <para>
- /// To override this session's read-only/modifiable setting for entities
- /// and proxies loaded by a query:
- /// <see cref="IQuery.SetReadOnly(bool)" />
+ /// This method is a facade for <see cref="IPersistenceContext.DefaultReadOnly" />.
/// </para>
/// </remarks>
+ /// <seealso cref="ISession.IsReadOnly(object)" />
+ /// <seealso cref="ISession.SetReadOnly(object, bool)" />
bool DefaultReadOnly { get; set; }
/// <summary>
View
15 src/NHibernate/Impl/CriteriaImpl.cs
@@ -124,11 +124,13 @@ public IProjection Projection
get { return projection; }
}
+ /// <inheritdoc />
public bool IsReadOnlyInitialized
{
get { return (readOnly != null); }
}
+ /// <inheritdoc />
public bool IsReadOnly
{
get
@@ -496,7 +498,8 @@ public ICriteria SetProjection(params IProjection[] projections)
return this;
}
-
+
+ /// <inheritdoc />
public ICriteria SetReadOnly(bool readOnly)
{
this.readOnly = readOnly;
@@ -795,12 +798,12 @@ public IFutureValue<T> FutureValue<T>()
return root.FutureValue<T>();
}
- public IEnumerable<T> Future<T>()
- {
- return root.Future<T>();
- }
+ public IEnumerable<T> Future<T>()
+ {
+ return root.Future<T>();
+ }
- public void List(IList results)
+ public void List(IList results)
{
root.List(results);
}
View
4 src/NHibernate/Impl/SessionImpl.cs
@@ -2394,12 +2394,12 @@ public override string FetchProfile
}
/// <inheritdoc />
- public void SetReadOnly(object entity, bool readOnly)
+ public void SetReadOnly(object entityOrProxy, bool readOnly)
{
using (new SessionIdLoggingContext(SessionId))
{
CheckAndUpdateSessionStatus();
- persistenceContext.SetReadOnly(entity, readOnly);
+ persistenceContext.SetReadOnly(entityOrProxy, readOnly);
}
}
View
3 src/NHibernate/Proxy/AbstractLazyInitializer.cs
@@ -50,6 +50,7 @@ protected internal AbstractLazyInitializer(string entityName, object id, ISessio
SetSession(session);
}
+ /// <inheritdoc />
public void SetSession(ISessionImplementor s)
{
if (s != _session)
@@ -84,6 +85,7 @@ public void SetSession(ISessionImplementor s)
}
}
+ /// <inheritdoc />
public void UnsetSession()
{
_session = null;
@@ -207,6 +209,7 @@ public void SetImplementation(object target)
initialized = true;
}
+ /// <inheritdoc />
public bool IsReadOnlySettingAvailable
{
get { return (_session != null && !_session.IsClosed); }
View
19 src/NHibernate/Proxy/ILazyInitializer.cs
@@ -40,7 +40,7 @@ public interface ILazyInitializer
ISessionImplementor Session { get; set; }
/// <summary>
- /// Is the proxy's read-only/modifiable setting available?
+ /// Is the read-only setting available?
/// </summary>
bool IsReadOnlySettingAvailable { get; }
@@ -49,22 +49,15 @@ public interface ILazyInitializer
/// </summary>
/// <remarks>
/// <para>
- /// The read-only/modifiable setting is not available when the proxy is
- /// detached or its associated session is closed.
+ /// Not available when the proxy is detached or its associated session is closed.
/// </para>
/// <para>
- /// If the proxy is currently initialized, its implementation will be set to
- /// the same mode; otherwise, when the proxy is initialized, its implementation
- /// will have the same read-only/modifiable setting as the proxy. In read-only
- /// mode, no snapshot is maintained and the instance is never dirty checked.
- /// </para>
+ /// To check if the read-only setting is available, use <see cref="IsReadOnlySettingAvailable" />
+ /// </para>
/// <para>
- /// If the associated proxy already has the specified read-only/modifiable
- /// setting, then this method does nothing.
+ /// The read-only status of the entity will be made to match the read-only status of the proxy
+ /// upon initialization.
/// </para>
- /// <para>
- /// To check if the read-only/modifiable setting is available: <see cref="IsReadOnlySettingAvailable" />
- /// </para>
/// </remarks>
bool ReadOnly { get; set; }

0 comments on commit e78a8d5

Please sign in to comment.
Something went wrong with that request. Please try again.