SD.LLBLGen.Pro.ORMSupportClasses Namespace

Classes

	Class	Description
	ActionQuery	Implementation of the ActionQuery class.
	ActionQueueElementTEntity	Internal class to store entities in an action queue (insertqueue or update queue)
	AggregateSetPredicate	Predicate class which performs an aggregate function on a set of entities and returns true or false depending if that aggregated value matches a specified expression. The set of entities this predicate is applied on are the elements of a member property with the name specified which match the specified filter.
	AliasScope	Class which is used as an alias scope in a DbSpecificCreator.
	ArgumentVerifier	Class which contains argument verification logic and which can throw exceptions if necessary. This code makes it easier to verify input arguments.
	AuditorBase	Abstract base class for auditors in the LLBLGen Pro system. Use this class to easily create auditors to perform auditing for you.
	AuthorizerBase	Abstract base class for authorizers in the LLBLGen Pro system. Use this class to easily create authorizers.
	BatchActionQuery	Action query which contains multiple action queries which have to be executed in the order in which they're stored. Used for multi-target entities, like saving an inherited entity in a target-per-entity hierarchy.
	BooleanCharYNConverter	Definition of the BooleanCharYNConverter. This converter uses 'Boolean' as its core type and converts 'Y' and 'N' to and from boolean. 'Y' / 'y' is seen as 'true'. 'N' / 'n' is seen as 'false'
	BooleanNumericConverter	Definition of the BooleanNumericConverter. This converter uses 'Boolean' as its core type and converts numeric values to and from boolean. Any value other than 0 is seen as true, and 0 is seen as false.
	ByteDecimalConverter	Definition of the ByteDecimalConverter. This converter uses 'Byte' as its core type and converts any decimal value to and from Byte
	CacheableChecker	Simple visitor which checks whether the visited expression is cachable or not. An expression isn't cachable if the expression contains constant expressions which reference an object as that can be a displayclass (stackframe).
	CacheController	The controller which is the central place where caches live. Use this class to register a cache for a given connection string.
	CachedResultset	Class which represents a cached resultset. A cached resultset is a list of object arrays and a number indicating the number of columns in the resultset. The object arrays are objects read from a datareader and can be used with a wrapping reader as if it's read from the DB. All values, including byte arrays are considered value types and are shared among all objects which are receiving the values.
	CachedResultsetDataReader	DataReader which is used to traverse a cached resultset.
	CacheItemT	Wrapper object for objects which are placed in the resultsetcache.
	CacheKey	Key object which is used to uniquely identify a query with its arguments.
	CancelableCollectionChangedEventArgs	Event args which are used for collection changed events and which is raised by cancelable actions. Set the Cancel flag to cancel the action which raised the event.
	CancelableDataSourceActionEventArgs	Event args class which is the cancelable variant of the DataSourceActionEventArgs event args class
	CatalogNameOverwriteHashtable	Specialized Hashtable which contains name-value pairs for name overwriting for catalog names names in adapter on some databases (db2, sqlserver)
	CharStringConverter	Definition of the CharStringConverter. This converter uses 'Char' as its core type and converts the char to and from a string.
	CollectionChangedEventArgs	EventArgs class for events raised by the entity collection classes for various actions.
	CollectionCoreT	Generic base class for the entity collection classes used by Selfservicing and adapter. This class is mainly written to be able to tap into Add/Remove/Insert etc. without problems: the shipped collection classes in .NET don't have the ability to override Add etc.
	ComPlusAdapterContextBase	Obsolete. ComPlusAdapterContextBase class. Abstract class which is the base for the ComPlusAdapterContext classes used in Adapter for hosting a COM+ aware DataAccessAdapter class. Use the hosted DataAccessAdapter class to start a new COM+ transaction.
	ConfigFileHelper	Static class which contains logic used by the generated code to read data from config files.
	Context	General Context class which provides uniquing support for the object fetcher. A developer can use this class to create a space for objects where every entity is loaded just once.
	CorrelationPredicateExpression	Simple wrapper class which wraps a predicate and allows logic to work with that predicate differently because it's seen as a correlation predicate, which means e.g. inheritance hierarchy relationships shouldn't be added because of elements inside this predicate expression.
	CustomXmlSerializationAttribute	Simple attribute which signals the xml serialization/deserialization logic for adapter to call out to custom routines (PerformCustomXmlSerialization and PerformCustomXmlDeserialization) for serialization and deserialization of the property data.
	DaoBase	Base class for DAO classes which are generated.
	DataAccessAdapterBase	Base class for DAA classes which are generated and which serves as an in-between type between those generated classes and the actual implementation in DataAccessAdapterCore. This class contains overrides of the actual action methods in DataAccessAdapterCore so they can be executed with a strategy.
	DataAccessAdapterCore	Base class for DAA classes which are generated.
	DataProjectorToCustomClassT	Projector to project plain projection data onto a custom class which can be an anonymous type.
	DataProjectorToDataTable	Projector engine which projects plain projection result data onto datarows which are added to a single datatable. Used by creation of projections of EntityView(2) data to datatables.
	DataProjectorToEntityCollectionBase	Abstract base class for the two collection projectors
	DataProjectorToIEntityCollection	Projector engine which projects plain projection result data onto new entities which are added to a single entitycollection.
	DataProjectorToIEntityCollection2	Projector engine which projects plain projection result data onto new entities which are added to a single entitycollection.
	DataProjectorToObjectRowList	Simple class which doesn't do any projection work, it simply adds all received rows to the results list.
	DataProjectorToValueListT	Projector engine which projects plain rpojection result data onto a value list. This means that a single value is picked from the row to project and placed in the list to fill. The value in a plain row is used to project onto the destination.
	DataReaderProjectionRow	Simple class which wraps an IDataReader and performs fast ordinal based access on the datareader with null value checking and conversion. Used by low-level SQL api to fast project a resultset to a poco type.
	DataScope	Abstract base class to create a custom data scope class.
	DataSourceActionEventArgs	Event args class which is used with LLBLGenProDataSource(2) action events. This is the non-cancelable variant.
	DataSourceDesigner2ConfigurationForm	Special designer form which is popped up when the user clicks 'Configure data source' on an LLBLGenProDataSource2 component on an ASP.NET webform.
	DataSourceDesignerConfigurationForm	Special designer form which is popped up when the user clicks 'Configure data source' on an LLBLGenProDataSource component on an ASP.NET webform.
	DataTableFiller	Utility class which fills the passed in datatable using the passed in open reader and the persistence info. It performs conversion along the way. It creates new columns if no columns are defined in the datatable, otherwise re-uses the columns.
	DataValueProjector	General class which defines the projection result and destination of a value in an object[] array.
	DateTimeDateTimeUTCConverter	Definition of the DateTimeDateTimeUTCConverter. This converter uses 'DateTime' as its core type and converts the DateTime to and from a DateTime which is considered to be a date/time value in UTC format.
	DbFunctionCall	Class which implements a function call to a database function and which is used on an EntityField(2) in a query.
	DbProviderFactoryInfo	Class which contains the DbProviderfactory information for a specific DQE.
	DbSpecificCreatorBase	Base class for every DbSpecificCreator implementation
	DelegatePredicate	Predicate class to filter in-memory entity collections based on a specified callback function.
	DelegatePredicateTEntity	Generic version of the DelegatePredicate predicate, to use with Predicate(Of T) predicates, which can be constructed with Lambda expressions.
	DependencyInjectionConfigInformation	Class which is used for storing the information read from a DependencyInjectionInformation section in the config file. Instances are created by the DependencyInjectionSectionHandler
	DependencyInjectionDiscoveryInformation	Static class which is used to set discovery information for dependency injection info for the situation when there's no config file available in the application. Set the variables of this static class as soon as possible at the startup of your application so the initialization of this class, if required, is ran before an entity is instantiated so the DependencyInjectionInfoProvider is initialized after this class is initialized by your application.
	DependencyInjectionInfoAttribute	Attribute definition to define dependency injection information on a class which instances are injected into other objects (targets). A usage of this attribute can be for example a validator class which is injected at runtime into an entity object to be its validator object to use.
	DependencyInjectionInfoProviderSingleton	Singleton class which contains the single instance of the DependencyInjectionProvider
	DependencyInjectionScope	Abstract class which defines a Dependency Injection scope in which dependency injection takes place with the information provided with this scope.
	DependencyInjectionSectionHandler	Handles the DependencyInjectionInformation section in the config file and creates an instance of DependencyInjectionConfigInformation with information stored in the section.
	DerivedTableDefinition	Class to define a derived table. A derived table is a select statement which is used inside a FROM clause of a query. Use derived table definitions in combination of DynamicRelation objects to build your query.
	DerivedTableFinder	Class which finds all derived table definitions in the object to traverse, e.g. a relation collection.
	DerivedTableTargetingFieldFinder	Class which is used to find all fields in query elements which target a derived table. These fields then can be post-processed to see if they have to be renamed because they're in an inheritance hierarchy.
	DesignTimeTracker	Simple class which tracks whether a class is in design mode or not. This is a global flag as everything is either in design mode or nothing is.
	DoubleDecimalConverter	Definition of the DoubleDecimalConverter. This converter uses 'Double' as its core type and converts any decimal value to and from Double
	DQEConfigurationBase	Base class for DQE Configuration classes which are used with the RuntimeConfiguration system
	DynamicQueryEngineBase	Central base class for all DynamicQueryEngine classes. Shared logic is placed in this class, which can be overriden in the DynamicQueryEngine classes per database.
	DynamicRelationBase	Abstract base class for the DynamicRelation class which is generated. Dynamic relations have always their left operand defined as the 'pk' side if applicable.
	ElementCreatorBase	Base class for elementcreator/elementcreator2 which are in the generated code.
	EntityBase	General Entity Base class, which is used to inherit the Entity classes from.
	EntityBase2	General Entity Base class, which is used to inherit the Entity classes from. Used in the Adapter template set. This entity does not have any persistence info on board.
	EntityCollectionBaseTEntity	Implementation of the entity collection base class.
	EntityCollectionBase2TEntity	Implementation of the entity collection base class.
	EntityCollectionNonGeneric	EntityCollection implementation which is used for backwards compatibility and for design time databinding. This EntityCollectionNonGeneric is an EntityCollectionBase2(Of EntityBase2)
	EntityCoreTFields	Core class for the entity classes in both Adapter and SelfServicing.
	EntityCoreTFieldsEntityStaticMetaDataBase	Base class for meta-data for an entity definition, which is used by this base class to perform various operations without generated code. This class is inherited by classes in the generated entities.
	EntityFactoryCache2	Cache class which ensures that only one instance of an entity factory is created/stored during serialization
	EntityFactoryCore	Abstract base class for entity factories. The class is suffixed with 'Core' as the generated code contains another base class, EntityFactoryBase, which is the direct base class for the generated entity factories.
	EntityFactoryCore2	Abstract base class for entity factories. The class is suffixed with 'Core' as the generated code contains another base class, EntityFactoryBase2, which is the direct base class for the generated entity factories.
	EntityField	Generic class which is used for the columns in the EntityFields collection, which forms the data store of any Entity class generated by LLBLGen Pro.
	EntityField2	Generic class which is used for the columns in the EntityFields collection, which forms the data store of any Entity class generated by LLBLGen Pro.
	EntityFieldCore	Generic base class for entity fields.
	EntityFieldPersistenceInfoList	Special List which gets at construction time an entityfields array and an fieldpersistenceinfo array and splits it per target into a separate entry: a TargetFieldPersistenceInfoBucket, which contains 2 arrays with the information for that target. It normally contains the same information as it gets at construction time, though in scenarios where inheritance is used and a target-per- entity hierarchy, this class is useful in update/insert/delete query building.
	EntityFields	Class which forms the EntityFields2 type. An EntityFields type is a collection of IEntityField objects which forms the total amount of fields for a given entity. SelfServicing specific
	EntityFields2	Class which forms the EntityFields2 type. An EntityFields2 type is a collection of IEntityField2 objects which forms the total amount of fields for a given entity. Adapter specific
	EntityFieldsCoreTField	General base class for Entity Fields classes.
	EntityProperty	Class which at runtime represents an entity property, and which is used in Predicate expressions for filtering and sorting in-memory using EntityView(2) objects. Both selfservicing and adapter use this class.
	EntityPropertyDescriptor	EntityPropertyDescriptor implementation for adding property descriptors for entity fields in a complex databinding scenario.
	EntityPropertyProjector	General class which defines the projection result and destination of a property of an entity.
	EntityRelation	Generic implementation of the IEntityRelation interface, which is used for relations between IEntity* instances.
	EntitySyncInfoTEntity	General synchronization information class for related entities to an existing entity. Used to keep track of which entity is set as a related entity using which relation and which field mapped on that relation so when the related entity is saved, it will be synced with the correct fields. The related entity is called a Data Suppling Entity.
	EntityViewTEntity	EntityView provides 'view' capabilities for an entity collection. This class supports filtering and sorting in-memory, using type safe objects. Binding an entity collection to a grid or other complex databinding control will actually make the control bind to an instance of this class.
	EntityView2TEntity	EntityView2 provides 'view' capabilities for an entity collection. This class supports filtering and sorting in-memory, using type safe objects. Binding an entity collection to a grid or other complex databinding control will actually make the control bind to an instance of this class.
	EntityViewBaseTEntity	Generic entity view base class, which provides the core class code for the EntityView class. EntityView provides 'view' capabilities for an entity collection. This class supports filtering and sorting in-memory, using type safe objects. Binding an entity collection to a grid or other complex databinding control will actually make the control bind to an instance of this class.
	ExceptionInfoRetriever	Class which retrieves information from a passed in exception which is specific to a DB type, and returns it to the caller.
	ExcludeFieldsList	Helper class which is a derived class from ExcludeIncludeFieldsList containing just fields to exclude
	ExcludeIncludeFieldsList	Class which is used for specifying fields to exclude or include in a fetch. If an instance of this list is passed to a fetch method which accepts an ExcludeIncludeFieldsList, the fields in this list are either excluded from the query (if ExcludeContainedFields is true (default)), or are used to exclude the rest of the fields in the query except the fields in this list.
	Expression	Expression class which defines field expressions which are applied to fields in a select list, in update queries or in field predicates. Valid expressions: FieldField ExOp FieldField ExOp ValueField ExOp ExpressionValue ExOp FieldValue ExOp ExpressionExpression ExOp FieldExpression ExOp Value Use one of the constructors to create the particular expression object.
	ExpressionElementT	ExpressionElement class, definition for elements contained in an expression.
	ExpressionFieldElement	ExpressionFieldElement class, definition for field elements contained in an expression
	ExtensionMethods	Class with various extension methods for various classes.
	FastDeserializer	The de-serializer class which takes care of the fast deserialization of data serialized with the FastSerializer class when SerializationHelper.Optimization is set to 'Fast'
	FastDictionaryTKey, TValue	Utility class which can be used instead of a normal Dictionary class when the Dictionary class is serialized. This class is faster and has much less overhead than the normal dictionary class, as it doesn't use generic types. Has no additional value for CF.NET
	FastSerializer	The serializer class which takes care of the fast serialization when SerializationHelper.Optimization is set to 'Fast'
	FastSerializerSurrogate	Class to act as a surrogate for the fast serializer.
	FastSerializerSurrogateSelector	Class to select the proper surrogate for the fast serializer
	FieldBetweenPredicate	Implementation of a Field Between ValueBegin And ValueEnd expression, using the following format: IEntityField(Core) Between Parameter1 And Parameter2 (f.e Foo BETWEEN @Foo1 AND Foo2) There is no check for types between the values specified and the specified IEntityField.
	FieldCompareExpressionPredicate	Implementation of a Field compare-operator Expression expression, using the following format: IEntityField(Core) ComparisonOperator Expression (f.e. Foo = (Bar * 2))
	FieldCompareNullPredicate	Implementation of a Field Compare NULL expression using the following format: IEntityField(Core) IS NULL (f.e. Foo IS NULL).
	FieldCompareRangePredicate	Implementation of a Field compare-range Values expression, using the following format: IEntityField(Core) ComparisonOperator Parameters (f.e. Foo IN (@Foo1, @Foo2 ... )) There is no check for types between the value specified and the specified IEntityField.
	FieldCompareSetPredicate	Implementation of a Field compare-operator Set expression, using the following format: IEntityField(Core) ComparisonOperator (Subquery)
	FieldCompareValuePredicate	Implementation of a Field compare-operator Value expression, using the following format: IEntityField(Core) ComparisonOperator Parameter (f.e. Foo = @Foo) There is no check for types between the value specified and the specified IEntityField.
	FieldFullTextSearchPredicate	FieldFullTextSearchPredicate class. CONTAINS(IEntityField(Core), Parameter) (f.e. CONTAINS(Foo, @Foo) ) FREETEXT(IEntityField(Core), Parameter) (f.e. FREETEXT(Foo, @Foo) ) SqlServer specific. On SqlServer 2005, also multi-field CONTAINS/FREETEXT predicates are supported.
	FieldInfo	General container class for static field information which is readonly at runtime and which is equal for all instances of a given field. This information is shared among all instances of an entity, and therefore saves a lot of memory at runtime.
	FieldLikePredicate	Implementation of a LIKE predicate expression, using the following formats: IEntityField(Core) LIKE Parameter (f.e. Foo LIKE @Foo ) A specified pattern will be set as the parameters value.
	FieldPersistenceInfo	Generic class which holds the generic information for entity field persistence of an entity field. Instances of this interface are passed to logic with an instance of the IEntityFieldCore interface. SelfServicing implements both interfaces in one interface: IEntityField. Generic
	FieldUtilities	Various field related routines
	FromClauseElementDirective	Class which is used to specify a FROM clause directive for a SQL query, e.g. a table/view hint or a temporal table predicate.
	FunctionMapping	Class which is used to define a function mapping between a .NET operator or function / method and a database function / operator. Mainly used for Linq support, however one could use this list also in .NET 2.0 code
	FunctionMappingStore	Class which is used to store function mapping related data.
	GeneralUtils	General container class for static utility methods which have no better grouping class.
	GenericExpressionVisitor	Generic class for the expression visitors. This class visits the expressions, and doesn't 'handle' them, i.e. it doesn't reconstruct objects again, it simply traverses the expression tree elements. All methods return the element visited without changes, unless overriden methods in subtypes change elements, which isn't recommended: in that case derive from GenericExpressionHandler.
	GroupByCollection	GroupByCollection class which is used to collect EntityField(2) instances which are used for the GROUP BY clause in a retrieval query. When a group by collection is specified in a retrieval query, all fields in the resultset have to be in this collection. Generic
	GuidByteArrayConverter	Definition of the GuidByteArrayConverter. This converter uses 'Guid' as its core type and converts the Guid to and from a byte array. It uses Guid.ToByteArray, which results in a byte array containing the bytes of the Guid.
	GuidStringConverter	Definition of the GuidStringConverter. This converter uses 'Guid' as its core type and converts the Guid to and from a string (char(32)). It uses Guid.ToString("N"), which results in 32 continous digits without any separators/wrappers.
	IncludeFieldsList	Helper class which is a derived class from ExcludeIncludeFieldsList containing just fields to include
	IncludeInCompactXmlAttribute	Simple attribute which is used to mark a property in an entity collection that it has to be included in Compact XML. Compact XML is used when the entity collection is send to/from a webservice.
	InheritanceInfo	Simple class which contains the inheritance information of an entity, and which is produced by an inheritanceinfoprovider.
	Int16DecimalConverter	Definition of the Int16DecimalConverter. This converter uses 'Int16' as its core type and converts any decimal value to and from Int16
	Int32DecimalConverter	Definition of the Int32DecimalConverter. This converter uses 'Int32' as its core type and converts any decimal value to and from Int32
	Int64DecimalConverter	Definition of the Int64DecimalConverter. This converter uses 'Int64' as its core type and converts any decimal value to and from Int64
	LLBLGenProDataSource	General data source control which can be used in ASP.NET projects to perform design time databinding and runtime databinding.
	LLBLGenProDataSource2	General data source control which can be used in ASP.NET projects to perform design time databinding and runtime databinding.
	LLBLGenProDataSourceBase	General datasource control base class for the selfservicing/adapter datasource controls for ASP.NET
	LLBLGenProDataSourceDesigner	General designer class for the LLBLGen Pro DataSource control.
	LLBLGenProDataSourceDesigner2	General designer class for the LLBLGen Pro DataSource control.
	LLBLGenProDataSourceView	General implementation of the DataSourceView class to be used with LLBLGenProDataSource control in ASP.NET applications.
	LLBLGenProDataSourceView2	General implementation of the DataSourceView class to be used with LLBLGenProDataSource control in ASP.NET applications.
	LLBLGenProDataSourceViewBase	General base class for DatSourceView objects for selfservicing and adapter.
	LLBLGenProDesignerDataSourceView	General datasourceview for design time databinding
	LLBLGenProDesignerDataSourceView2	General datasourceview for design time databinding
	MemberPredicate	Predicate class which allows in-memory filters to perform a predicate on one or more related entities. The entity this predicate is applied on has to have a member property with the name specified. Each element in that member (or the member itself, in case of a single instance) will be interpreted with the specified filter. The result of that interpretation is used together with the MemberOperator specified what the result of this predicate will be: true or false, in which case the entity this predicate is applied on is accepted (true) or not (false).
	MergeableDictionaryTKey, TValue	Specialized Hashtable which allows merging with a passed-in hashtable.
	ModelInfoProviderBase	Abstract base class for the InfoProvider generated class which contains both the field info provider and the inheritance info provider.
	MultiValueDictionaryTKey, TValue	Extension to the normal Dictionary. This class can store more than one value for every key. It keeps a HashSet for every Key value. Calling Add with the same Key and multiple values will store each value under the same Key in the Dictionary. Obtaining the values for a Key will return the HashSet with the Values of the Key. It can also merge with other instances of MultiValueDictionary, as long as the TKey and TValue types are equal.
	MultiValueHashtableTKey, TValue	Specialized hashtable which can store multiple values for a given key. All values are stored in an UniqueValueList as value. When the value is requested, the UniqueValueList is returned, not the actual value.
	NodeEntityReference	Class which contains the data to set an entity reference found in an XmlNode to an entity instance. Instances of this class are used to store entity references found in an Xml tree in ReadXml() so these references can be set once the complete object tree is created and objects are known.
	NumericValueOperatorExecutor	Utility class which operates on numeric values and which applies arithmetic operations.
	ObjectGraphUtils	Some utility functions to process graphs
	ORMBadSequenceException	Exception which is thrown when a bad sequence value is detected after an insert.
	ORMConcurrencyException	General exception class which is thrown when there is a concurrency error during a save action or a delete action. A concurrency error occurs if the Save action of an entity fails, i.e. when no rows were affected by the save, or when an entity is deleted and a delete restriction has been set and no rows were affected by the delete action.
	ORMConfigurationException	Exception class for configuration related errors.
	ORMEntityIsDeletedException	General exception class which is thrown when a user tries to get a value from a field of an entity which is marked as Deleted.
	ORMEntityOutOfSyncException	General exception class which is thrown when a user tries to get a value from a field of an entity which is marked as OutOfSync, and needs to be refetched.
	ORMEntityValidationException	General exception class which is thrown by a validation error.
	ORMException	Abstract base class for all ORM exceptions.
	ORMFieldIsNullException	General exception class which is thrown when a user tries to get a value from a field which is null.
	ORMFieldIsReadonlyException	General exception class which is thrown when a user sets a field which is readonly.
	ORMGeneralOperationException	Exception which is thrown when the general operation of the o/r core isnt used correctly, like bad imput has been given and no other exception is appropriate.
	ORMInheritanceInfoException	General exception which is thrown when an error is determined in the inheritance info during query execution.
	ORMInterpretationException	General exception which is thrown when an interpretation error occurs during predicate / sortclause interpretation for filtering or sorting in-memory in an EntityView(2).
	ORMInvalidFieldReadException	Exception which is thrown when a developer reads a field from a new entity which isn't set to a value yet. Only thrown when the EntityBase(2).MakeInvalidFieldReadsFatal flag is set to true (default: false).
	ORMLockTimeoutException	timeout exception for TimeOut locks used inside the code. This exception should only pop up when a timed lock timed out, which is to prevent deadlocks.
	ORMQueryConstructionException	General exception which is thrown when an error occurs during the construction of the query to execute.
	ORMQueryExecutionException	General exception class which is thrown when an exception was caught during a query execution. Contains the original exception as inner exception.
	ORMRelationException	General exception class which is thrown when something is wrong with a relation or with the context the relation is used in (ToQueryText in RelationCollection for example)
	ORMSecurityException	Exception class which is usable for security exceptions thrown by authorizers.
	ORMSerializationOptimizationException	Exception class which is thrown when a value being optimized does not meet the required criteria for optimization.
	ORMTransientRecoveryFailedException	Exception class which is thrown when the maximum number of retries has been attempted or when the maximum delay has been reached.
	ORMValueTypeMismatchException	General exception class which is thrown when a user sets a field to a value which doesn't match the type of the field.
	ParameterFieldRelation	Class to define the relation between a parameter of a query and a field. This relation is used to find back a related EntityFieldCore instance when an Output Parameter is found in a query so the value of the Output Parameter can be assigned to the related EntityField
	ParameterParameterRelation	Class to define a relation between two parameters, one is the source and one is the destination. These relation objects are used in multi-command queries for inserting multi-target entities.
	ParameterValue	Class which is used to specify parameter specific aspects for a value specified in a plain SQL query call.
	PerformGetDbCountEventArgs	Event arguments class which is passed as argument in the PerformDbCount event on an LLBLGenProDataSource control.
	PerformGetDbCountEventArgs2	Event arguments class which is passed as argument in the PerformDbCount event on an LLBLGenProDataSource2 control.
	PerformSelectEventArgs	Event arguments class which is passed as argument in the PerformSelect event on an LLBLGenProDataSource2 control
	PerformSelectEventArgs2	Event arguments class which is passed as argument in the PerformSelect event on an LLBLGenProDataSource2 control
	PerformWorkEventArgs	Event arguments class which is passed as argument in the PerformWork event on an LLBLGenProDataSource control.
	PerformWorkEventArgs2	Event arguments class which is passed as argument in the PerformWork event on an LLBLGenProDataSource control.
	PersistenceCore	Class which is used to store core methods used in various parts of the persistence pipeline, and which are shared among selfservicing and adapter.
	PersistenceInfoProviderBase	Abstract class for the persistence info provider class which is used to provide FieldPersistenceInfo objects for fields/entities.
	PlainSQLFetchAspects	Simple class which is used to specify aspects about a fetch query specified as plain SQL.
	Predicate	Abstract base implementation of the IPredicate interface.
	PredicateExpression	Implementation of the IPredicateExpression interface.
	PredicateExpressionElement	Implementation of the IPredicateExpressionElement interface
	PredicateWrapper	Small class which wraps a predicate so it can be placed in an IExpression element, like a scalar query expression or dbfunction call.
	PrefetchPath	PrefetchPath class, which specifies a prefetch path to fetch related entities during a fetch. SelfServicing specific.
	PrefetchPath2	PrefetchPath class, which specifies a prefetch path to fetch related entities during a fetch. Adapter specific.
	PrefetchPathElement	PrefetchPathElement class.
	PrefetchPathElement2	PrefetchPathElement2 class.
	ProjectionLiteral	Simple class which is used to emit a literal value into the projection. It subclasses dbfunctioncall as that's the class to use to emit a custom SQL fragment into the query, however we need to specialize it to avoid the () suffix for a function call.
	ProjectionRow	Simple class which wraps an object array and allows type converson and name-based indexing. Used in projections of DynamicQuery resultsets.
	Query	Abstract query class for the various query objects in the framework.
	QueryApiObjectTraverser	Class which is used to traverse over an llblgen pro object, like a derivedtable, predicate expression etc. and access all inner objects, including fields.
	QueryFragments	Class which is used to specify separate query fragments in one container which is then usable to produce a single query string. The delimiter is added as a fragment when a fragment is added.
	QueryParameters	Bucket class which contains all the parameters for formulating a set fetch query.
	RecoveryDelay	Class which handles calculation of the next delay period (in seconds) based on parameters contained within the class. As defaults it uses for maximumDelay: 30 seconds, for delayParameter: 2 and for delayType: RecoveryStrategyDelayType.Exponential.
	RecoveryStrategyBase	Base class for transient error recovery stategies. Not thread safe.
	ReferencedEntityMap	Class which is used to store maps to referenced entities to be able to serialize an entity which is referenced multiple times only once.
	RelationCollection	Class which is used to stack relation objects between several entities to build a complete join path
	RelationFactory	Abstract base class for all generated relation classes.
	RelationPredicateBucket	IRelationPredicateBucket implementation which can be used as a single unit to pass to a data-access adapter for filtering over multi-entities.
	ResultsetCache	Default implementation of the resultsetcache interface.
	RetrievalQuery	Implementation of the RetrievalQuery class.
	RuntimeConfiguration	Central configuration class to allow configuration of various runtime elements at the code level without the requirement of a config file.
	RuntimeConfigurationEntityConfigMethods	Class for the set methods to configure Entity(Core) related settings
	RuntimeConfigurationPrefetchPathConfigMethods	Class for the set methods to configure PrefetchPath/PrefetchPath2 instances in the runtime.
	RuntimeConfigurationTracingConfigMethods	Class for the set methods to configure TraceSwitch instances in the runtime.
	RuntimeConfigurationXmlConfigMethods	Class for the set methods to configure Xml serialization specific settings
	ScalarQueryExpression	Class which implements a scalar query which is usable inside an expression. This expression assumes the query formulated will result in a single value. If that's not the case, use the overload of the CTor which accepts a value for forceRowLimit or set its ForceRowLimit property to true (default: false). If forceRowLimit is set to true, a TOP 1 clause will be emitted into the query to force the query to result into a single value. Normally you don't need to do this as a scalar query has to be formulated as a single value anyway.
	SchemaNameOverwriteHashtable	Specialized Hashtable which contains name-value pairs for name overwriting for schema names names in adapter on some databases (db2, sqlserver and oracle)
	SequenceRetrievalQuery	Class for sequence retrieval queries. Sequence retrieval queries are scalar queries (returning a value) which are used to retrieve the actual / to use sequence value in systems which do not support batched queries. Normally every DQE will batch the sequence retrieval query into the INSERT query as a batched query, however some systems do not support this and the only solution is the SequenceRetrievalQuery. Used for Access, Firebird and other systems. SequenceRetrievalQueries can be added to IActionQuery instances and will use the IActionQuery object's connection object.
	SerializationHelper	Helper class containing: - The default serialization to use. - Some string constants used as names in SerializationInfo - Some shared routines used for fast serialization to save duplication
	SerializationReader	A SerializationReader instance is used to read stored values and objects from a byte array. Once an instance is created, use the various methods to read the required data. The data read MUST be exactly the same type and in the same order as it was written.
	SerializationUtils	Small class which helps with versioning in binary normal serialization code. It allows swallowing of exceptions which occur when incompatible binary data is deserialized with newer code which expects members to be there.
	SerializationWriter	Class which defines the writer for serialized data using the fast serialization optimization. A SerializationWriter instance is used to store values and objects in a byte array. Once an instance is created, use the various methods to store the required data. ToArray() will return a byte[] containing all of the data required for deserialization. This can be stored in the SerializationInfo parameter in an ISerializable.GetObjectData() method. As an alternative to ToArray(), if you want to apply some post-processing to the serialized bytes, such as compression, call AppendTokenTables first to ensure that the string and object token tables are appended to the stream, and then cast BaseStream to MemoryStream. You can then access the MemoryStream's internal buffer as follows: Examples Copy writer.AppendTokenTables(); MemoryStream stream = (MemoryStream) writer.BaseStream; serializedData = MyCompressor.Compress(stream.GetBuffer(), (int)stream.Length);
	SimpleRetryRecoveryStrategy	Default recovery stategy which simply re-tries a failed execution of work, no matter what the error is.
	SingleDecimalConverter	Definition of the SingleDecimalConverter. This converter uses 'Single' as its core type and converts any decimal value to and from Single
	SortClause	Class which implements ISortClause, a class which forms a single sort clause, thus an order by definition defined for a single IEntityField.
	SortExpression	Implementation of the ISortExpression interface. This class contains the sort clauses used in IRetrievalQuery instances.
	SourceFieldFinder	Class which traverses a set of fields and their expressions and finds all fields which are actually mapped fields, so which have their ContainingObjectName set. These fields can then be used to be the containing field object for an expression instead of an empty expression field which doesn't have a mapping. This is necessary as llblgen pro doesn't have a 'source' definition, it determines that on the fly, which can go wrong if the projection has just expression fields and there are no relations specified.
	SqlAzureRecoveryStrategy	Specific strategy to be used with SQL Azure and also usable for local SQL Server connections.
	StaticEntityFieldsDataContainer	Container for the static data of an Entity fields object.
	StoredProcedureCall	Class which defines a stored procedure call, used in the generated code to call an Action or Retrieval stored procedure.
	StringBuilderCache	[FB] See comments at the top of the file. From CoreFX (https://github.com/dotnet/corefx/blob/bffef76f6af208e2042a2f27bc081ee908bb390b/src/Common/src/System/IO/StringBuilderCache.cs), adjusted the max size. Also added support for multiple cached instances, and it returns the instance with the minimal size matching the requested size
	StringPlaceHolder	Simple place holder class to be used with the QueryFragments class.
	SystemTypeConverterBaseT	Base class for the system type converters defined in the orm support classes.
	TableValuedFunctionCall	Definition of a TVF call to be used in the Query api. A tvf call is implemented as a derived table definition.
	TableValuedFunctionPersistenceInfo	Persistence info container for a Table valued function.
	TargetEntityFieldPersistenceInfoBucket	Helperclass for the value instances of EntityFieldPersistenceInfoList Used in conjunction with EntityFieldPersistenceInfoHashtable by DQE's in Insert/Delete/Update query building
	TraceHelper	Container class for the static traceswitch objects used by the tracing logic in the ORMSupportclasses.
	TransactionBase	Abstract transaction class which is used to control a serie of actions on multiple entities or entity collection classes. The database connection is opened in the constructor, so the transaction instance is ready to use. This class is the non-COM+ version, it will always start a new ADO.NET transaction and will not be using a COM+ transaction when callers are participating in such a transaction.
	TransactionComPlusBase	Obsolete. Abstract transaction class which is used to control a serie of actions on multiple entities or entity collection classes. The database connection is opened in the constructor so the COM+ transaction is flowing into the creation of the database connection. No ADO.NET transaction is started, everything runs in the containing COM+ transaction. This class is the COM+ version, it will never start a new ADO.NET transaction and will always be using a COM+ transaction. All actions MUST be explicitly be commited or rolled back (aborted), there is no autocomplete implemented in this class.
	TypeContainedAttribute	Attribute to use on properties which return an entity collection in the Adapter template set. This attribute will tell the property descriptor construction code to construct a list of properties of the type set as the value of the attribute.
	TypeConverterDataValueProjector	Wrapper class which utilizes a set typeconverter during projection.
	TypedListBaseT	Base class for typedlist classes in SelfServicing.
	TypedListBase2T	Base class for typedlist classes in SelfServicing.
	TypedListCore	Abstract base class for Typed Lists. This class is a thin wrapper around the DataTable to make sure the member variable obeyWeakRelations is serialized: in VB.NET it's not possible to program this construct, because in VB.NET you can't re-implement an interface.
	TypedViewBaseT	General base class for typedviews. This class is used to place internal framework oriented code inside a typedview
	UniqueListT	Provides a faster way to store individual objects both maintaining the order that they were added and providing a fast lookup. Based on code developed by ewbi at http://ewbi.blogs.com/develops/2010/10/uniquestringlis.html
	UniqueValueListT	Placeholder type for UniqueList. This type is kept as it's a public type and removing it in favor of UniqueList will break code.
	UnitOfWork	UnitOfWork class. Can collect actions to perform on the entities/entity collections specified. Will not perform these actions until Commit(transaction) is called. A UnitOfWork is meant to make development easier. It will not prohibit the developer to persist the actions also using other methods. Selfservicing Specific.
	UnitOfWork2	UnitOfWork2 class. Can collect actions to perform on the entities/entity collections specified. Will not perform these actions until Commit(transaction) is called. A UnitOfWork is meant to make development easier. It will not prohibit the developer to persist the actions also using other methods. Adapter Specific.
	UnitOfWorkCallBackElement	unit of work callback element to store in the unit of work collections for callbacks.
	UnitOfWorkCallBackElement2	unit of work callback element to store in the unit of work collections for callbacks.
	UnitOfWorkCollectionElement	unit of work element to store in the unit of work collections for insert/update/delete.
	UnitOfWorkCollectionElement2	unit of work element to store in the unit of work collections for insert/update/delete.
	UnitOfWorkDeleteEntitiesDirectlyElement	unit of work element to store in the DeleteEntitiesDirectly calls to execute
	UnitOfWorkElement	unit of work element to store in the unit of work collections for insert/update/delete.
	UnitOfWorkElement2	unit of work element to store in the unit of work collections for insert/update/delete.
	UnitOfWorkUpdateEntitiesDirectlyElement	unit of work element to store in the UpdateEntitiesDirectly calls to execute
	UnitOfWorkUpdateMultiElement	unit of work element to store in the update multi calls to execute
	ValidatorBase	Abstract class definition for a validator object, used to validate entity data. This class is the common base class for all generated entitynameValidator classes in the generated code.
	ValuePairTValue1, TValue2	Simple class to define a pair of values.
	ViewProjectionDataTEntity	Class which contains projection data for entity views, used in hierarchical projections of data. The data is applied to a view of all entities with the type specified as TEntity.
	VolatileEntityFieldsDataContainer	Class which is used to store the volatile field data of an entity fields object. Used when the entity fields object is part of an entity as that object in that state doesn't store field objects.
	WorkDataCollector	Class which collects work to be done for delete actions of an entity. It is used to collect work to delete entities which depend on entities which are marked for deletion by the scope. This way cascade deletes can be performed.
	XmlExtensionMethods	General class with extension methods for various types in the .NET library.
	XmlHelper	Generic XML helper class to work more efficient with an XmlDocument and XmlNodes. This class contains various utility methods to ease the (de)serialization process of the data to /from Xml

Structures

	Structure	Description
	FieldStateBucket	Small struct which contains the state of a field for transaction state caching.
	RuntimeLibraryVersion	Constant holder for the version of this library. Because the library is signed, it has a general version, like 1.0.2003.2, but it also has an internal version, stored in this struct, which reflects the build date. Versions are always equal for the DQE's and the ORM support classes.
	TimedLock	This class is by Ian Griffiths, see: http://www.interact-sw.co.uk/iangblog/2004/04/26/yetmoretimedlocking [FB]Comment below is by Ian as well. Class is left as-is with very minor changes in comments and code placement. Thanks to Eric Gunnerson for recommending this be a struct rather than a class - avoids a heap allocation. Thanks to Change Gillespie and Jocelyn Coulmance for pointing out the bugs that then crept in when I changed it to use struct... Thanks to John Sands for providing the necessary incentive to make me invent a way of using a struct in both release and debug builds without losing the debug leak tracking.

Interfaces

	Interface	Description
	IActionQuery	Interface for action queries. These queries do not return a resultset. Action queries execute Insert, Delete and Update statements. Generic
	IActiveContextParticipant	Small interface used for accessing the ActiveContext related properties on objects
	IAuditor	Interface for the auditor to be used with entity instances at runtime. Auditors audit at runtime various actions on entities and allow automatic persistence of audit information in audit entities when transactions are committed.
	IAuthorizer	Interface for the authorizer to be used with entity instances at runtime. Authorizers authorize at runtime field get/set actions as well as save/load/delete actions on entities.
	IByteCompressor	Interface to implement on a compressor class which can be used to compres/decompress the resulting byte array of the Fast serializer.
	IConcurrencyPredicateFactory	Interface for ConcurrencyPredicateFactory objects which can be provided by the developer to produce at runtime predicate objects which will be added to the update query or delete query. The predicate is returned by the IEntity2 method GetConcurrencyPredicate. Especially useful in recursive saves.
	IContextAwareElement	Interface which is used to set the context on an element which isn't participating in an active context.
	IDao	Interface for Data Access Objects (DAO). Every IEntity implementation has one specific Dao object SelfServicing specific.
	IDataAccessAdapter	Interface for Data Access Adapter (DAA) objects. Instances of this interface are used as 'adapters' to work with databases. Adapter specific.
	IDataAccessCore	Core interface for data-access logic which is used by all template groups' core persistence classes (DataAccessAdapterBase, DaoBase)
	IDataValueProjector	Interface for defining the IDataValueProjector type which is used for value projections when projecting an object[] content onto another data store format.
	IDbFunctionCall	Interface which defines a database function call type, used for specifying a function call in a filter, resultset or sortclause.
	IDbSpecificCreator	Interface for DatabaseSpecificCreator objects, which use the Strategy pattern to supply IPredicate implementations with a way to create parameter objects, field names, including prefix/postfix characters, and conversion routines, which suit the target database. Generic
	IDbSpecificHintCreator	Interface for creating hints based on the input specified. Hints are used to tell the RDBMS to produce different SQL. This interface is implemented on those IDatabaseSpecificGenerator implementing classes for which the RDBMS supports hints.
	IDerivedTableDefinition	Interface to define a derived table. A derived table is a select statement which is used inside a FROM clause of a query. Use derived table definitions in combination of DynamicRelation objects to build your query. Implemented in DerivedTableDefinition.
	IDynamicRelation	Interface definition for the DynamicRelation class. This interface is implemented on the DynamicRelationBase class.
	IElementCreator	Interface for creating project elements from somewhere else, like inside Linq providers.
	IElementCreator2	Interface for creating project elements from somewhere else, like inside Linq providers.
	IElementCreatorCore	Interface implemented by both IElementCreator(2) interfaces
	IEntity	Interface used for all Entity classes, it's the interface implemented by the abstract base class which is used to derive every entity class from SelfServicing specific
	IEntity2	Interface used for all Entity2 classes Adapter specific
	IEntityCollection	Interface for the EntityCollection type. The collection defines typed basic collection behavior. Selfservicing specific
	IEntityCollection2	Interface for the EntityCollection2 type. The collection defines typed basic collection behavior. Adapter specific
	IEntityCollectionCore	Interface used as the base for all entity collections. (adapter and selfservicing).
	IEntityCore	Interface used for as a base for all Entity classes
	IEntityDataProjector	Interface which defines a projector engine for projecting entity data. The engine consumes projected plain data and produces an object which from then on contains the plain data.
	IEntityFactory	Interface for EntityFactory objects used by several methods which have to create entity objects on the fly. SelfServicing specific
	IEntityFactory2	Interface for EntityFactory2 objects used by several methods which have to create entity objects on the fly. Factories have to add a valid validator object to the entities. Adapter specific
	IEntityFactoryCore	Interface to define a common interface between the factory interfaces for adapter and selfservicing.
	IEntityField	Interface for the EntityField type. An EntityField is the unit which is used to hold the value for a given property of an entity. SelfServicing specific.
	IEntityField2	Interface for the EntityField2 type. An EntityField2 is the unit which is used to hold the value for a given property of an entity. Adapter specific.
	IEntityFieldCore	Interface definition which defines the core IEntityField set. Is implemented by other interfaces like IEntityField and IEntityField2. Generic.
	IEntityFieldCoreInterpret	Interface which is used internally for getting a field's value when passing in an entity.
	IEntityFields	Interface for the EntityFields type. An EntityFields type is a collection of IEntityField objects which forms the total amount of fields for a given entity. SelfServicing specific
	IEntityFields2	Interface for the EntityFields2 type. An EntityFields2 type is a collection of IEntityField2 objects which forms the total amount of fields for a given entity. Adapter specific
	IEntityFieldsCore	Interface for the Entity Fields types. An Entity Fields type is a collection of IEntityFieldCore objects which forms the total amount of fields for a given entity.
	IEntityPropertyProjector	Interface for defining the IEntityPropertyProjector type which is used for entity property projections when projecting an entityview's content onto another data store format.
	IEntityRelation	Interface used for relations between IEntity* instances. Generic
	IEntityView	General interface to access common properties of an EntityView(Of TEntity) without knowing the type of TEntity.
	IEntityView2	General interface to access common properties of an EntityView(Of TEntity) without knowing the type of TEntity.
	IEntityViewCore	Interface implemented on the base class of Entity view classes.
	IExpression	General interface definition for the Expression class which defines field expressions which are applied to fields in a select list, in update queries or in field predicates.
	IExpressionElement	Interface definition for elements contained in an expression.
	IExpressionFieldElement	Interface definition for field elements contained in an expression
	IExpressionInterpret	Interface which is used internally on an Expression class to make the expression interpret itself on the passed in entity.
	IFastSerializationTypeSurrogate	Interface to allow helper classes to be used to serialize objects that are not directly supported by SerializationWriter/SerializationReader
	IFieldInfo	General interface for static entity field information and isn't related to persistence info.
	IFieldInfoProvider	Interface for the FieldInfoProvider class which is used to provide field info information for adapter/selfservicing fields / entityfields(2) objects.
	IFieldPersistenceInfo	Interface which holds the generic information for entity field persistence of an entity field. Instances of this interface are passed to logic with an instance of the IEntityFieldCore interface. SelfServicing implements both interfaces in one interface: IEntityField. Generic
	IGeneralDataProjector	Interface which defines a projector engine for projecting general data in object[] arrays (e.g. datareader results). The engine consumes projected plain data and produces an object which from then on contains the plain data.
	IGroupByCollection	Interface for the GroupByCollection class which is used to collect EntityField(2) instances which are used for the GROUP BY clause in a retrieval query. When a group by collection is specified in a retrieval query, all fields in the resultset have to be in this collection. Generic
	IInheritanceInfo	Interface for objects which specify inheritance information for a certain entity. Instances of this interface are produced by GetInheritanceInfo(String, Boolean)
	IInheritanceInfoProvider	Interface for inheritanceinfo provider objects and other inheritance information. InheritanceInfo objects provide inheritance information at runtime for the DQE's and helper classes. The information inside these providers has to be statically constructed and should not change at runtime to make it threadsafe. These providers supply the DQE with detailed inheritance information so queries can be formed for any entity hierarchy.
	IMemoryStreamByteCompressor	Interface to implement on specialized compressor classes to compress a passed in memory stream
	IModelInfoProvider	Interface for the ModelInfoProvider generated class which is used to provide field and inheritance info for adapter/selfservicing objects.
	IOwnedDataSerializable	Interface which allows a class to save/retrieve their internal data to/from an existing SerializationWriter/SerializationReader.
	IOwnedDataSerializableAndRecreatable	Interface which allows a class to specify that it can be recreated during deserialization using a default constructor and then calling DeserializeOwnedData()
	IParameterFieldRelation	Interface to define the relation between a parameter of a query and a field. This relation is used to find back a related EntityField when an Output Parameter is found in a query so the value of the Output Parameter can be assigned to the related EntityField. Generic
	IPersistenceInfoProvider	Interface for the PersistenceInfoProvider classes which are used to provide persistence information for adapter/selfservicing fields.
	IPredicate	Interface for a predicate. Predicates are expressions which result in true or false, and which are used in WHERE clauses. Generic
	IPredicateExpression	Interface for a PredicateExpression, which is a grouped set of Predicates. A predicate expression is usable as a WHERE clause. Generic
	IPredicateExpressionElement	Interface used for the elements which are physically stored in a PredicateExpression. Generic
	IPredicateInterpret	Interface which is used internally on a Predicate class to make the predicate interpret itself on the passed in entity.
	IPrefetchPath	Interface definition for the PrefetchPath type, which specifies a prefetch path to fetch related entities during a fetch. SelfServicing specific.
	IPrefetchPath2	Interface definition for the PrefetchPath2 type, which specifies a prefetch path to fetch related entities during a fetch. Adapter specific.
	IPrefetchPathCore	Core interface for prefetch paths
	IPrefetchPathElement	Interface definition for the PrefetchPathElement type, which instances are used in a PrefetchPath instance. Selfservicing specific
	IPrefetchPathElement2	Interface definition for the PrefetchPathElement2 type, which instances are used in a PrefetchPath2 instance. Adapter specific
	IPrefetchPathElementCore	Interface definition for the core of a PrefetchPathElement instances contained in a PrefetchPath. This interface is used as a base interface for the specialised IPrefetchPathElement (selfservicing) and IPrefetchPathElement2 (Adapter).
	IProjector	Core interface for projectors
	IPropertyDescriptorFactory	interface for the factory which creates different sets of property descriptor sets. Required for complex databinding. Selfservicing specific.
	IQuery	The interface for dynamic created queries. Generic
	IRelation	Simple interface for relation which is the base interface for IDynamicRelation and IEntityRelation
	IRelationCollection	Interface for the RelationCollection class which is used to stack relation objects between several entities to build a complete join path Generic NB: ToQueryText() has been removed, query text producing logic is moved to the DQE's, since Oracle 8i doesn't support ANSI joins.
	IRelationFactory	Relation factory interface for the Relations objects for each entity. This interface is used by InheritanceInfoProvider objects to produce relations which relate to the type/entity specified.
	IRelationPredicateBucket	Interface definition for a bucket class which contains both a predicate expression and a relation collection which are related to each other (the predicate expression works in combination with the relation collection's contents). Used in adapter's context however can also be used in other situations, for example custom templates.
	IResultsetCache	Interface for a cache which caches resultsets
	IRetrievalQuery	Interface for retrieval queries. These queries do return a resultset. Retrieval queries execute Select statements. Generic
	IScalarQueryExpression	Interface which defines a scalar query which can be used inside an Expression object. The scalar query results a single value, and because it can be used as an expression, it can be used in the select list of a dynamic list.
	ISequenceRetrievalQuery	Interface for sequence retrieval queries. Sequence retrieval queries are scalar queries (returning a value) which are used to retrieve the actual / to use sequence value in systems which do not support batched queries. Normally every DQE will batch the sequence retrieval query into the INSERT query as a batched query, however some systems do not support this and the only solution is the SequenceRetrievalQuery. Used for Access, Firebird and other systems. SequenceRetrievalQueries can be added to IActionQuery instances and will use the IActionQuery object's connection object.
	ISortClause	Interface definition for a class which forms a single sort clause, thus an order by definition defined for a single IEntityField or IEntityField - IFieldPersistenceInfo combination PersistenceInfo will return the same object when an IEntityField is added to the object. Generic
	ISortExpression	Interface for the class which contains the sort clauses used in IRetrievalQuery instances. Generic
	ITransaction	Interface for the definition of a Transaction class which is used to control a serie of actions on multiple entities or entity collection classes. SelfServicing specific
	ITransactionalElement	Interface which is necessary for the Transaction class. Every class which has to be controlled by a Transaction object has to implement this interface. Examples are: an Entity class and an Entity Collection Class. SelfServicing specific
	ITransactionController	Interface for classes which control an ado.net transaction object and which can commit/rollback this transaction
	ITypeDefaultValue	Interface for the class which supplies a default value for a specified .NET type. Necessary for NULL values read from the database. Generic
	ITypedListCore	Interface base definition for TypedList classes
	ITypedListLgp	Interface for TypedList classes. ITypedList is already defined in .NET, that's why it is suffixed with Lgp. Selfservicing specific.
	ITypedListLgp2	Interface for TypedList classes. ITypedList is already defined in .NET, that's why it is suffixed with Lgp. Adapter specific.
	ITypedView	Interface for TypedView classes. Selfservicing specific.
	ITypedView2	Interface for TypedView classes. Adapter specific.
	IUnitOfWorkCore	Interface for unit of work classes.
	IValidator	Interface for validation classes used by IEntityCore implementing classes. Generic
	IViewProjectionData	Interface for the generic ViewProjectionData class which contains projection data for entity views, used in hierarchical projections of data. The data is applied to a view of all entities with the type specified as TEntity.

Delegates

	Delegate	Description
	AggregateSetPredicateCallback	Callback for the AggregateSetPredicate, which is used to aggregate over the set of values passed in.
	DelegatePredicateCallback	Callback for the DelegatePredicate, which is used to perform the interpretation of the passed in entity.
	InterpretSetValueCallback	Callback for the AggregateSetPredicate, which is used to interpret a passed in entity and return the value to add to the set of values to aggregate in the AggregateSetPredicate.
	ProjectionRowProjectorFunc	Delegate definition which is used by linq. The delegate is used to produce a single instance from the projection row specified.
	ProjectionValueProducerFunc	Delegate definition which is used by IProjector and projection engines. The delegate is used to produce a single value out of one or more values in the object array passed into the projection engine.
	Setter	Delegate definition for a dynamically compiled method for setting the provider specific type.

Enumerations

	Enumeration	Description
	AggregateFunction	Enum definition for the various aggregate functions which can be applied to fields in a retrieval query. Useful in typed lists. Use these in combination with a groupbycollection. Not all functions are legal on all fields. Some functions will produce errors when used with fields of a given type, like a Sum function with a character field. This is the responsibility of the developer. Aggregate functions are never applied to *lob fields.
	AggregateSetFunction	Enum definition for the various aggregate functions supported by the AggregateSetPredicate for in-memory filters.
	BuildInValidationBypass	Enum which defines the strategy for the build-in validation logic for new values for entity fields. Build-in validation logic checks if the value to set matches the characteristics of the database field the entity field is mapped on, so when the entity is persisted there won't be any overflow exception.
	CascadeActionType	Enum which defines the cascade action type to use with data scopes
	CatalogNameUsage	SqlServer specific enum definition for Adapter template set. Specifies for the active DataAccessAdapter object what to do with the catalog name in persistence information set into fields.
	ComparisonOperator	Enum definition for the operator used in the FieldCompareValue Predicate.
	ConcurrencyPredicateType	Enum to specify to the IConcurrencyPredicateFactory what kind of predicate to produce
	DataScopeRefetchStrategyType	Enum which defines the refetch strategy for saved entities a datascope instance has to take after commit.
	DataSourceCacheLocation	Enum to define the data cache to use for the LLBLGen Pro DataSource controls in an ASP.NET application
	DataSourceDataContainerType	Enum which specifies the type of object which contains the data in an LLBLGenProDataSource(2) control in an ASP.NET application
	DataSourceSortingMode	Enum definition for LLBLGenProDataSource(2) controls to signal what sorting mode they have to use for selects.
	DependencyInjectionContextType	Enum defined to specify in which context the instance to inject lives in.
	DependencyInjectionTargetKind	Enum defined for dependency injection information, to specify the targetkind
	DerivedTableFieldPresence	Enum which is used when derived table targeting fields are checked if they're present in the derived table targeted.
	DistinctFilteringPreferenceType	Enum which defines the preference type for distinct filtering for select queries.
	EntityState	Enum definition for the state an Entity can be in.
	ExceptionInfoElement	Enum which is used to identify the various info elements in a db specific exception info hashtable/dictionary.
	ExOp	Enum definition for the ExpressionOperators (ExOp). Name is shortened to limit typing.
	ExpressionElementType	Enum for defining the type of the expression element in an expression object
	FetchNewAuthorizationFailureResultHint	Enum to specify the hint what to do when authorization fails on a newly fetched entity into a new object.
	FirebirdCompatibilityLevel	Enum for compatibility level in the Firebird DQE
	FromClauseElementDirectiveType	Type to define the from clause element directive kind
	FullTextSearchOperator	Operator to use with FieldFullTextSearchPredicate. SqlServer specific.
	InheritanceHierarchyType	Enum definition for defining the hierarchy type of the inheritance tree
	JoinHint	Enum definition for the hint specified in the Add method of RelationCollection.
	MemberOperator	Enum which specifies when the MemberPredicate should be considered 'true'
	NavigatorAspectType	Enum which defines the navigator aspect type to specify which aspects to enable on default views of contained collections of entities contained in data scopes
	OracleCompatibilityLevel	Enum for compatibility level in the Oracle DQEs (ODP.NET and MS Oracle)
	PostCollectionChangeAction	Enum to specify what to do when the data in the related collection of an entity view changes. A change in data can be: entity added or changed. If an entity is removed from the underlying collection, the entity is simply removed from the entity view, as the view doesn't contain any data by itself.
	PredicateExpressionElementType	Enum definition for the type of a PredicateExpressionElement
	PredicateExpressionOperator	Enum definition for the Operators used in PredicateExpressions
	PredicateType	Enum definition for the type of a predicate instance. This enum is stored in Predicate as an int and is used in DataAccessAdapterBase derived classes.
	RdbmsHint	Obsolete. Enum definition for RDBMS hints, like table lock hints and other hints.
	RecoveryStrategyDelayType	Specifies the delay type to use with a transient error recovery strategy.
	RelationType	Enum definition for the type of relation an EntityRelation object represents. There is no definition for m:n relation because EntityRelation can't represent a m:n relation
	ScaleOverflowCorrectionAction	Enum which defines the action to take when a scale overflow is detected in the build-in validation for precision/scale values. This validation takes place when an entity field is set to a value and the validation isn't bypassed.
	SchemaNameUsage	Oracle specific enum definition for Adapter template set. Specifies for the active DataAccessAdapter object what to do with the schema name in persistence information set into fields.
	SerializationOptimization	Enum which defines the serialization settings available.
	SetOperator	Enum definition for the operators used with the FieldCompareSetPredicate class.
	SingleStatementQueryAction	Enum which is used in Auditors, to signal that this single statement query action is about to be executed and that the framework would like to know if the auditor expects to have entities to save after the statement so a transaction should be started.
	SortOperator	Enum definition for the sort operator, which can be specified with IEntityField instances to create order by clauses.
	SqlServerCompatibilityLevel	Enum for compatibility level in the SqlServer DQE
	TemporalTablePredicateType	The type of predicate to create by the dbspecific creator for a FromClauseElement directive
	UnitOfWorkBlockType	Enum which is used to specify block types, to identity groups of actions under the same type, e.g. inserts or updates.
	UnitOfWorkCallBackScheduleSlot	Enum definition to tell the UnitOfWork that the passed in callback should be executed in the slot specified. Entities are executed in the order: Insert, Update, Delete.
	XmlFormatAspect	Enum definition for the flags which can be passed to overloads of WriteXml(). These flags control the way the format of the output.