Click or drag to resize

SD.LLBLGen.Pro.ORMSupportClasses Namespace

 
Classes
  ClassDescription
Public classActionQuery
Implementation of the ActionQuery class.
Public classActionQueueElementTEntity
Internal class to store entities in an action queue (insertqueue or update queue)
Public classAggregateSetPredicate
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.
Public classAliasScope
Class which is used as an alias scope in a DbSpecificCreator.
Public classArgumentVerifier
Class which contains argument verification logic and which can throw exceptions if necessary. This code makes it easier to verify input arguments.
Public classAuditorBase
Abstract base class for auditors in the LLBLGen Pro system. Use this class to easily create auditors to perform auditing for you.
Public classAuthorizerBase
Abstract base class for authorizers in the LLBLGen Pro system. Use this class to easily create authorizers.
Public classBatchActionQuery
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.
Public classBooleanCharYNConverter
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'
Public classBooleanNumericConverter
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.
Public classByteDecimalConverter
Definition of the ByteDecimalConverter. This converter uses 'Byte' as its core type and converts any decimal value to and from Byte
Public classCacheableChecker
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).
Public classCacheController
The controller which is the central place where caches live. Use this class to register a cache for a given connection string.
Public classCachedResultset
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.
Public classCachedResultsetDataReader
DataReader which is used to traverse a cached resultset.
Public classCacheItemT
Wrapper object for objects which are placed in the resultsetcache.
Public classCacheKey
Key object which is used to uniquely identify a query with its arguments.
Public classCancelableCollectionChangedEventArgs
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.
Public classCancelableDataSourceActionEventArgs
Event args class which is the cancelable variant of the DataSourceActionEventArgs event args class
Public classCatalogNameOverwriteHashtable
Specialized Hashtable which contains name-value pairs for name overwriting for catalog names names in adapter on some databases (db2, sqlserver)
Public classCharStringConverter
Definition of the CharStringConverter. This converter uses 'Char' as its core type and converts the char to and from a string.
Public classCollectionChangedEventArgs
EventArgs class for events raised by the entity collection classes for various actions.
Public classCollectionCoreT
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.
Public classComPlusAdapterContextBase 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.
Public classConfigFileHelper
Static class which contains logic used by the generated code to read data from config files.
Public classContext
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.
Public classCorrelationPredicateExpression
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.
Public classCustomXmlSerializationAttribute
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.
Public classDaoBase
Base class for DAO classes which are generated.
Public classDataAccessAdapterBase
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.
Public classDataAccessAdapterCore
Base class for DAA classes which are generated.
Public classDataProjectorToCustomClassT
Projector to project plain projection data onto a custom class which can be an anonymous type.
Public classDataProjectorToDataTable
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.
Public classDataProjectorToEntityCollectionBase
Abstract base class for the two collection projectors
Public classDataProjectorToIEntityCollection
Projector engine which projects plain projection result data onto new entities which are added to a single entitycollection.
Public classDataProjectorToIEntityCollection2
Projector engine which projects plain projection result data onto new entities which are added to a single entitycollection.
Public classDataProjectorToObjectRowList
Simple class which doesn't do any projection work, it simply adds all received rows to the results list.
Public classDataProjectorToValueListT
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.
Public classDataReaderProjectionRow
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.
Public classDataScope
Abstract base class to create a custom data scope class.
Public classDataSourceActionEventArgs
Event args class which is used with LLBLGenProDataSource(2) action events. This is the non-cancelable variant.
Public classDataSourceDesigner2ConfigurationForm
Special designer form which is popped up when the user clicks 'Configure data source' on an LLBLGenProDataSource2 component on an ASP.NET webform.
Public classDataSourceDesignerConfigurationForm
Special designer form which is popped up when the user clicks 'Configure data source' on an LLBLGenProDataSource component on an ASP.NET webform.
Public classDataTableFiller
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.
Public classDataValueProjector
General class which defines the projection result and destination of a value in an object[] array.
Public classDateTimeDateTimeUTCConverter
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.
Public classDbFunctionCall
Class which implements a function call to a database function and which is used on an EntityField(2) in a query.
Public classDbProviderFactoryInfo
Class which contains the DbProviderfactory information for a specific DQE.
Public classDbSpecificCreatorBase
Base class for every DbSpecificCreator implementation
Public classDelegatePredicate
Predicate class to filter in-memory entity collections based on a specified callback function.
Public classDelegatePredicateTEntity
Generic version of the DelegatePredicate predicate, to use with Predicate(Of T) predicates, which can be constructed with Lambda expressions.
Public classDependencyInjectionConfigInformation
Class which is used for storing the information read from a DependencyInjectionInformation section in the config file. Instances are created by the DependencyInjectionSectionHandler
Public classDependencyInjectionDiscoveryInformation
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.
Public classDependencyInjectionInfoAttribute
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.
Public classDependencyInjectionInfoProviderSingleton
Singleton class which contains the single instance of the DependencyInjectionProvider
Public classDependencyInjectionScope
Abstract class which defines a Dependency Injection scope in which dependency injection takes place with the information provided with this scope.
Public classDependencyInjectionSectionHandler
Handles the DependencyInjectionInformation section in the config file and creates an instance of DependencyInjectionConfigInformation with information stored in the section.
Public classDerivedTableDefinition
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.
Public classDerivedTableFinder
Class which finds all derived table definitions in the object to traverse, e.g. a relation collection.
Public classDerivedTableTargetingFieldFinder
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.
Public classDesignTimeTracker
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.
Public classDoubleDecimalConverter
Definition of the DoubleDecimalConverter. This converter uses 'Double' as its core type and converts any decimal value to and from Double
Public classDQEConfigurationBase
Base class for DQE Configuration classes which are used with the RuntimeConfiguration system
Public classDynamicQueryEngineBase
Central base class for all DynamicQueryEngine classes. Shared logic is placed in this class, which can be overriden in the DynamicQueryEngine classes per database.
Public classDynamicRelationBase
Abstract base class for the DynamicRelation class which is generated. Dynamic relations have always their left operand defined as the 'pk' side if applicable.
Public classElementCreatorBase
Base class for elementcreator/elementcreator2 which are in the generated code.
Public classEntityBase
General Entity Base class, which is used to inherit the Entity classes from.
Public classEntityBase2
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.
Public classEntityCollectionBaseTEntity
Implementation of the entity collection base class.
Public classEntityCollectionBase2TEntity
Implementation of the entity collection base class.
Public classEntityCollectionNonGeneric
EntityCollection implementation which is used for backwards compatibility and for design time databinding. This EntityCollectionNonGeneric is an EntityCollectionBase2(Of EntityBase2)
Public classEntityCoreTFields
Core class for the entity classes in both Adapter and SelfServicing.
Protected classEntityCoreTFieldsEntityStaticMetaDataBase
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.
Public classEntityFactoryCache2
Cache class which ensures that only one instance of an entity factory is created/stored during serialization
Public classEntityFactoryCore
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.
Public classEntityFactoryCore2
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.
Public classEntityField
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.
Public classEntityField2
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.
Public classEntityFieldCore
Generic base class for entity fields.
Public classEntityFieldPersistenceInfoList
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.
Public classEntityFields
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
Public classEntityFields2
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
Public classEntityFieldsCoreTField
General base class for Entity Fields classes.
Public classEntityProperty
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.
Public classEntityPropertyDescriptor
EntityPropertyDescriptor implementation for adding property descriptors for entity fields in a complex databinding scenario.
Public classEntityPropertyProjector
General class which defines the projection result and destination of a property of an entity.
Public classEntityRelation
Generic implementation of the IEntityRelation interface, which is used for relations between IEntity* instances.
Public classEntitySyncInfoTEntity
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.
Public classEntityViewTEntity
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.
Public classEntityView2TEntity
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.
Public classEntityViewBaseTEntity
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.
Public classExceptionInfoRetriever
Class which retrieves information from a passed in exception which is specific to a DB type, and returns it to the caller.
Public classExcludeFieldsList
Helper class which is a derived class from ExcludeIncludeFieldsList containing just fields to exclude
Public classExcludeIncludeFieldsList
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.
Public classExpression
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.
Public classExpressionElementT
ExpressionElement class, definition for elements contained in an expression.
Public classExpressionFieldElement
ExpressionFieldElement class, definition for field elements contained in an expression
Public classExtensionMethods
Class with various extension methods for various classes.
Public classFastDeserializer
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'
Public classFastDictionaryTKey, 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
Public classFastSerializer
The serializer class which takes care of the fast serialization when SerializationHelper.Optimization is set to 'Fast'
Public classFastSerializerSurrogate
Class to act as a surrogate for the fast serializer.
Public classFastSerializerSurrogateSelector
Class to select the proper surrogate for the fast serializer
Public classFieldBetweenPredicate
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.
Public classFieldCompareExpressionPredicate
Implementation of a Field compare-operator Expression expression, using the following format: IEntityField(Core) ComparisonOperator Expression (f.e. Foo = (Bar * 2))
Public classFieldCompareNullPredicate
Implementation of a Field Compare NULL expression using the following format: IEntityField(Core) IS NULL (f.e. Foo IS NULL).
Public classFieldCompareRangePredicate
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.
Public classFieldCompareSetPredicate
Implementation of a Field compare-operator Set expression, using the following format: IEntityField(Core) ComparisonOperator (Subquery)
Public classFieldCompareValuePredicate
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.
Public classFieldFullTextSearchPredicate
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.
Public classFieldInfo
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.
Public classFieldLikePredicate
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.
Public classFieldPersistenceInfo
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
Public classFieldUtilities
Various field related routines
Public classFromClauseElementDirective
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.
Public classFunctionMapping
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
Public classFunctionMappingStore
Class which is used to store function mapping related data.
Public classGeneralUtils
General container class for static utility methods which have no better grouping class.
Public classGenericExpressionVisitor
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.
Public classGroupByCollection
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
Public classGuidByteArrayConverter
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.
Public classGuidStringConverter
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.
Public classIncludeFieldsList
Helper class which is a derived class from ExcludeIncludeFieldsList containing just fields to include
Public classIncludeInCompactXmlAttribute
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.
Public classInheritanceInfo
Simple class which contains the inheritance information of an entity, and which is produced by an inheritanceinfoprovider.
Public classInt16DecimalConverter
Definition of the Int16DecimalConverter. This converter uses 'Int16' as its core type and converts any decimal value to and from Int16
Public classInt32DecimalConverter
Definition of the Int32DecimalConverter. This converter uses 'Int32' as its core type and converts any decimal value to and from Int32
Public classInt64DecimalConverter
Definition of the Int64DecimalConverter. This converter uses 'Int64' as its core type and converts any decimal value to and from Int64
Public classLLBLGenProDataSource
General data source control which can be used in ASP.NET projects to perform design time databinding and runtime databinding.
Public classLLBLGenProDataSource2
General data source control which can be used in ASP.NET projects to perform design time databinding and runtime databinding.
Public classLLBLGenProDataSourceBase
General datasource control base class for the selfservicing/adapter datasource controls for ASP.NET
Public classLLBLGenProDataSourceDesigner
General designer class for the LLBLGen Pro DataSource control.
Public classLLBLGenProDataSourceDesigner2
General designer class for the LLBLGen Pro DataSource control.
Public classLLBLGenProDataSourceView
General implementation of the DataSourceView class to be used with LLBLGenProDataSource control in ASP.NET applications.
Public classLLBLGenProDataSourceView2
General implementation of the DataSourceView class to be used with LLBLGenProDataSource control in ASP.NET applications.
Public classLLBLGenProDataSourceViewBase
General base class for DatSourceView objects for selfservicing and adapter.
Public classLLBLGenProDesignerDataSourceView
General datasourceview for design time databinding
Public classLLBLGenProDesignerDataSourceView2
General datasourceview for design time databinding
Public classMemberPredicate
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).
Public classMergeableDictionaryTKey, TValue
Specialized Hashtable which allows merging with a passed-in hashtable.
Public classModelInfoProviderBase
Abstract base class for the InfoProvider generated class which contains both the field info provider and the inheritance info provider.
Public classMultiValueDictionaryTKey, 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.
Public classMultiValueHashtableTKey, 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.
Public classNodeEntityReference
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.
Public classNumericValueOperatorExecutor
Utility class which operates on numeric values and which applies arithmetic operations.
Public classObjectGraphUtils
Some utility functions to process graphs
Public classORMBadSequenceException
Exception which is thrown when a bad sequence value is detected after an insert.
Public classORMConcurrencyException
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.
Public classORMConfigurationException
Exception class for configuration related errors.
Public classORMEntityIsDeletedException
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.
Public classORMEntityOutOfSyncException
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.
Public classORMEntityValidationException
General exception class which is thrown by a validation error.
Public classORMException
Abstract base class for all ORM exceptions.
Public classORMFieldIsNullException
General exception class which is thrown when a user tries to get a value from a field which is null.
Public classORMFieldIsReadonlyException
General exception class which is thrown when a user sets a field which is readonly.
Public classORMGeneralOperationException
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.
Public classORMInheritanceInfoException
General exception which is thrown when an error is determined in the inheritance info during query execution.
Public classORMInterpretationException
General exception which is thrown when an interpretation error occurs during predicate / sortclause interpretation for filtering or sorting in-memory in an EntityView(2).
Public classORMInvalidFieldReadException
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).
Public classORMLockTimeoutException
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.
Public classORMQueryConstructionException
General exception which is thrown when an error occurs during the construction of the query to execute.
Public classORMQueryExecutionException
General exception class which is thrown when an exception was caught during a query execution. Contains the original exception as inner exception.
Public classORMRelationException
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)
Public classORMSecurityException
Exception class which is usable for security exceptions thrown by authorizers.
Public classORMSerializationOptimizationException
Exception class which is thrown when a value being optimized does not meet the required criteria for optimization.
Public classORMTransientRecoveryFailedException
Exception class which is thrown when the maximum number of retries has been attempted or when the maximum delay has been reached.
Public classORMValueTypeMismatchException
General exception class which is thrown when a user sets a field to a value which doesn't match the type of the field.
Public classParameterFieldRelation
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
Public classParameterParameterRelation
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.
Public classParameterValue
Class which is used to specify parameter specific aspects for a value specified in a plain SQL query call.
Public classPerformGetDbCountEventArgs
Event arguments class which is passed as argument in the PerformDbCount event on an LLBLGenProDataSource control.
Public classPerformGetDbCountEventArgs2
Event arguments class which is passed as argument in the PerformDbCount event on an LLBLGenProDataSource2 control.
Public classPerformSelectEventArgs
Event arguments class which is passed as argument in the PerformSelect event on an LLBLGenProDataSource2 control
Public classPerformSelectEventArgs2
Event arguments class which is passed as argument in the PerformSelect event on an LLBLGenProDataSource2 control
Public classPerformWorkEventArgs
Event arguments class which is passed as argument in the PerformWork event on an LLBLGenProDataSource control.
Public classPerformWorkEventArgs2
Event arguments class which is passed as argument in the PerformWork event on an LLBLGenProDataSource control.
Public classPersistenceCore
Class which is used to store core methods used in various parts of the persistence pipeline, and which are shared among selfservicing and adapter.
Public classPersistenceInfoProviderBase
Abstract class for the persistence info provider class which is used to provide FieldPersistenceInfo objects for fields/entities.
Public classPlainSQLFetchAspects
Simple class which is used to specify aspects about a fetch query specified as plain SQL.
Public classPredicate
Abstract base implementation of the IPredicate interface.
Public classPredicateExpression
Implementation of the IPredicateExpression interface.
Public classPredicateExpressionElement
Implementation of the IPredicateExpressionElement interface
Public classPredicateWrapper
Small class which wraps a predicate so it can be placed in an IExpression element, like a scalar query expression or dbfunction call.
Public classPrefetchPath
PrefetchPath class, which specifies a prefetch path to fetch related entities during a fetch. SelfServicing specific.
Public classPrefetchPath2
PrefetchPath class, which specifies a prefetch path to fetch related entities during a fetch. Adapter specific.
Public classPrefetchPathElement
PrefetchPathElement class.
Public classPrefetchPathElement2
PrefetchPathElement2 class.
Public classProjectionLiteral
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.
Public classProjectionRow
Simple class which wraps an object array and allows type converson and name-based indexing. Used in projections of DynamicQuery resultsets.
Public classQuery
Abstract query class for the various query objects in the framework.
Public classQueryApiObjectTraverser
Class which is used to traverse over an llblgen pro object, like a derivedtable, predicate expression etc. and access all inner objects, including fields.
Public classQueryFragments
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.
Public classQueryParameters
Bucket class which contains all the parameters for formulating a set fetch query.
Public classRecoveryDelay
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.
Public classRecoveryStrategyBase
Base class for transient error recovery stategies. Not thread safe.
Public classReferencedEntityMap
Class which is used to store maps to referenced entities to be able to serialize an entity which is referenced multiple times only once.
Public classRelationCollection
Class which is used to stack relation objects between several entities to build a complete join path
Public classRelationFactory
Abstract base class for all generated relation classes.
Public classRelationPredicateBucket
IRelationPredicateBucket implementation which can be used as a single unit to pass to a data-access adapter for filtering over multi-entities.
Public classResultsetCache
Default implementation of the resultsetcache interface.
Public classRetrievalQuery
Implementation of the RetrievalQuery class.
Public classRuntimeConfiguration
Central configuration class to allow configuration of various runtime elements at the code level without the requirement of a config file.
Public classRuntimeConfigurationEntityConfigMethods
Class for the set methods to configure Entity(Core) related settings
Public classRuntimeConfigurationPrefetchPathConfigMethods
Class for the set methods to configure PrefetchPath/PrefetchPath2 instances in the runtime.
Public classRuntimeConfigurationTracingConfigMethods
Class for the set methods to configure TraceSwitch instances in the runtime.
Public classRuntimeConfigurationXmlConfigMethods
Class for the set methods to configure Xml serialization specific settings
Public classScalarQueryExpression
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.
Public classSchemaNameOverwriteHashtable
Specialized Hashtable which contains name-value pairs for name overwriting for schema names names in adapter on some databases (db2, sqlserver and oracle)
Public classSequenceRetrievalQuery
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.
Public classSerializationHelper
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
Public classSerializationReader
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.
Public classSerializationUtils
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.
Public classCode exampleSerializationWriter
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
writer.AppendTokenTables();
MemoryStream stream = (MemoryStream) writer.BaseStream;
serializedData = MyCompressor.Compress(stream.GetBuffer(), (int)stream.Length);
Public classSimpleRetryRecoveryStrategy
Default recovery stategy which simply re-tries a failed execution of work, no matter what the error is.
Public classSingleDecimalConverter
Definition of the SingleDecimalConverter. This converter uses 'Single' as its core type and converts any decimal value to and from Single
Public classSortClause
Class which implements ISortClause, a class which forms a single sort clause, thus an order by definition defined for a single IEntityField.
Public classSortExpression
Implementation of the ISortExpression interface. This class contains the sort clauses used in IRetrievalQuery instances.
Public classSourceFieldFinder
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.
Public classSqlAzureRecoveryStrategy
Specific strategy to be used with SQL Azure and also usable for local SQL Server connections.
Public classStaticEntityFieldsDataContainer
Container for the static data of an Entity fields object.
Public classStoredProcedureCall
Class which defines a stored procedure call, used in the generated code to call an Action or Retrieval stored procedure.
Public classStringBuilderCache
[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
Public classStringPlaceHolder
Simple place holder class to be used with the QueryFragments class.
Public classSystemTypeConverterBaseT
Base class for the system type converters defined in the orm support classes.
Public classTableValuedFunctionCall
Definition of a TVF call to be used in the Query api. A tvf call is implemented as a derived table definition.
Public classTableValuedFunctionPersistenceInfo
Persistence info container for a Table valued function.
Public classTargetEntityFieldPersistenceInfoBucket
Helperclass for the value instances of EntityFieldPersistenceInfoList Used in conjunction with EntityFieldPersistenceInfoHashtable by DQE's in Insert/Delete/Update query building
Public classTraceHelper
Container class for the static traceswitch objects used by the tracing logic in the ORMSupportclasses.
Public classTransactionBase
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.
Public classTransactionComPlusBase 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.
Public classTypeContainedAttribute
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.
Public classTypeConverterDataValueProjector
Wrapper class which utilizes a set typeconverter during projection.
Public classTypedListBaseT
Base class for typedlist classes in SelfServicing.
Public classTypedListBase2T
Base class for typedlist classes in SelfServicing.
Public classTypedListCore
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.
Public classTypedViewBaseT
General base class for typedviews. This class is used to place internal framework oriented code inside a typedview
Public classUniqueListT
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
Public classUniqueValueListT
Placeholder type for UniqueList. This type is kept as it's a public type and removing it in favor of UniqueList will break code.
Public classUnitOfWork
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.
Public classUnitOfWork2
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.
Public classUnitOfWorkCallBackElement
unit of work callback element to store in the unit of work collections for callbacks.
Public classUnitOfWorkCallBackElement2
unit of work callback element to store in the unit of work collections for callbacks.
Public classUnitOfWorkCollectionElement
unit of work element to store in the unit of work collections for insert/update/delete.
Public classUnitOfWorkCollectionElement2
unit of work element to store in the unit of work collections for insert/update/delete.
Public classUnitOfWorkDeleteEntitiesDirectlyElement
unit of work element to store in the DeleteEntitiesDirectly calls to execute
Public classUnitOfWorkElement
unit of work element to store in the unit of work collections for insert/update/delete.
Public classUnitOfWorkElement2
unit of work element to store in the unit of work collections for insert/update/delete.
Public classUnitOfWorkUpdateEntitiesDirectlyElement
unit of work element to store in the UpdateEntitiesDirectly calls to execute
Public classUnitOfWorkUpdateMultiElement
unit of work element to store in the update multi calls to execute
Public classValidatorBase
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.
Public classValuePairTValue1, TValue2
Simple class to define a pair of values.
Public classViewProjectionDataTEntity
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.
Public classVolatileEntityFieldsDataContainer
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.
Public classWorkDataCollector
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.
Public classXmlExtensionMethods
General class with extension methods for various types in the .NET library.
Public classXmlHelper
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
  StructureDescription
Public structureFieldStateBucket
Small struct which contains the state of a field for transaction state caching.
Public structureRuntimeLibraryVersion
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.
Public structureTimedLock
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
  InterfaceDescription
Public interfaceIActionQuery
Interface for action queries. These queries do not return a resultset. Action queries execute Insert, Delete and Update statements. Generic
Public interfaceIActiveContextParticipant
Small interface used for accessing the ActiveContext related properties on objects
Public interfaceIAuditor
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.
Public interfaceIAuthorizer
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.
Public interfaceIByteCompressor
Interface to implement on a compressor class which can be used to compres/decompress the resulting byte array of the Fast serializer.
Public interfaceIConcurrencyPredicateFactory
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.
Public interfaceIContextAwareElement
Interface which is used to set the context on an element which isn't participating in an active context.
Public interfaceIDao
Interface for Data Access Objects (DAO). Every IEntity implementation has one specific Dao object SelfServicing specific.
Public interfaceIDataAccessAdapter
Interface for Data Access Adapter (DAA) objects. Instances of this interface are used as 'adapters' to work with databases. Adapter specific.
Public interfaceIDataAccessCore
Core interface for data-access logic which is used by all template groups' core persistence classes (DataAccessAdapterBase, DaoBase)
Public interfaceIDataValueProjector
Interface for defining the IDataValueProjector type which is used for value projections when projecting an object[] content onto another data store format.
Public interfaceIDbFunctionCall
Interface which defines a database function call type, used for specifying a function call in a filter, resultset or sortclause.
Public interfaceIDbSpecificCreator
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
Public interfaceIDbSpecificHintCreator
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.
Public interfaceIDerivedTableDefinition
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.
Public interfaceIDynamicRelation
Interface definition for the DynamicRelation class. This interface is implemented on the DynamicRelationBase class.
Public interfaceIElementCreator
Interface for creating project elements from somewhere else, like inside Linq providers.
Public interfaceIElementCreator2
Interface for creating project elements from somewhere else, like inside Linq providers.
Public interfaceIElementCreatorCore
Interface implemented by both IElementCreator(2) interfaces
Public interfaceIEntity
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
Public interfaceIEntity2
Interface used for all Entity2 classes Adapter specific
Public interfaceIEntityCollection
Interface for the EntityCollection type. The collection defines typed basic collection behavior. Selfservicing specific
Public interfaceIEntityCollection2
Interface for the EntityCollection2 type. The collection defines typed basic collection behavior. Adapter specific
Public interfaceIEntityCollectionCore
Interface used as the base for all entity collections. (adapter and selfservicing).
Public interfaceIEntityCore
Interface used for as a base for all Entity classes
Public interfaceIEntityDataProjector
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.
Public interfaceIEntityFactory
Interface for EntityFactory objects used by several methods which have to create entity objects on the fly. SelfServicing specific
Public interfaceIEntityFactory2
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
Public interfaceIEntityFactoryCore
Interface to define a common interface between the factory interfaces for adapter and selfservicing.
Public interfaceIEntityField
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.
Public interfaceIEntityField2
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.
Public interfaceIEntityFieldCore
Interface definition which defines the core IEntityField set. Is implemented by other interfaces like IEntityField and IEntityField2. Generic.
Public interfaceIEntityFieldCoreInterpret
Interface which is used internally for getting a field's value when passing in an entity.
Public interfaceIEntityFields
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
Public interfaceIEntityFields2
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
Public interfaceIEntityFieldsCore
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.
Public interfaceIEntityPropertyProjector
Interface for defining the IEntityPropertyProjector type which is used for entity property projections when projecting an entityview's content onto another data store format.
Public interfaceIEntityRelation
Interface used for relations between IEntity* instances. Generic
Public interfaceIEntityView
General interface to access common properties of an EntityView(Of TEntity) without knowing the type of TEntity.
Public interfaceIEntityView2
General interface to access common properties of an EntityView(Of TEntity) without knowing the type of TEntity.
Public interfaceIEntityViewCore
Interface implemented on the base class of Entity view classes.
Public interfaceIExpression
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.
Public interfaceIExpressionElement
Interface definition for elements contained in an expression.
Public interfaceIExpressionFieldElement
Interface definition for field elements contained in an expression
Public interfaceIExpressionInterpret
Interface which is used internally on an Expression class to make the expression interpret itself on the passed in entity.
Public interfaceIFastSerializationTypeSurrogate
Interface to allow helper classes to be used to serialize objects that are not directly supported by SerializationWriter/SerializationReader
Public interfaceIFieldInfo
General interface for static entity field information and isn't related to persistence info.
Public interfaceIFieldInfoProvider
Interface for the FieldInfoProvider class which is used to provide field info information for adapter/selfservicing fields / entityfields(2) objects.
Public interfaceIFieldPersistenceInfo
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
Public interfaceIGeneralDataProjector
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.
Public interfaceIGroupByCollection
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
Public interfaceIInheritanceInfo
Interface for objects which specify inheritance information for a certain entity. Instances of this interface are produced by GetInheritanceInfo(String, Boolean)
Public interfaceIInheritanceInfoProvider
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.
Public interfaceIMemoryStreamByteCompressor
Interface to implement on specialized compressor classes to compress a passed in memory stream
Public interfaceIModelInfoProvider
Interface for the ModelInfoProvider generated class which is used to provide field and inheritance info for adapter/selfservicing objects.
Public interfaceIOwnedDataSerializable
Interface which allows a class to save/retrieve their internal data to/from an existing SerializationWriter/SerializationReader.
Public interfaceIOwnedDataSerializableAndRecreatable
Interface which allows a class to specify that it can be recreated during deserialization using a default constructor and then calling DeserializeOwnedData()
Public interfaceIParameterFieldRelation
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
Public interfaceIPersistenceInfoProvider
Interface for the PersistenceInfoProvider classes which are used to provide persistence information for adapter/selfservicing fields.
Public interfaceIPredicate
Interface for a predicate. Predicates are expressions which result in true or false, and which are used in WHERE clauses. Generic
Public interfaceIPredicateExpression
Interface for a PredicateExpression, which is a grouped set of Predicates. A predicate expression is usable as a WHERE clause. Generic
Public interfaceIPredicateExpressionElement
Interface used for the elements which are physically stored in a PredicateExpression. Generic
Public interfaceIPredicateInterpret
Interface which is used internally on a Predicate class to make the predicate interpret itself on the passed in entity.
Public interfaceIPrefetchPath
Interface definition for the PrefetchPath type, which specifies a prefetch path to fetch related entities during a fetch. SelfServicing specific.
Public interfaceIPrefetchPath2
Interface definition for the PrefetchPath2 type, which specifies a prefetch path to fetch related entities during a fetch. Adapter specific.
Public interfaceIPrefetchPathCore
Core interface for prefetch paths
Public interfaceIPrefetchPathElement
Interface definition for the PrefetchPathElement type, which instances are used in a PrefetchPath instance. Selfservicing specific
Public interfaceIPrefetchPathElement2
Interface definition for the PrefetchPathElement2 type, which instances are used in a PrefetchPath2 instance. Adapter specific
Public interfaceIPrefetchPathElementCore
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).
Public interfaceIProjector
Core interface for projectors
Public interfaceIPropertyDescriptorFactory
interface for the factory which creates different sets of property descriptor sets. Required for complex databinding. Selfservicing specific.
Public interfaceIQuery
The interface for dynamic created queries. Generic
Public interfaceIRelation
Simple interface for relation which is the base interface for IDynamicRelation and IEntityRelation
Public interfaceIRelationCollection
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.
Public interfaceIRelationFactory
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.
Public interfaceIRelationPredicateBucket
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.
Public interfaceIResultsetCache
Interface for a cache which caches resultsets
Public interfaceIRetrievalQuery
Interface for retrieval queries. These queries do return a resultset. Retrieval queries execute Select statements. Generic
Public interfaceIScalarQueryExpression
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.
Public interfaceISequenceRetrievalQuery
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.
Public interfaceISortClause
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
Public interfaceISortExpression
Interface for the class which contains the sort clauses used in IRetrievalQuery instances. Generic
Public interfaceITransaction
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
Public interfaceITransactionalElement
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
Public interfaceITransactionController
Interface for classes which control an ado.net transaction object and which can commit/rollback this transaction
Public interfaceITypeDefaultValue
Interface for the class which supplies a default value for a specified .NET type. Necessary for NULL values read from the database. Generic
Public interfaceITypedListCore
Interface base definition for TypedList classes
Public interfaceITypedListLgp
Interface for TypedList classes. ITypedList is already defined in .NET, that's why it is suffixed with Lgp. Selfservicing specific.
Public interfaceITypedListLgp2
Interface for TypedList classes. ITypedList is already defined in .NET, that's why it is suffixed with Lgp. Adapter specific.
Public interfaceITypedView
Interface for TypedView classes. Selfservicing specific.
Public interfaceITypedView2
Interface for TypedView classes. Adapter specific.
Public interfaceIUnitOfWorkCore
Interface for unit of work classes.
Public interfaceIValidator
Interface for validation classes used by IEntityCore implementing classes. Generic
Public interfaceIViewProjectionData
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
  DelegateDescription
Public delegateAggregateSetPredicateCallback
Callback for the AggregateSetPredicate, which is used to aggregate over the set of values passed in.
Public delegateDelegatePredicateCallback
Callback for the DelegatePredicate, which is used to perform the interpretation of the passed in entity.
Public delegateInterpretSetValueCallback
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.
Public delegateProjectionRowProjectorFunc
Delegate definition which is used by linq. The delegate is used to produce a single instance from the projection row specified.
Public delegateProjectionValueProducerFunc
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.
Public delegateSetter
Delegate definition for a dynamically compiled method for setting the provider specific type.
Enumerations
  EnumerationDescription
Public enumerationAggregateFunction
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.
Public enumerationAggregateSetFunction
Enum definition for the various aggregate functions supported by the AggregateSetPredicate for in-memory filters.
Public enumerationBuildInValidationBypass
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.
Public enumerationCascadeActionType
Enum which defines the cascade action type to use with data scopes
Public enumerationCatalogNameUsage
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.
Public enumerationComparisonOperator
Enum definition for the operator used in the FieldCompareValue Predicate.
Public enumerationConcurrencyPredicateType
Enum to specify to the IConcurrencyPredicateFactory what kind of predicate to produce
Public enumerationDataScopeRefetchStrategyType
Enum which defines the refetch strategy for saved entities a datascope instance has to take after commit.
Public enumerationDataSourceCacheLocation
Enum to define the data cache to use for the LLBLGen Pro DataSource controls in an ASP.NET application
Public enumerationDataSourceDataContainerType
Enum which specifies the type of object which contains the data in an LLBLGenProDataSource(2) control in an ASP.NET application
Public enumerationDataSourceSortingMode
Enum definition for LLBLGenProDataSource(2) controls to signal what sorting mode they have to use for selects.
Public enumerationDependencyInjectionContextType
Enum defined to specify in which context the instance to inject lives in.
Public enumerationDependencyInjectionTargetKind
Enum defined for dependency injection information, to specify the targetkind
Public enumerationDerivedTableFieldPresence
Enum which is used when derived table targeting fields are checked if they're present in the derived table targeted.
Public enumerationDistinctFilteringPreferenceType
Enum which defines the preference type for distinct filtering for select queries.
Public enumerationEntityState
Enum definition for the state an Entity can be in.
Public enumerationExceptionInfoElement
Enum which is used to identify the various info elements in a db specific exception info hashtable/dictionary.
Public enumerationExOp
Enum definition for the ExpressionOperators (ExOp). Name is shortened to limit typing.
Public enumerationExpressionElementType
Enum for defining the type of the expression element in an expression object
Public enumerationFetchNewAuthorizationFailureResultHint
Enum to specify the hint what to do when authorization fails on a newly fetched entity into a new object.
Public enumerationFirebirdCompatibilityLevel
Enum for compatibility level in the Firebird DQE
Public enumerationFromClauseElementDirectiveType
Type to define the from clause element directive kind
Public enumerationFullTextSearchOperator
Operator to use with FieldFullTextSearchPredicate. SqlServer specific.
Public enumerationInheritanceHierarchyType
Enum definition for defining the hierarchy type of the inheritance tree
Public enumerationJoinHint
Enum definition for the hint specified in the Add method of RelationCollection.
Public enumerationMemberOperator
Enum which specifies when the MemberPredicate should be considered 'true'
Public enumerationNavigatorAspectType
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
Public enumerationOracleCompatibilityLevel
Enum for compatibility level in the Oracle DQEs (ODP.NET and MS Oracle)
Public enumerationPostCollectionChangeAction
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.
Public enumerationPredicateExpressionElementType
Enum definition for the type of a PredicateExpressionElement
Public enumerationPredicateExpressionOperator
Enum definition for the Operators used in PredicateExpressions
Public enumerationPredicateType
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.
Public enumerationRdbmsHint Obsolete.
Enum definition for RDBMS hints, like table lock hints and other hints.
Public enumerationRecoveryStrategyDelayType
Specifies the delay type to use with a transient error recovery strategy.
Public enumerationRelationType
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
Public enumerationScaleOverflowCorrectionAction
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.
Public enumerationSchemaNameUsage
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.
Public enumerationSerializationOptimization
Enum which defines the serialization settings available.
Public enumerationSetOperator
Enum definition for the operators used with the FieldCompareSetPredicate class.
Public enumerationSingleStatementQueryAction
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.
Public enumerationSortOperator
Enum definition for the sort operator, which can be specified with IEntityField instances to create order by clauses.
Public enumerationSqlServerCompatibilityLevel
Enum for compatibility level in the SqlServer DQE
Public enumerationTemporalTablePredicateType
The type of predicate to create by the dbspecific creator for a FromClauseElement directive
Public enumerationUnitOfWorkBlockType
Enum which is used to specify block types, to identity groups of actions under the same type, e.g. inserts or updates.
Public enumerationUnitOfWorkCallBackScheduleSlot
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.
Public enumerationXmlFormatAspect
Enum definition for the flags which can be passed to overloads of WriteXml(). These flags control the way the format of the output.