Class SelectionRow

Selections
Row Object for table 'selection'. Row objects correspond directly to database tables, and one instance of a row object represents one row in the corresponding table in the database.

Inheritance

object

SqlCommand

PrivateSave

TableRowBase

SelectionRow

Implements

Inherited Members

TableRowBase._saveOwner

TableRowBase._sentries

TableRowBase._relatedNestedPersistMembers

TableRowBase._isSaving

TableRowBase._sqlType

TableRowBase.InternalSetValue(int, object)

TableRowBase.InternalSetValue(SoField, object)

TableRowBase.GetFieldValue(FieldInfo)

TableRowBase.GetKnownFields()

TableRowBase.IsGhostField(FieldInfo)

TableRowBase.RowLoad()

TableRowBase.RowLoad(ITableRowLoadHandler)

TableRowBase.OnLoaded(IdxBase)

TableRowBase.Load(IdxBase, SoDataReader)

TableRowBase.Load(SoDataReader, TableInfo)

TableRowBase.SetDefaults()

TableRowBase.SetDefaults(DashboardTileDefinitionRow, string)

TableRowBase.SetSaveOwner(INestedPersist)

TableRowBase.Save()

TableRowBase.Delete()

TableRowBase.Validate()

TableRowBase.SetDirty(int, object, object)

TableRowBase.OnPreIdUpdate()

TableRowBase.OnPrimaryKeyRequest(PKContainer)

TableRowBase.OnPrimaryKeyUpdate(PKContainer)

TableRowBase.OnIdUpdate()

TableRowBase.BeginIgnoreSentryCheck()

TableRowBase.EndIgnoreSentryCheck()

TableRowBase.GetRelatedNestedPersist()

TableRowBase.this[int]

TableRowBase.this[SoField]

TableRowBase.Sentries

TableRowBase.ForeignKeyHelper

TableRowBase.IsDeleted

TableRowBase.IsSaving

TableRowBase.SqlType

TableRowBase.IsSentryIgnored

TableRowBase.IsMarkedForDelete

TableRowBase.OnElementSaved

TableRowBase.OnElementIdUpdate

PrivateSave.GetTableInfos()

PrivateSave.CloneToBasicUpdatingQuery()

PrivateSave.SetTicketLogAction(TicketLogAction, string)

PrivateSave.DoNotWriteTraveltransactionLog

PrivateSave.OnUpdateField

SqlCommand.Origin

SqlCommand.AdditionalInfo

SqlCommand.AddIgnoreAutoSentryTableInfo(TableInfo)

SqlCommand.AddIgnoreAutoSentryTableInfo(IEnumerable<TableInfo>)

SqlCommand.RemoveIgnoreAutoSentryTableInfo(TableInfo)

SqlCommand.ClearIgnoreAutoSentryTableInfos()

SqlCommand.IsAutoSentryIgnoredOnTableInfo(TableInfo)

SqlCommand.GetPrivateSaves()

SqlCommand.GetInserts()

SqlCommand.GetUpdates()

SqlCommand.GetDeletes()

SqlCommand.GetSelect()

SqlCommand.AutoSentryIgnoredTables

object.Equals(object)

object.Equals(object, object)

object.ReferenceEquals(object, object)

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

Namespace: SuperOffice.CRM.Rows

Assembly: SoDataBase.dll

Syntax

public class SelectionRow : TableRowBase, INestedPersist, ISoDataLookup, ISentryIgnorable, ISoItem

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the SelectionRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, SelectionTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table Selection are:

Index fields	Nested index class name

Constructors

SelectionRow(SelectionRowIdxBase)

Constructor for the class taking an index as argument. Selections

Declaration

protected SelectionRow(SelectionRow.SelectionRowIdxBase idx)

Parameters

Type	Name	Description
SelectionRow.SelectionRowIdxBase	idx	The index representing a SELECT command to the database.

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

Fields

_currentAssociateId

Current value, see property AssociateId.

Declaration

protected int _currentAssociateId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentChartKey

Current value, see property ChartKey.

Declaration

protected string _currentChartKey

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentCombinationType

Current value, see property CombinationType.

Declaration

protected SelectionUnionType _currentCombinationType

Field Value

Type	Description
SelectionUnionType

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentCompanyUnique

Current value, see property CompanyUnique.

Declaration

protected short _currentCompanyUnique

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentDashboardTileDefinitionId

Current value, see property DashboardTileDefinitionId.

Declaration

protected int _currentDashboardTileDefinitionId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentDone

Current value, see property Done.

Declaration

protected short _currentDone

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentGroupIdx

Current value, see property GroupIdx.

Declaration

protected int _currentGroupIdx

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentIncludePerson

Current value, see property IncludePerson.

Declaration

protected int _currentIncludePerson

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentLastLoaded

Current value, see property LastLoaded.

Declaration

protected DateTime _currentLastLoaded

Field Value

Type	Description
DateTime

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentLastLoadedBy

Current value, see property LastLoadedBy.

Declaration

protected int _currentLastLoadedBy

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentLastMembershipChange

Current value, see property LastMembershipChange.

Declaration

protected DateTime _currentLastMembershipChange

Field Value

Type	Description
DateTime

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentLastMembershipChangeBy

Current value, see property LastMembershipChangeBy.

Declaration

protected int _currentLastMembershipChangeBy

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentLeftSelectionId

Current value, see property LeftSelectionId.

Declaration

protected int _currentLeftSelectionId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentMemberCount

Current value, see property MemberCount.

Declaration

protected uint _currentMemberCount

Field Value

Type	Description
uint

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentName

Current value, see property Name.

Declaration

protected string _currentName

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentPostitTextId

Current value, see property PostitTextId.

Declaration

protected int _currentPostitTextId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentRegistered

Current value, see property Registered.

Declaration

protected DateTime _currentRegistered

Field Value

Type	Description
DateTime

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentRegisteredAssociateId

Current value, see property RegisteredAssociateId.

Declaration

protected int _currentRegisteredAssociateId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentRightSelectionId

Current value, see property RightSelectionId.

Declaration

protected int _currentRightSelectionId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentSearchCatId

Current value, see property SearchCatId.

Declaration

protected int _currentSearchCatId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentSelectionId

Current value, see property SelectionId.

Declaration

protected int _currentSelectionId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentSeltype

Current value, see property Seltype.

Declaration

protected short _currentSeltype

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentSoundEx

Current value, see property SoundEx.

Declaration

protected string _currentSoundEx

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentSource

Current value, see property Source.

Declaration

protected short _currentSource

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentSystemType

Current value, see property SystemType.

Declaration

protected SelectionSystemType _currentSystemType

Field Value

Type	Description
SelectionSystemType

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentTargetTableNumber

Current value, see property TargetTableNumber.

Declaration

protected short _currentTargetTableNumber

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentTextId

Current value, see property TextId.

Declaration

protected int _currentTextId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentUpdated

Current value, see property Updated.

Declaration

protected DateTime _currentUpdated

Field Value

Type	Description
DateTime

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentUpdatedAssociateId

Current value, see property UpdatedAssociateId.

Declaration

protected int _currentUpdatedAssociateId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentUpdatedCount

Current value, see property UpdatedCount.

Declaration

protected short _currentUpdatedCount

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_currentVisibility

Current value, see property Visibility.

Declaration

protected short _currentVisibility

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedAssociateId

Persisted value, see property AssociateId.

Declaration

protected int _persistedAssociateId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedChartKey

Persisted value, see property ChartKey.

Declaration

protected string _persistedChartKey

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedCombinationType

Persisted value, see property CombinationType.

Declaration

protected SelectionUnionType _persistedCombinationType

Field Value

Type	Description
SelectionUnionType

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedCompanyUnique

Persisted value, see property CompanyUnique.

Declaration

protected short _persistedCompanyUnique

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedDashboardTileDefinitionId

Persisted value, see property DashboardTileDefinitionId.

Declaration

protected int _persistedDashboardTileDefinitionId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedDone

Persisted value, see property Done.

Declaration

protected short _persistedDone

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedGroupIdx

Persisted value, see property GroupIdx.

Declaration

protected int _persistedGroupIdx

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedIncludePerson

Persisted value, see property IncludePerson.

Declaration

protected int _persistedIncludePerson

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedLastLoaded

Persisted value, see property LastLoaded.

Declaration

protected DateTime _persistedLastLoaded

Field Value

Type	Description
DateTime

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedLastLoadedBy

Persisted value, see property LastLoadedBy.

Declaration

protected int _persistedLastLoadedBy

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedLastMembershipChange

Persisted value, see property LastMembershipChange.

Declaration

protected DateTime _persistedLastMembershipChange

Field Value

Type	Description
DateTime

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedLastMembershipChangeBy

Persisted value, see property LastMembershipChangeBy.

Declaration

protected int _persistedLastMembershipChangeBy

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedLeftSelectionId

Persisted value, see property LeftSelectionId.

Declaration

protected int _persistedLeftSelectionId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedMemberCount

Persisted value, see property MemberCount.

Declaration

protected uint _persistedMemberCount

Field Value

Type	Description
uint

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedName

Persisted value, see property Name.

Declaration

protected string _persistedName

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedPostitTextId

Persisted value, see property PostitTextId.

Declaration

protected int _persistedPostitTextId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedRegistered

Persisted value, see property Registered.

Declaration

protected DateTime _persistedRegistered

Field Value

Type	Description
DateTime

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedRegisteredAssociateId

Persisted value, see property RegisteredAssociateId.

Declaration

protected int _persistedRegisteredAssociateId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedRightSelectionId

Persisted value, see property RightSelectionId.

Declaration

protected int _persistedRightSelectionId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedSearchCatId

Persisted value, see property SearchCatId.

Declaration

protected int _persistedSearchCatId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedSelectionId

Persisted value, see property SelectionId.

Declaration

protected int _persistedSelectionId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedSeltype

Persisted value, see property Seltype.

Declaration

protected short _persistedSeltype

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedSoundEx

Persisted value, see property SoundEx.

Declaration

protected string _persistedSoundEx

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedSource

Persisted value, see property Source.

Declaration

protected short _persistedSource

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedSystemType

Persisted value, see property SystemType.

Declaration

protected SelectionSystemType _persistedSystemType

Field Value

Type	Description
SelectionSystemType

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedTargetTableNumber

Persisted value, see property TargetTableNumber.

Declaration

protected short _persistedTargetTableNumber

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedTextId

Persisted value, see property TextId.

Declaration

protected int _persistedTextId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedUpdated

Persisted value, see property Updated.

Declaration

protected DateTime _persistedUpdated

Field Value

Type	Description
DateTime

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedUpdatedAssociateId

Persisted value, see property UpdatedAssociateId.

Declaration

protected int _persistedUpdatedAssociateId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedUpdatedCount

Persisted value, see property UpdatedCount.

Declaration

protected short _persistedUpdatedCount

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_persistedVisibility

Persisted value, see property Visibility.

Declaration

protected short _persistedVisibility

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

Properties

AssociateId

.NET type: int. Associate who owns the selection

Declaration

public virtual int AssociateId { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

Setting this field to a new value will reset the Sentry and recalculate your rights based on the new value

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

ChartKey

.NET type: string. ID/key of the last-used chart tile on this selection

Declaration

public virtual string ChartKey { get; set; }

Property Value

Type	Description
string

Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CombinationType

.NET type: SelectionUnionType. How should the inputs of a combined selection be combined

Declaration

public virtual SelectionUnionType CombinationType { get; set; }

Property Value

Type	Description
SelectionUnionType

Remarks

Original type in dictionary: Enum.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((short)0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

CompanyUnique

.NET type: short. Only one person from a company may be selected as a member

Declaration

public virtual short CompanyUnique { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((Int16)0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

DashboardTileDefinitionId

.NET type: int. The associated tile definition

Declaration

public virtual int DashboardTileDefinitionId { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Done

.NET type: short. Done (0=false, 1=true). Status implies changes in which fields are shown in GUI, as well as which fields can be updated

Declaration

public virtual short Done { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: Bool.

Setting this field to a new value will reset the Sentry and recalculate your rights based on the new value

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((Int16)0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

GroupIdx

.NET type: int. Original primary user group of associate

Declaration

public virtual int GroupIdx { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

Setting this field to a new value will reset the Sentry and recalculate your rights based on the new value

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

IncludePerson

.NET type: int. 0 = Include first person, 1 = Include all persons, 2 = Include no persons

Declaration

public virtual int IncludePerson { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: Int.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

InnerFieldValuePairs

The values of all the fields in the row.
The first field is the primary key.
The index of the value corresponds to the name of the field returned from the Fields property.

Declaration

protected override ArgumentParameterCollection InnerFieldValuePairs { get; }

Property Value

Type	Description
ArgumentParameterCollection

Overrides

PrivateSave.InnerFieldValuePairs

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

InnerPrimaryKey

The primary key needed to decide which specific row to alter with the current sql-command.

Declaration

protected override FieldInfo InnerPrimaryKey { get; }

Property Value

Type	Description
FieldInfo

Overrides

PrivateSave.InnerPrimaryKey

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

InnerPrimaryKeyValue

The actual value the primary key must have.

Declaration

protected override Parameter InnerPrimaryKeyValue { get; }

Property Value

Type	Description
Parameter

Overrides

PrivateSave.InnerPrimaryKeyValue

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

IsDirty

Is the row dirty, e.g. been modified since the last time it was saved to the database.

Declaration

public override bool IsDirty { get; }

Property Value

Type	Description
bool

Overrides

TableRowBase.IsDirty

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

IsNew

Is this object new, meaning that it does not exist in the database.

Declaration

public override bool IsNew { get; }

Property Value

Type	Description
bool

Overrides

TableRowBase.IsNew

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

this[string]

Get or set a value based on the name of the field.

Declaration

public override object this[string fieldName] { get; set; }

Parameters

Type	Name	Description
string	fieldName	Name of the field in the database

Property Value

Type	Description
object	Value of the field.

Overrides

TableRowBase.this[string]

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

Exceptions

Type	Condition
ArgumentException	Thrown if the field is not known.

LastLoaded

.NET type: DateTime. The date/time this selection was last loaded (selectionentity fetched)

Declaration

public virtual DateTime LastLoaded { get; set; }

Property Value

Type	Description
DateTime

Remarks

Original type in dictionary: DateTime.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

LastLoadedBy

.NET type: int. Who last loaded this selection

Declaration

public virtual int LastLoadedBy { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

LastMembershipChange

.NET type: DateTime. The date/time the membership the selection last changed. Dynamic: change of criteria; Static: add/remove members; Combined: change of algorithm

Declaration

public virtual DateTime LastMembershipChange { get; set; }

Property Value

Type	Description
DateTime

Remarks

Original type in dictionary: DateTime.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

LastMembershipChangeBy

.NET type: int. Who last changed the membership

Declaration

public virtual int LastMembershipChangeBy { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

LeftSelectionId

.NET type: int. ID of the left selection of a combined selection

Declaration

public virtual int LeftSelectionId { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

MemberCount

.NET type: uint. How many selectionmembers (for progress bar)

Declaration

public virtual uint MemberCount { get; set; }

Property Value

Type	Description
uint

Remarks

Original type in dictionary: UInt.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((UInt32)0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Name

.NET type: string. Name, freetext indexed

Declaration

public virtual string Name { get; set; }

Property Value

Type	Description
string

Remarks

Original type in dictionary: String[220].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

PostitTextId

.NET type: int. Postit text

Declaration

public virtual int PostitTextId { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Registered

.NET type: DateTime. Registered when in UTC

Declaration

public virtual DateTime Registered { get; set; }

Property Value

Type	Description
DateTime

Remarks

Original type in dictionary: UtcDateTime.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (DateTime.MinValue)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

RegisteredAssociateId

.NET type: int. Registered by whom

Declaration

public virtual int RegisteredAssociateId { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

RightSelectionId

.NET type: int. ID of the right selection of a combined selection

Declaration

public virtual int RightSelectionId { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

SearchCatId

.NET type: int. Search category (list)

Declaration

public virtual int SearchCatId { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

SelectionId

.NET type: int. Primary key

Declaration

public virtual int SelectionId { get; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: PK.

This field is the primary key and can only be read, never written.

This field is not protected by the Sentry system, and can always be read

SelectionTableInfo

Get the SelectionTableInfo object associated with the row.

Declaration

public SelectionTableInfo SelectionTableInfo { get; }

Property Value

Type	Description
SelectionTableInfo

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

Seltype

.NET type: short. 0 = static selection, 1 = dynamic selection, 2 = combined selection. See the 'SystemType' field to disnguish between user selections, and Temporary or other system-managed kinds of selection

Declaration

public virtual short Seltype { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((Int16)0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

SoundEx

.NET type: string. What the name sounds like, for duplicate detection

Declaration

public virtual string SoundEx { get; set; }

Property Value

Type	Description
string

Remarks

Original type in dictionary: String[10].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Source

.NET type: short. How did we get this selection? For future integration needs

Declaration

public virtual short Source { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((Int16)0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

SystemType

.NET type: SelectionSystemType. Selection system type - defines if this selection is one that is managed by the system, and what kind it is

Declaration

public virtual SelectionSystemType SystemType { get; set; }

Property Value

Type	Description
SelectionSystemType

Remarks

Original type in dictionary: Enum.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

TableInfo

Get the TableInfo for the table.

Declaration

public override TableInfo TableInfo { get; }

Property Value

Type	Description
TableInfo	The TableInfo for the table.

Overrides

TableRowBase.TableInfo

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

TargetTableNumber

.NET type: short. Table number that this is a selection of (contact, sale, appointment, ....)

Declaration

public virtual short TargetTableNumber { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: TableNumber.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

TextId

.NET type: int. Description text

Declaration

public virtual int TextId { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Updated

.NET type: DateTime. Last updated when in UTC

Declaration

public virtual DateTime Updated { get; set; }

Property Value

Type	Description
DateTime

Remarks

Original type in dictionary: UtcDateTime.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (DateTime.MinValue)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

UpdatedAssociateId

.NET type: int. Last updated by whom

Declaration

public virtual int UpdatedAssociateId { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

UpdatedCount

.NET type: short. Number of updates made to this record

Declaration

public virtual short UpdatedCount { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((Int16)0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

Setting this field to a new value will not affect the Sentry calculations and your rights

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Visibility

.NET type: short. Obsolete, but still maintained denormalization of visiblefor

Declaration

public virtual short Visibility { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Methods

CreateNew()

Create a new instance of the SelectionRow object. Selections

Declaration

public static SelectionRow CreateNew()

Returns

Type	Description
SelectionRow	A new instance of the SelectionRow object.

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

GetFromCustomSearch(CustomSearch)

Create a new instance of the SelectionRow object, and populate it with data from a custom search. If the search returns no results, an object with IsNew will be returned; if the result contains one row, an object representing that row will be returned. If the result contains more than one row, the first row will be used and the rest discarded (there is no way of detecting this situation).

Declaration

public static SelectionRow GetFromCustomSearch(SelectionRow.CustomSearch query)

Parameters

Type	Name	Description
SelectionRow.CustomSearch	query	The custom search to execute against the database

Returns

Type	Description
SelectionRow	A new instance of the SelectionRow object, reflecting the result of the query.

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

GetFromIdxSelectionId(int)

Create a new instance of the SelectionRow object, by querying the database table via the index 'IDXSelId'. This method is intended to make it easy to use efficient queries that match a database index.

Declaration

public static SelectionRow GetFromIdxSelectionId(int selectionId)

Parameters

Type	Name	Description
int	selectionId

Returns

Type	Description
SelectionRow	Row object that represents the result of the search. IsNew will be true if the query did not match any row in the table

Remarks

This method represents one of the unique indexes on the Selection table. Non-unique indexes have corresponding inner classes and methods in the SelectionRows collection, since they may return more than one row.

GetFromReader(SoDataReader, SelectionTableInfo)

Create a new instance of the SelectionRow object, and populate it with data from a reader/tableinfo. If the reader has DBNull as the current value of the primary key field, an unpopulated object with IsNew == true will be returned. If any fields are missing or one of the non-primary key fields is DBNull, an exception will be thrown. Selections

Declaration

public static SelectionRow GetFromReader(SoDataReader reader, SelectionTableInfo tableInfo)

Parameters

Type	Name	Description
SoDataReader	reader	SoDataReader positioned to a valid database row.
SelectionTableInfo	tableInfo	SelectionTableInfo instance used in the query that is the source of the reader. The fields used from the reader will be those owned by this tableinfo object.

Returns

Type	Description
SelectionRow	A new instance of the SelectionRow object.

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

GetPersistedFieldValue(FieldInfo)

Get the persisted value of a field.

Declaration

public override object GetPersistedFieldValue(FieldInfo field)

Parameters

Type	Name	Description
FieldInfo	field	Specification of a field

Returns

Type	Description
object	Field value, such as an int, DateTime, string ... Null can be returned if the value is not known.

Overrides

PrivateSave.GetPersistedFieldValue(FieldInfo)

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

Exceptions

Type	Condition
ArgumentException	Thrown if the field is not known.

InternalSetValue(string, object)

Selections
Row Object for table 'selection'. Row objects correspond directly to database tables, and one instance of a row object represents one row in the corresponding table in the database.

Declaration

protected override void InternalSetValue(string fieldName, object value)

Parameters

Type	Name	Description
string	fieldName
object	value

Overrides

TableRowBase.InternalSetValue(string, object)

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

IsPersistedFieldValueKnown(FieldInfo)

Check if the persisted value for a field is known.

Declaration

public override bool IsPersistedFieldValueKnown(FieldInfo field)

Parameters

Type	Name	Description
FieldInfo	field	Specification of a field

Returns

Type	Description
bool	True if the value is known and sentry permits read.

Overrides

PrivateSave.IsPersistedFieldValueKnown(FieldInfo)

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnLoad(SoDataReader, TableInfo)

Fill the object with data returned from the database.

Declaration

protected override void OnLoad(SoDataReader reader, TableInfo tableInfo)

Parameters

Type	Name	Description
SoDataReader	reader	Object holding the data returned from the database.
TableInfo	tableInfo	The TableInfo used for the SELECT statement.

Overrides

TableRowBase.OnLoad(SoDataReader, TableInfo)

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnSave(BatchSave)

Add the object to the BatchSave list if it needs saving.

Declaration

protected override void OnSave(BatchSave batchSave)

Parameters

Type	Name	Description
BatchSave	batchSave	Collection of objects to be saved within the transaction.

Overrides

TableRowBase.OnSave(BatchSave)

Remarks

Classes overriding this method should call it.

OnSaved(bool)

Method called after the save operation has been performed.

Declaration

protected override void OnSaved(bool bSucceeded)

Parameters

Type	Name	Description
bool	bSucceeded	True if the save operation succeeded (e.g. transaction committed), or false if the save operation failed (e.g. transaction rolled back)

Overrides

TableRowBase.OnSaved(bool)

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

Reset()

Reset the changes made on the object.

Declaration

protected override void Reset()

Overrides

TableRowBase.Reset()

Remarks

If the row is not persisted to the database (e.g. IsNew is true), all the values will be reset. If the row has been persisted to or loaded from the database, the properties will be set to those of the last persisted or loaded values.

SetDefaults(DefaulterStrategy)

Set default values for the row.

Declaration

public override void SetDefaults(DefaulterStrategy strategy)

Parameters

Type	Name	Description
DefaulterStrategy	strategy	Strategy used when applying default values; values depend on where we are in the Create/Fetch/Populate/Save cycle

Overrides

TableRowBase.SetDefaults(DefaulterStrategy)

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

SetPrimaryKey(int)

Set the primary key for the row.

Declaration

protected override void SetPrimaryKey(int primaryKey)

Parameters

Type	Name	Description
int	primaryKey	The new primary key for the row.

Overrides

TableRowBase.SetPrimaryKey(int)

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

SetRowAsNew()

Selections
Row Object for table 'selection'. Row objects correspond directly to database tables, and one instance of a row object represents one row in the corresponding table in the database.

Declaration

public override void SetRowAsNew()

Overrides

TableRowBase.SetRowAsNew()

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

ToString()

ToString method intended for debugging, returns a string that displays the object type, new/dirty status, primary key and the string fields

Declaration

public override string ToString()

Returns

Type	Description
string

Overrides

object.ToString()

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

Validate(RowValidator)

Validate this row.

Declaration

public override void Validate(RowValidator rowValidator)

Parameters

Type	Name	Description
RowValidator	rowValidator	RowValidator for inserting the result of the validation

Overrides

TableRowBase.Validate(RowValidator)

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

Events

OnAssociateIdChange

Event raised when AssociateId is changing.

Declaration

public event OnFieldChange<int> OnAssociateIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnChartKeyChange

Event raised when ChartKey is changing.

Declaration

public event OnFieldChange<string> OnChartKeyChange

Event Type

Type	Description
OnFieldChange<string>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnCombinationTypeChange

Event raised when CombinationType is changing.

Declaration

public event OnFieldChange<SelectionUnionType> OnCombinationTypeChange

Event Type

Type	Description
OnFieldChange<SelectionUnionType>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnCompanyUniqueChange

Event raised when CompanyUnique is changing.

Declaration

public event OnFieldChange<short> OnCompanyUniqueChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnDashboardTileDefinitionIdChange

Event raised when DashboardTileDefinitionId is changing.

Declaration

public event OnFieldChange<int> OnDashboardTileDefinitionIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnDoneChange

Event raised when Done is changing.

Declaration

public event OnFieldChange<short> OnDoneChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnGroupIdxChange

Event raised when GroupIdx is changing.

Declaration

public event OnFieldChange<int> OnGroupIdxChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnIncludePersonChange

Event raised when IncludePerson is changing.

Declaration

public event OnFieldChange<int> OnIncludePersonChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnLastLoadedByChange

Event raised when LastLoadedBy is changing.

Declaration

public event OnFieldChange<int> OnLastLoadedByChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnLastLoadedChange

Event raised when LastLoaded is changing.

Declaration

public event OnFieldChange<DateTime> OnLastLoadedChange

Event Type

Type	Description
OnFieldChange<DateTime>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnLastMembershipChangeByChange

Event raised when LastMembershipChangeBy is changing.

Declaration

public event OnFieldChange<int> OnLastMembershipChangeByChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnLastMembershipChangeChange

Event raised when LastMembershipChange is changing.

Declaration

public event OnFieldChange<DateTime> OnLastMembershipChangeChange

Event Type

Type	Description
OnFieldChange<DateTime>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnLeftSelectionIdChange

Event raised when LeftSelectionId is changing.

Declaration

public event OnFieldChange<int> OnLeftSelectionIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnMemberCountChange

Event raised when MemberCount is changing.

Declaration

public event OnFieldChange<uint> OnMemberCountChange

Event Type

Type	Description
OnFieldChange<uint>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnNameChange

Event raised when Name is changing.

Declaration

public event OnFieldChange<string> OnNameChange

Event Type

Type	Description
OnFieldChange<string>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnPostitTextIdChange

Event raised when PostitTextId is changing.

Declaration

public event OnFieldChange<int> OnPostitTextIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnRegisteredAssociateIdChange

Event raised when RegisteredAssociateId is changing.

Declaration

public event OnFieldChange<int> OnRegisteredAssociateIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnRegisteredChange

Event raised when Registered is changing.

Declaration

public event OnFieldChange<DateTime> OnRegisteredChange

Event Type

Type	Description
OnFieldChange<DateTime>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnRightSelectionIdChange

Event raised when RightSelectionId is changing.

Declaration

public event OnFieldChange<int> OnRightSelectionIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnSearchCatIdChange

Event raised when SearchCatId is changing.

Declaration

public event OnFieldChange<int> OnSearchCatIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnSeltypeChange

Event raised when Seltype is changing.

Declaration

public event OnFieldChange<short> OnSeltypeChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnSoundExChange

Event raised when SoundEx is changing.

Declaration

public event OnFieldChange<string> OnSoundExChange

Event Type

Type	Description
OnFieldChange<string>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnSourceChange

Event raised when Source is changing.

Declaration

public event OnFieldChange<short> OnSourceChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnSystemTypeChange

Event raised when SystemType is changing.

Declaration

public event OnFieldChange<SelectionSystemType> OnSystemTypeChange

Event Type

Type	Description
OnFieldChange<SelectionSystemType>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnTargetTableNumberChange

Event raised when TargetTableNumber is changing.

Declaration

public event OnFieldChange<short> OnTargetTableNumberChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnTextIdChange

Event raised when TextId is changing.

Declaration

public event OnFieldChange<int> OnTextIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnUpdatedAssociateIdChange

Event raised when UpdatedAssociateId is changing.

Declaration

public event OnFieldChange<int> OnUpdatedAssociateIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnUpdatedChange

Event raised when Updated is changing.

Declaration

public event OnFieldChange<DateTime> OnUpdatedChange

Event Type

Type	Description
OnFieldChange<DateTime>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnUpdatedCountChange

Event raised when UpdatedCount is changing.

Declaration

public event OnFieldChange<short> OnUpdatedCountChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

OnVisibilityChange

Event raised when Visibility is changing.

Declaration

public event OnFieldChange<short> OnVisibilityChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onAssociateIdChange

Change envent for property AssociateId; field is of .NET type int.

Declaration

protected event OnFieldChange<int> _onAssociateIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onChartKeyChange

Change envent for property ChartKey; field is of .NET type string.

Declaration

protected event OnFieldChange<string> _onChartKeyChange

Event Type

Type	Description
OnFieldChange<string>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onCombinationTypeChange

Change envent for property CombinationType; field is of .NET type short.

Declaration

protected event OnFieldChange<SelectionUnionType> _onCombinationTypeChange

Event Type

Type	Description
OnFieldChange<SelectionUnionType>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onCompanyUniqueChange

Change envent for property CompanyUnique; field is of .NET type short.

Declaration

protected event OnFieldChange<short> _onCompanyUniqueChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onDashboardTileDefinitionIdChange

Change envent for property DashboardTileDefinitionId; field is of .NET type int.

Declaration

protected event OnFieldChange<int> _onDashboardTileDefinitionIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onDoneChange

Change envent for property Done; field is of .NET type short.

Declaration

protected event OnFieldChange<short> _onDoneChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onGroupIdxChange

Change envent for property GroupIdx; field is of .NET type int.

Declaration

protected event OnFieldChange<int> _onGroupIdxChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onIncludePersonChange

Change envent for property IncludePerson; field is of .NET type int.

Declaration

protected event OnFieldChange<int> _onIncludePersonChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onLastLoadedByChange

Change envent for property LastLoadedBy; field is of .NET type int.

Declaration

protected event OnFieldChange<int> _onLastLoadedByChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onLastLoadedChange

Change envent for property LastLoaded; field is of .NET type DateTime.

Declaration

protected event OnFieldChange<DateTime> _onLastLoadedChange

Event Type

Type	Description
OnFieldChange<DateTime>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onLastMembershipChangeByChange

Change envent for property LastMembershipChangeBy; field is of .NET type int.

Declaration

protected event OnFieldChange<int> _onLastMembershipChangeByChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onLastMembershipChangeChange

Change envent for property LastMembershipChange; field is of .NET type DateTime.

Declaration

protected event OnFieldChange<DateTime> _onLastMembershipChangeChange

Event Type

Type	Description
OnFieldChange<DateTime>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onLeftSelectionIdChange

Change envent for property LeftSelectionId; field is of .NET type int.

Declaration

protected event OnFieldChange<int> _onLeftSelectionIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onMemberCountChange

Change envent for property MemberCount; field is of .NET type uint.

Declaration

protected event OnFieldChange<uint> _onMemberCountChange

Event Type

Type	Description
OnFieldChange<uint>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onNameChange

Change envent for property Name; field is of .NET type string.

Declaration

protected event OnFieldChange<string> _onNameChange

Event Type

Type	Description
OnFieldChange<string>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onPostitTextIdChange

Change envent for property PostitTextId; field is of .NET type int.

Declaration

protected event OnFieldChange<int> _onPostitTextIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onRegisteredAssociateIdChange

Change envent for property RegisteredAssociateId; field is of .NET type int.

Declaration

protected event OnFieldChange<int> _onRegisteredAssociateIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onRegisteredChange

Change envent for property Registered; field is of .NET type DateTime.

Declaration

protected event OnFieldChange<DateTime> _onRegisteredChange

Event Type

Type	Description
OnFieldChange<DateTime>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onRightSelectionIdChange

Change envent for property RightSelectionId; field is of .NET type int.

Declaration

protected event OnFieldChange<int> _onRightSelectionIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onSearchCatIdChange

Change envent for property SearchCatId; field is of .NET type int.

Declaration

protected event OnFieldChange<int> _onSearchCatIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onSeltypeChange

Change envent for property Seltype; field is of .NET type short.

Declaration

protected event OnFieldChange<short> _onSeltypeChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onSoundExChange

Change envent for property SoundEx; field is of .NET type string.

Declaration

protected event OnFieldChange<string> _onSoundExChange

Event Type

Type	Description
OnFieldChange<string>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onSourceChange

Change envent for property Source; field is of .NET type short.

Declaration

protected event OnFieldChange<short> _onSourceChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onSystemTypeChange

Change envent for property SystemType; field is of .NET type int.

Declaration

protected event OnFieldChange<SelectionSystemType> _onSystemTypeChange

Event Type

Type	Description
OnFieldChange<SelectionSystemType>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onTargetTableNumberChange

Change envent for property TargetTableNumber; field is of .NET type short.

Declaration

protected event OnFieldChange<short> _onTargetTableNumberChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onTextIdChange

Change envent for property TextId; field is of .NET type int.

Declaration

protected event OnFieldChange<int> _onTextIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onUpdatedAssociateIdChange

Change envent for property UpdatedAssociateId; field is of .NET type int.

Declaration

protected event OnFieldChange<int> _onUpdatedAssociateIdChange

Event Type

Type	Description
OnFieldChange<int>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onUpdatedChange

Change envent for property Updated; field is of .NET type DateTime.

Declaration

protected event OnFieldChange<DateTime> _onUpdatedChange

Event Type

Type	Description
OnFieldChange<DateTime>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onUpdatedCountChange

Change envent for property UpdatedCount; field is of .NET type short.

Declaration

protected event OnFieldChange<short> _onUpdatedCountChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

_onVisibilityChange

Change envent for property Visibility; field is of .NET type short.

Declaration

protected event OnFieldChange<short> _onVisibilityChange

Event Type

Type	Description
OnFieldChange<short>

Remarks

Row objects can be created in several ways.

Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
You can create a (nested) SelectionRow SelectionRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.SelectionRow.IsNew and SuperOffice.CRM.Data.SelectionRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the SelectionTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, SelectionTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Unique indexes on table Selection are:

Index fields	Nested index class name

Implements

INestedPersist

ISoDataLookup

ISentryIgnorable

ISoItem

Extension Methods

EnumUtil.MapEnums<From, To>(From)

SelectionRecordDataExtensions.ToRecordData(SelectionRow)

Converters.MapEnums<From, To>(From)

QueryExectionExtensions.ExecuteNonQuery(SqlCommand)

QueryExectionExtensions.ExecuteReader(SqlCommand, bool)

QueryExectionExtensions.ExecuteScalar<T>(SqlCommand)