Implementation of the ActionQuery class.

Internal class to store entities in an action queue (insertqueue or update queue)

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.

Class which is used as an alias scope in a DbSpecificCreator.

Class which contains argument verification logic and which can throw exceptions if necessary. This code makes it easier to verify input arguments.

Abstract base class for auditors in the LLBLGen Pro system. Use this class to easily create auditors to perform auditing for you.

Abstract base class for authorizers in the LLBLGen Pro system. Use this class to easily create authorizers.

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.

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'

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.

Definition of the ByteDecimalConverter. This converter uses 'Byte' as its core type and converts any decimal value to and from Byte

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).

The controller which is the central place where caches live. Use this class to register a cache for a given connection string.

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.

DataReader which is used to traverse a cached resultset.

Wrapper object for objects which are placed in the resultsetcache.

Key object which is used to uniquely identify a query with its arguments.

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.

Event args class which is the cancelable variant of the DataSourceActionEventArgs event args class

Specialized Hashtable which contains name-value pairs for name overwriting for catalog names names in adapter on some databases (db2, sqlserver)

Definition of the CharStringConverter. This converter uses 'Char' as its core type and converts the char to and from a string.

EventArgs class for events raised by the entity collection classes for various actions.

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 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.

Static class which contains logic used by the generated code to read data from config files.

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.

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.

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.

Base class for DAO classes which are generated.

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.

Base class for DAA classes which are generated.

Projector to project plain projection data onto a custom class which can be an anonymous type.

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.

Abstract base class for the two collection projectors

Projector engine which projects plain projection result data onto new entities which are added to a single entitycollection.

Projector engine which projects plain projection result data onto new entities which are added to a single entitycollection.

Simple class which doesn't do any projection work, it simply adds all received rows to the results list.

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.

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.

Abstract base class to create a custom data scope class.

Event args class which is used with LLBLGenProDataSource(2) action events. This is the non-cancelable variant.

Special designer form which is popped up when the user clicks 'Configure data source' on an LLBLGenProDataSource2 component on an ASP.NET webform.

Special designer form which is popped up when the user clicks 'Configure data source' on an LLBLGenProDataSource component on an ASP.NET webform.

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.

General class which defines the projection result and destination of a value in an object[] array.

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.

Class which implements a function call to a database function and which is used on an EntityField(2) in a query.

Class which contains the DbProviderfactory information for a specific DQE.

Base class for every DbSpecificCreator implementation

Predicate class to filter in-memory entity collections based on a specified callback function.

Generic version of the DelegatePredicate predicate, to use with Predicate(Of T) predicates, which can be constructed with Lambda expressions.

Class which is used for storing the information read from a DependencyInjectionInformation section in the config file. Instances are created by the DependencyInjectionSectionHandler

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.

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.

Singleton class which contains the single instance of the DependencyInjectionProvider

Abstract class which defines a Dependency Injection scope in which dependency injection takes place with the information provided with this scope.

Handles the DependencyInjectionInformation section in the config file and creates an instance of DependencyInjectionConfigInformation with information stored in the section.

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.

Class which finds all derived table definitions in the object to traverse, e.g. a relation collection.

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.

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.

Definition of the DoubleDecimalConverter. This converter uses 'Double' as its core type and converts any decimal value to and from Double

Base class for DQE Configuration classes which are used with the RuntimeConfiguration system

Central base class for all DynamicQueryEngine classes. Shared logic is placed in this class, which can be overriden in the DynamicQueryEngine classes per database.

Abstract base class for the DynamicRelation class which is generated. Dynamic relations have always their left operand defined as the 'pk' side if applicable.

Base class for elementcreator/elementcreator2 which are in the generated code.

General Entity Base class, which is used to inherit the Entity classes from.

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.

Implementation of the entity collection base class.

Implementation of the entity collection base class.

EntityCollection implementation which is used for backwards compatibility and for design time databinding. This EntityCollectionNonGeneric is an EntityCollectionBase2(Of EntityBase2)

Core class for the entity classes in both Adapter and SelfServicing.

Cache class which ensures that only one instance of an entity factory is created/stored during serialization

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.

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.

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.

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.

Generic base class for entity fields.

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.

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

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

General base class for Entity Fields classes.

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 implementation for adding property descriptors for entity fields in a complex databinding scenario.

General class which defines the projection result and destination of a property of an entity.

Generic implementation of the IEntityRelation interface, which is used for relations between IEntity* instances.

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.

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.

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.

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.

Class which retrieves information from a passed in exception which is specific to a DB type, and returns it to the caller.

Helper class which is a derived class from ExcludeIncludeFieldsList containing just fields to exclude

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 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.

ExpressionElement class, definition for elements contained in an expression.

ExpressionFieldElement class, definition for field elements contained in an expression

Class with various extension methods for various classes.

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'

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

The serializer class which takes care of the fast serialization when SerializationHelper.Optimization is set to 'Fast'

Class to act as a surrogate for the fast serializer.

Class to select the proper surrogate for the fast serializer

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.

Implementation of a Field compare-operator Expression expression, using the following format: IEntityField(Core) ComparisonOperator Expression (f.e. Foo = (Bar * 2))

Implementation of a Field Compare NULL expression using the following format: IEntityField(Core) IS NULL (f.e. Foo IS NULL).

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.

Implementation of a Field compare-operator Set expression, using the following format: IEntityField(Core) ComparisonOperator (Subquery)

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 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.

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.

Abstract base class for the FieldInfoProvider class which is used by generated code to provide IFieldInfo objects and nametoindex dictionaries for EntityFields(2) objects.

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.

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

Various field related routines

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.

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

Class which is used to store function mapping related data.

General container class for static utility methods which have no better grouping class.

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 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

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.

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.

Helper class which is a derived class from ExcludeIncludeFieldsList containing just fields to include

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.

Simple class which contains the inheritance information of an entity, and which is produced by an inheritanceinfoprovider.

Base class for implementing an InheritanceInfoProvider object.

Definition of the Int16DecimalConverter. This converter uses 'Int16' as its core type and converts any decimal value to and from Int16

Definition of the Int32DecimalConverter. This converter uses 'Int32' as its core type and converts any decimal value to and from Int32

Definition of the Int64DecimalConverter. This converter uses 'Int64' as its core type and converts any decimal value to and from Int64

General data source control which can be used in ASP.NET projects to perform design time databinding and runtime databinding.

General data source control which can be used in ASP.NET projects to perform design time databinding and runtime databinding.

General datasource control base class for the selfservicing/adapter datasource controls for ASP.NET

General designer class for the LLBLGen Pro DataSource control.

General designer class for the LLBLGen Pro DataSource control.

General implementation of the DataSourceView class to be used with LLBLGenProDataSource control in ASP.NET applications.

General implementation of the DataSourceView class to be used with LLBLGenProDataSource control in ASP.NET applications.

General base class for DatSourceView objects for selfservicing and adapter.

General datasourceview for design time databinding

General datasourceview for design time databinding

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).

Specialized Hashtable which allows merging with a passed-in hashtable.

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.

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.

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.

Utility class which operates on numeric values and which applies arithmetic operations.

Some utility functions to process graphs

Exception which is thrown when a bad sequence value is detected after an insert.

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.

Exception class for configuration related errors.

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.

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.

General exception class which is thrown by a validation error.

Abstract base class for all ORM exceptions.

General exception class which is thrown when a user tries to get a value from a field which is null.

General exception class which is thrown when a user sets a field which is readonly.

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.

General exception which is thrown when an error is determined in the inheritance info during query execution.

General exception which is thrown when an interpretation error occurs during predicate / sortclause interpretation for filtering or sorting in-memory in an EntityView(2).

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).

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.

General exception which is thrown when an error occurs during the construction of the query to execute.

General exception class which is thrown when an exception was caught during a query execution. Contains the original exception as inner exception.

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)

Exception class which is usable for security exceptions thrown by authorizers.

Exception class which is thrown when a value being optimized does not meet the required criteria for optimization.

Exception class which is thrown when the maximum number of retries has been attempted or when the maximum delay has been reached.

General exception class which is thrown when a user sets a field to a value which doesn't match the type of the field.

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

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.

Class which is used to specify parameter specific aspects for a value specified in a plain SQL query call.

Event arguments class which is passed as argument in the PerformDbCount event on an LLBLGenProDataSource control.

Event arguments class which is passed as argument in the PerformDbCount event on an LLBLGenProDataSource2 control.

Event arguments class which is passed as argument in the PerformSelect event on an LLBLGenProDataSource2 control

Event arguments class which is passed as argument in the PerformSelect event on an LLBLGenProDataSource2 control

Event arguments class which is passed as argument in the PerformWork event on an LLBLGenProDataSource control.

Event arguments class which is passed as argument in the PerformWork event on an LLBLGenProDataSource control.

Class which is used to store core methods used in various parts of the persistence pipeline, and which are shared among selfservicing and adapter.

Abstract class for the persistence info provider class which is used to provide FieldPersistenceInfo objects for fields/entities.

Simple class which is used to specify aspects about a fetch query specified as plain SQL.

Abstract base implementation of the IPredicate interface.

Implementation of the IPredicateExpression interface.

Implementation of the IPredicateExpressionElement interface

Small class which wraps a predicate so it can be placed in an IExpression element, like a scalar query expression or dbfunction call.

PrefetchPath class, which specifies a prefetch path to fetch related entities during a fetch. SelfServicing specific.

PrefetchPath class, which specifies a prefetch path to fetch related entities during a fetch. Adapter specific.

PrefetchPathElement class.

PrefetchPathElement2 class.

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.

Simple class which wraps an object array and allows type converson and name-based indexing. Used in projections of DynamicQuery resultsets.

Abstract query class for the various query objects in the framework.

Class which is used to traverse over an llblgen pro object, like a derivedtable, predicate expression etc. and access all inner objects, including fields.

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.

Bucket class which contains all the parameters for formulating a set fetch query.

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.

Base class for transient error recovery stategies. Not thread safe.

Class which is used to store maps to referenced entities to be able to serialize an entity which is referenced multiple times only once.

Class which is used to stack relation objects between several entities to build a complete join path

IRelationPredicateBucket implementation which can be used as a single unit to pass to a data-access adapter for filtering over multi-entities.

Default implementation of the resultsetcache interface.

Implementation of the RetrievalQuery class.

Central configuration class to allow configuration of various runtime elements at the code level without the requirement of a config file.

Class for the set methods to configure Entity(Core) related settings

Class for the set methods to configure PrefetchPath/PrefetchPath2 instances in the runtime.

Class for the set methods to configure TraceSwitch instances in the runtime.

Class for the set methods to configure Xml serialization specific settings

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.

Specialized Hashtable which contains name-value pairs for name overwriting for schema names names in adapter on some databases (db2, sqlserver and oracle)

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.

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

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.

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.

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:

Default recovery stategy which simply re-tries a failed execution of work, no matter what the error is.

Definition of the SingleDecimalConverter. This converter uses 'Single' as its core type and converts any decimal value to and from Single

Class which implements ISortClause, a class which forms a single sort clause, thus an order by definition defined for a single IEntityField.

Implementation of the ISortExpression interface. This class contains the sort clauses used in IRetrievalQuery instances.

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.

Specific strategy to be used with SQL Azure and also usable for local SQL Server connections.

Container for the static data of an Entity fields object.

Class which defines a stored procedure call, used in the generated code to call an Action or Retrieval stored procedure.

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.

Simple place holder class to be used with the QueryFragments class.

Base class for the system type converters defined in the orm support classes.

Definition of a TVF call to be used in the Query api. A tvf call is implemented as a derived table definition.

Persistence info container for a Table valued function.

Helperclass for the value instances of EntityFieldPersistenceInfoList Used in conjunction with EntityFieldPersistenceInfoHashtable by DQE's in Insert/Delete/Update query building

Container class for the static traceswitch objects used by the tracing logic in the ORMSupportclasses.

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.

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.

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.

Wrapper class which utilizes a set typeconverter during projection.

Base class for typedlist classes in SelfServicing.

Base class for typedlist classes in SelfServicing.

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.

General base class for typedviews. This class is used to place internal framework oriented code inside a typedview

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

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 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 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.

unit of work callback element to store in the unit of work collections for callbacks.

unit of work callback element to store in the unit of work collections for callbacks.

unit of work element to store in the unit of work collections for insert/update/delete.

unit of work element to store in the unit of work collections for insert/update/delete.

unit of work element to store in the DeleteEntitiesDirectly calls to execute

unit of work element to store in the unit of work collections for insert/update/delete.

unit of work element to store in the unit of work collections for insert/update/delete.

unit of work element to store in the UpdateEntitiesDirectly calls to execute

unit of work element to store in the update multi calls to execute

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.

Simple class to define a pair of values.

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.

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.

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.

General class with extension methods for various types in the .NET library.

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

Small struct which contains the state of a field for transaction state caching.

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.

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.

Interface for action queries. These queries do not return a resultset. Action queries execute Insert, Delete and Update statements. Generic

Small interface used for accessing the ActiveContext related properties on objects

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.

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.

Interface to implement on a compressor class which can be used to compres/decompress the resulting byte array of the Fast serializer.

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.

Interface which is used to set the context on an element which isn't participating in an active context.

Interface for Data Access Objects (DAO). Every IEntity implementation has one specific Dao object SelfServicing specific.

Interface for Data Access Adapter (DAA) objects. Instances of this interface are used as 'adapters' to work with databases. Adapter specific.

Core interface for data-access logic which is used by all template groups' core persistence classes (DataAccessAdapterBase, DaoBase)

Interface for defining the IDataValueProjector type which is used for value projections when projecting an object[] content onto another data store format.

Interface which defines a database function call type, used for specifying a function call in a filter, resultset or sortclause.

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

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.

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.

Interface definition for the DynamicRelation class. This interface is implemented on the DynamicRelationBase class.

Interface for creating project elements from somewhere else, like inside Linq providers.

Interface for creating project elements from somewhere else, like inside Linq providers.

Interface implemented by both IElementCreator(2) interfaces

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

Interface used for all Entity2 classes Adapter specific

Interface for the EntityCollection type. The collection defines typed basic collection behavior. Selfservicing specific

Interface for the EntityCollection2 type. The collection defines typed basic collection behavior. Adapter specific

Interface used as the base for all entity collections. (adapter and selfservicing).

Interface used for as a base for all Entity classes

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.

Interface for EntityFactory objects used by several methods which have to create entity objects on the fly. SelfServicing specific

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

Interface to define a common interface between the factory interfaces for adapter and selfservicing.

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.

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.

Interface definition which defines the core IEntityField set. Is implemented by other interfaces like IEntityField and IEntityField2. Generic.

Interface which is used internally for getting a field's value when passing in an entity.

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

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

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.

Interface for defining the IEntityPropertyProjector type which is used for entity property projections when projecting an entityview's content onto another data store format.

Interface used for relations between IEntity* instances. Generic

General interface to access common properties of an EntityView(Of TEntity) without knowing the type of TEntity.

General interface to access common properties of an EntityView(Of TEntity) without knowing the type of TEntity.

Interface implemented on the base class of Entity view classes.

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.

Interface definition for elements contained in an expression.

Interface definition for field elements contained in an expression

Interface which is used internally on an Expression class to make the expression interpret itself on the passed in entity.

Interface to allow helper classes to be used to serialize objects that are not directly supported by SerializationWriter/SerializationReader

General interface for static entity field information and isn't related to persistence info.

Interface for the FieldInfoProvider class which is used to provide field info information for adapter/selfservicing fields / entityfields(2) objects.

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

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.

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

Interface for objects which specify inheritance information for a certain entity. Instances of this interface are produced by GetInheritanceInfo(String, Boolean)

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.

Interface to implement on specialized compressor classes to compress a passed in memory stream

Interface which allows a class to save/retrieve their internal data to/from an existing SerializationWriter/SerializationReader.

Interface which allows a class to specify that it can be recreated during deserialization using a default constructor and then calling DeserializeOwnedData()

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

Interface for the PersistenceInfoProvider classes which are used to provide persistence information for adapter/selfservicing fields.

Interface for a predicate. Predicates are expressions which result in true or false, and which are used in WHERE clauses. Generic

Interface for a PredicateExpression, which is a grouped set of Predicates. A predicate expression is usable as a WHERE clause. Generic

Interface used for the elements which are physically stored in a PredicateExpression. Generic

Interface which is used internally on a Predicate class to make the predicate interpret itself on the passed in entity.

Interface definition for the PrefetchPath type, which specifies a prefetch path to fetch related entities during a fetch. SelfServicing specific.

Interface definition for the PrefetchPath2 type, which specifies a prefetch path to fetch related entities during a fetch. Adapter specific.

Core interface for prefetch paths

Interface definition for the PrefetchPathElement type, which instances are used in a PrefetchPath instance. Selfservicing specific

Interface definition for the PrefetchPathElement2 type, which instances are used in a PrefetchPath2 instance. Adapter specific

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).

Core interface for projectors

interface for the factory which creates different sets of property descriptor sets. Required for complex databinding. Selfservicing specific.

The interface for dynamic created queries. Generic

Simple interface for relation which is the base interface for IDynamicRelation and IEntityRelation

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.

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.

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.

Interface for a cache which caches resultsets

Interface for retrieval queries. These queries do return a resultset. Retrieval queries execute Select statements. Generic

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.

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.

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

Interface for the class which contains the sort clauses used in IRetrievalQuery instances. Generic

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

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

Interface for classes which control an ado.net transaction object and which can commit/rollback this transaction

Interface for the class which supplies a default value for a specified .NET type. Necessary for NULL values read from the database. Generic

Interface base definition for TypedList classes

Interface for TypedList classes. ITypedList is already defined in .NET, that's why it is suffixed with Lgp. Selfservicing specific.

Interface for TypedList classes. ITypedList is already defined in .NET, that's why it is suffixed with Lgp. Adapter specific.

Interface for TypedView classes. Selfservicing specific.

Interface for TypedView classes. Adapter specific.

Interface for unit of work classes.

Interface for validation classes used by IEntityCore implementing classes. Generic

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.

Callback for the AggregateSetPredicate, which is used to aggregate over the set of values passed in.

Callback for the DelegatePredicate, which is used to perform the interpretation of the passed in entity.

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.

Delegate definition which is used by linq. The delegate is used to produce a single instance from the projection row specified.

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.

Delegate definition for a dynamically compiled method for setting the provider specific type.

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.

Enum definition for the various aggregate functions supported by the AggregateSetPredicate for in-memory filters.

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.

Enum which defines the cascade action type to use with data scopes

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.

Enum definition for the operator used in the FieldCompareValue Predicate.

Enum to specify to the IConcurrencyPredicateFactory what kind of predicate to produce

Enum which defines the refetch strategy for saved entities a datascope instance has to take after commit.

Enum to define the data cache to use for the LLBLGen Pro DataSource controls in an ASP.NET application

Enum which specifies the type of object which contains the data in an LLBLGenProDataSource(2) control in an ASP.NET application

Enum definition for LLBLGenProDataSource(2) controls to signal what sorting mode they have to use for selects.

Enum defined to specify in which context the instance to inject lives in.

Enum defined for dependency injection information, to specify the targetkind

Enum which is used when derived table targeting fields are checked if they're present in the derived table targeted.

Enum which defines the preference type for distinct filtering for select queries.

Enum definition for the state an Entity can be in.

Enum which is used to identify the various info elements in a db specific exception info hashtable/dictionary.

Enum definition for the ExpressionOperators (ExOp). Name is shortened to limit typing.

Enum for defining the type of the expression element in an expression object

Enum to specify the hint what to do when authorization fails on a newly fetched entity into a new object.

Enum for compatibility level in the Firebird DQE

Type to define the from clause element directive kind

Operator to use with FieldFullTextSearchPredicate. SqlServer specific.

Enum definition for defining the hierarchy type of the inheritance tree

Enum definition for the hint specified in the Add method of RelationCollection.

Enum which specifies when the MemberPredicate should be considered 'true'

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

Enum for compatibility level in the Oracle DQEs (ODP.NET and MS Oracle)

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.

Enum definition for the type of a PredicateExpressionElement

Enum definition for the Operators used in PredicateExpressions

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.

Enum definition for RDBMS hints, like table lock hints and other hints.

Specifies the delay type to use with a transient error recovery strategy.

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

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.

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.

Enum which defines the serialization settings available.

Enum definition for the operators used with the FieldCompareSetPredicate class.

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.

Enum definition for the sort operator, which can be specified with IEntityField instances to create order by clauses.

Enum for compatibility level in the SqlServer DQE

The type of predicate to create by the dbspecific creator for a FromClauseElement directive

Enum which is used to specify block types, to identity groups of actions under the same type, e.g. inserts or updates.

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.

Enum definition for the flags which can be passed to overloads of WriteXml(). These flags control the way the format of the output.