MultipleFeatureSource¶
Namespace: ThinkGeo.Core
This MultipleFeatureSource is a special FeatureSource which holds a bunch of FeatureSource.
public class MultipleFeatureSource : FeatureSource
Inheritance Object → FeatureSource → MultipleFeatureSource
Remarks:
Almost all API apply to MultipleFeatureSource will apply to each FeautureSource individually.
Properties¶
FeatureSources¶
This property specify the FeatureSource collection within the MultipleFeatureSource.
public Collection<FeatureSource> FeatureSources { get; }
Property Value¶
IsEditable¶
This property returns if the FeatureSource allows edits or is read only.
public bool IsEditable { get; }
Property Value¶
Remarks:
This property is useful to check if a specific FeatureSource accepts editing. If you call the BeginTransaction and this property is false then an exception will be raised.
For developers who are creating or extending a FeatureSource it is expected that you override this virtual method if the new FeatureSource you are creating allows edits. By default the decimalDegreesValue if false meaning that if you want to allow edits you must override this method and return true.
Id¶
public string Id { get; }
Property Value¶
CanExecuteSqlQuery¶
This property specifies whether the FeatureSource can excute a SQL query or not. If it is false, then it will throw exception when these APIs are calleds: ExecuteScalar, ExecuteNonQuery, ExecuteQuery
public bool CanExecuteSqlQuery { get; }
Property Value¶
Remarks:
The default implementation is false.
IsOpen¶
This property returns true if the FeatureSource is open and false if it is not.
public bool IsOpen { get; }
Property Value¶
Remarks:
Various methods on the FeatureSource require that it be in an open state. If one of those methods is called when the state is not open, then the method will throw an exception. To enter the open state, you must call the FeatureSource's Open method. The method will raise an exception if the current FeatureSource is already open.
Projection¶
public Projection Projection { get; protected set; }
Property Value¶
CanModifyColumnStructure¶
public bool CanModifyColumnStructure { get; }
Property Value¶
IsInTransaction¶
This property returns true if the FeatureSource is in a transaction and false if it is not.
public bool IsInTransaction { get; }
Property Value¶
Remarks:
To enter a transaction, you must first call the BeginTransaction method of the FeatureSource. It is possible that some FeatureSources are read-only and do not allow edits. To end a transaction, you must either call CommitTransaction or RollbackTransaction.
IsTransactionLive¶
This property returns true if the features currently modified in a transaction are expected to reflect their state when calling other methods on the FeatureSource, such as spatial queries.
public bool IsTransactionLive { get; set; }
Property Value¶
Remarks:
The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object.
As an example, imagine that you have a FeatureSource that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed.
In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureSource reflect the changes.
ProjectionConverter¶
This property holds the projection object that is used within the FeatureSource to ensure that features inside of the FeatureSource are projected.
public ProjectionConverter ProjectionConverter { get; set; }
Property Value¶
Remarks:
By default this property is null, meaning that the data being passed back from any methods on the FeatureSource will be in the coordinate system of the raw data. When you specify a projection object in the property, all incoming and outgoing method calls will subject the features to projection.
For example, if the spatial database you are using has all of its data stored in decimal degrees, but you want to see the data in UTM, you would create a projection object that goes from decimal degrees to UTM and set that as the projection. With this one property set, we will ensure that it will seem to you the developer that all of the data in the FeatureSource is in UTM. That means every spatial query will return UTM projected shapes. You can even pass in UTM shapes for the parameters. Internally, we will ensure that the shapes are converted to and from the projection without any intervention on the developer's part.
In fact, even when you override virtual or abstract core methods in the FeatureSource, you will not need to know about projections at all. Simply work with the data in its native coordinate system. We will handle all of the projection at the high level method.
GeoCache¶
The cache system.
public FeatureCache GeoCache { get; set; }
Property Value¶
Remarks:
You must set IsActive to true for the Cache system. The default is not active.
FeatureIdsToExclude¶
A collection of strings representing record id of features not to get in the Layer.
public Collection<string> FeatureIdsToExclude { get; }
Property Value¶
Remarks:
This string collection is a handy place to specify what records not to get from the source. Suppose you have a shape file of roads and you want to hide the roads within a particular rectangle, simply execute GetFeaturesInsideBoundingBox() and add the id of the return features to the collection and forget about them. Since you can set this by Layer it makes is easy to determine what to and what not to.
TransactionBuffer¶
The TransactionBuffer used in the Transaction System.
public TransactionBuffer TransactionBuffer { get; set; }
Property Value¶
Remarks:
The Transaction System
The transaction system of a FeatureSource sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureSource. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureSource is responsible for integrating your changes into the underlying FeatureSource. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureSource API will not reflect any changes that are in the temporary editing buffer.
In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object.
As an example, imagine that you have a FeatureSource that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures. The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again. This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed.
In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records. In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureSource reflect the changes.
MaxRecordsToDraw¶
public int MaxRecordsToDraw { get; set; }
Property Value¶
Constructors¶
MultipleFeatureSource()¶
This is the default constructor for the MultipleFeatureSource class.
public MultipleFeatureSource()
Remarks:
All this constructor, you can add FeautureSources to this MultipleFeatureSource by calling the property FeatureSources.
MultipleFeatureSource(IEnumerable<FeatureSource>)¶
This is a constructor for the class by passing a group of FeeatureSources.
public MultipleFeatureSource(IEnumerable<FeatureSource> featureSources)
Parameters¶
featureSources IEnumerable<FeatureSource>
The target FeatureSources will be included in this MultipleFeatureSource.
Methods¶
GetColumnsCore()¶
This method returns the columns available for the FeatureSources within this MultipleFeatureSource.
protected Collection<FeatureSourceColumn> GetColumnsCore()
Returns¶
Collection<FeatureSourceColumn>
This method returns the columns available for the FeatureSources within this MultipleFeatureSource.
Exceptions¶
InvalidOperationException
In the event you attempt to call this method on a feature source which has not been opened it will throw an InvalidOperationException.
OpenCore()¶
This method opens the FeatureSource so that it is initialized and ready to use.
protected void OpenCore()
Remarks:
This API will open all FeatureSource included in this MultipleFEatureSource.
CloseCore()¶
This method closes the FeatureSource and releases any resources it was using.
protected void CloseCore()
Remarks:
This API will close all FeatureSource included in this MultipleFEatureSource.
GetCountCore()¶
This method returns the count of the number of records in this FeatureSource.
protected long GetCountCore()
Returns¶
This method returns the count of the number of records in this FeatureSource.
Exceptions¶
InvalidOperationException
If the operation is done under source closed state it will throw a InvalidOperationException.
Remarks:
This returning features count stands for the total count in all FeatureSource included in this MultipleFeatureSource.
GetBoundingBoxCore()¶
This method returns the bounding box which encompasses all of the FeatureSources in the MutlpleFeatureSource.
protected RectangleShape GetBoundingBoxCore()
Returns¶
This method returns the bounding box which encompasses all of the FeatureSources in the
MutlpleFeatureSource.
Exceptions¶
InvalidOperationException
If the operation is done under source closed state it will throw a InvalidOperationException.
CommitTransactionCore(TransactionBuffer)¶
This API is not supported in this concrete FeatureSource: MultipleFeatureSource.
protected TransactionResult CommitTransactionCore(TransactionBuffer transactions)
Parameters¶
transactions TransactionBuffer
This parameter encapsulates all of the adds, edits and deleted that make up the
transaction. You will use this data to write the changes to your underlying data
source.
Returns¶
The return decimalDegreesValue of this method is a TransactionResult class which gives you the
status of the transaction you just committed. It includes how many of the updates,
adds, and deletes were successful and any error that were encountered during the
committing of the transaction.
GetAllFeaturesCore(IEnumerable<String>)¶
This method returns all of the InternalFeatures in the MutipleFeatureSource.
protected Collection<Feature> GetAllFeaturesCore(IEnumerable<string> returningColumnNames)
Parameters¶
returningColumnNames IEnumerable<String>
This parameter allows you to select the field names of the column data you wish
to return with each Feature.
Returns¶
The return value is a collection of all of the InternalFeatures in the
MutipleFeatureSource.
Exceptions¶
InvalidOperationException
In the event you attempt to call this method on a feature source which has not been opened it will throw an InvalidOperationException.
Remarks:
This returning collection of Features will include all the features counting all the FeatureSources in this MultipleFeautureSource.
GetFeaturesInsideBoundingBoxCore(RectangleShape, IEnumerable<String>)¶
This method returns all of the InternalFeatures of this MultipleFeatureSource inside of the specified bounding box.
protected Collection<Feature> GetFeaturesInsideBoundingBoxCore(RectangleShape boundingBox, IEnumerable<string> returningColumnNames)
Parameters¶
boundingBox RectangleShape
This parameter represents the bounding box you with to find InternalFeatures inside of.
returningColumnNames IEnumerable<String>
This parameter allows you to select the field names of the column data you wish
to return with each Feature.
Returns¶
Exceptions¶
InvalidOperationException
In the event you attempt to call this method on a feature source which has not been opened it will throw an InvalidOperationException.
ArgumentNullException
If you pass a null as the returningColumnNames we will throw an ArgumentNullException.
ArgumentNullException
If you pass a null as the boundingBox we will throw an ArgumentNullException.
Remarks:
This returning collection of Features will include all the features insides all the FeatureSources in this MultipleFeautureSource.
GetFeaturesByIdsCore(IEnumerable<String>, IEnumerable<String>)¶
This method returns a collection of Features by providing a group of Ids.
protected Collection<Feature> GetFeaturesByIdsCore(IEnumerable<string> ids, IEnumerable<string> returningColumnNames)
Parameters¶
This parameter represents the group of Ids which uniquely identified the Features
in the FeatureSource.
returningColumnNames IEnumerable<String>
This parameter allows you to select the field names of the column data you wish
to return with each Feature.
Returns¶
Collection<Feature>
This method returns a collection of Features by providing a group of Ids.
Exceptions¶
InvalidOperationException
In the event you attempt to call this method on a feature source which has not been opened it will throw an InvalidOperationException.
ArgumentNullException
If you pass a null as the ids we will throw an ArgumentNullException.
ArgumentNullException
If you pass a null as the returningColumnNames we will throw an ArgumentNullException.
Remarks:
This returning collection of Features will include all the features with the passed in Ids insides all the FeatureSources in this MultipleFeautureSource.
GetFeaturesForDrawingCore(RectangleShape, Double, Double, IEnumerable<String>)¶
This method returns the InternalFeatures that will be used for drawing.
protected Collection<Feature> GetFeaturesForDrawingCore(RectangleShape boundingBox, double screenWidth, double screenHeight, IEnumerable<string> returningColumnNames)
Parameters¶
boundingBox RectangleShape
This parameter is the bounding box of the InternalFeatures you want to draw.
screenWidth Double
This parameter is the width in screen pixels of the view you will draw
on.
screenHeight Double
This parameter is the height in screen pixels of the view you will draw
on.
returningColumnNames IEnumerable<String>
This parameter allows you to select the field names of the column data you wish
to return with each Feature.
Returns¶
Collection<Feature>
This method returns the InternalFeatures that will be used for drawing.
Remarks:
This method returns all of the InternalFeatures of this FeatureSources with the MultipleFeatureSource in this MultipleFeautureSource. inside of the specified bounding box.
GetFeaturesNearestToCore(BaseShape, GeographyUnit, Int32, IEnumerable<String>)¶
This method will get a user defined number of Features that are closest to the TargetShape from all the FeatureSources within the MutlipleFeatureSource.
protected Collection<Feature> GetFeaturesNearestToCore(BaseShape targetShape, GeographyUnit unitOfData, int maxItemsToFind, IEnumerable<string> returningColumnNames)
Parameters¶
targetShape BaseShape
This parameter is the shape you should to find close InternalFeatures to.
unitOfData GeographyUnit
This parameter is the unit of what the TargetShape and the FeatureSource is in
such as feet, meters etc.
maxItemsToFind Int32
This parameter defines how many close InternalFeatures to find around the
TargetShape.
returningColumnNames IEnumerable<String>
This parameter allows you to select the field names of the column data you wish
to return with each Feature.
Returns¶
This method returns a user defined number of InternalFeatures that are closest to the
TargetShape from all the FeatureSources within the MutlipleFeatureSource.
Exceptions¶
InvalidOperationException
In the event you attempt to call this method on a feature source which has not been opened it will throw an InvalidOperationException.
ArgumentNullException
If you pass a null as the targetShape we will throw an ArgumentNullException.
ArgumentNullException
If you pass a null as the returningColumnNames we will throw an ArgumentNullException.
ArgumentOutOfRangeException
If you pass in a maxItemsToFind that is not greater than 0 it will throw a ArgumentOutOfRangeException.
ArgumentException
If you pass in a targetShape which is invalid we will throw an ArgumentException.
GetFeaturesOutsideBoundingBoxCore(RectangleShape, IEnumerable<String>)¶
This method returns all of the InternalFeatures of this FeatureSource outside of the specified bounding box from all the FeatureSources within the MutlipleFeatureSource.
protected Collection<Feature> GetFeaturesOutsideBoundingBoxCore(RectangleShape boundingBox, IEnumerable<string> returningColumnNames)
Parameters¶
boundingBox RectangleShape
This parameter represents the bounding box you with to find InternalFeatures outside
of.
returningColumnNames IEnumerable<String>
This parameter allows you to select the field names of the column data you wish
to return with each Feature.
Returns¶
This method returns all of the Features of this FeatureSource outside of the
specified bounding box from all the FeatureSources within the MutlipleFeatureSource.
Exceptions¶
InvalidOperationException
In the event you attempt to call this method on a feature source which has not been opened it will throw an InvalidOperationException.
ArgumentNullException
If you pass a null as the returningColumnNames we will throw an ArgumentNullException.
ArgumentNullException
If you pass a null as the boundingBox we will throw an ArgumentNullException.
Remarks:
This method returns all of the InternalFeatures of this FeatureSource outside of the specified bounding box. If you are in a transaction and that transaction is live then it will also take that into consideration.
GetFeaturesWithinDistanceOfCore(BaseShape, GeographyUnit, DistanceUnit, Double, IEnumerable<String>)¶
This method returns a collection of InternalFeatures that are within a certain distance of the TargetShape.This query will apply to all featureSource within this MultipleFeatureSource.
protected Collection<Feature> GetFeaturesWithinDistanceOfCore(BaseShape targetShape, GeographyUnit unitOfData, DistanceUnit distanceUnit, double distance, IEnumerable<string> returningColumnNames)
Parameters¶
targetShape BaseShape
The shape you wish to find InternalFeatures within a distance of.
unitOfData GeographyUnit
This parameter is the unit of data that the FeatureSource and TargetShape are
in.
distanceUnit DistanceUnit
This parameter specifies the unit of the distance parameter such as feet, miles
or kilometers etc.
distance Double
This parameter specifies the distance in which to find InternalFeatures around the
TargetShape.
returningColumnNames IEnumerable<String>
This parameter allows you to select the field names of the column data you wish
to return with each Feature.
Returns¶
This method returns a collection of InternalFeatures that are within a certain distance
of the TargetShape.
Exceptions¶
InvalidOperationException
In the event you attempt to call this method on a feature source which has not been opened it will throw an InvalidOperationException.
ArgumentNullException
If you pass a null as the targetShape we will throw an ArgumentNullException.
ArgumentNullException
If you pass a null as the returningColumnNames we will throw an ArgumentNullException.
ArgumentOutOfRangeException
If you pass in a unitOfData that is not defined it will throw a ArgumentOutOfRangeException.
ArgumentOutOfRangeException
If you pass in a distanceUnit that is not defined it will throw a ArgumentOutOfRangeException.
ArgumentException
If you pass in a targetShape which is invalid we will throw an ArgumentException.
Remarks:
This method returns a collection of InternalFeatures that are within a certain distance of the TargetShape. It is important to note that the TargetShape and the FeatureSource use the same unit such as feet or meters. If they do not then the results will not be predictable or correct. If there is a current transaction and it is marked as live then the results will include any transaction Feature that applies.
The implementation we provided create a bounding box around the TargetShape using the distance supplied and then queries the features inside of it. This may not the most efficient method for this operation. If you underlying data provider exposes a more efficient way we recommend you override the Core version of this method and implement it.
The default implementation of GetFeaturesWithinDistanceOfCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. We recommend when you override GetFeaturesInsideBoundingBoxCore method that you use any spatial indexes you have at your disposal to make this method as fast as possible.
SpatialQueryCore(BaseShape, QueryType, IEnumerable<String>)¶
This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified.
protected Collection<Feature> SpatialQueryCore(BaseShape targetShape, QueryType queryType, IEnumerable<string> returningColumnNames)
Parameters¶
targetShape BaseShape
This parameter specifies the target shape used in the spatial query.
queryType QueryType
This parameter specifies what kind of spatial query you wish to perform.
returningColumnNames IEnumerable<String>
This parameter allows you to select the field names of the column data you wish
to return with each Feature.
Returns¶
The return value is a collection of Features that match the spatial query you
executed based on the TargetShape.
Exceptions¶
InvalidOperationException
In the event you attempt to call this method on a feature source which has not been opened it will throw an InvalidOperationException.
ArgumentNullException
If you pass a null as the targetShape we will throw an ArgumentNullException.
ArgumentNullException
If you pass a null as the returningColumnNames we will throw an ArgumentNullException.
ArgumentOutOfRangeException
If you pass in a queryType that is not defined in the enumeration it will throw a ArgumentOutOfRangeException.
ArgumentException
If you pass in a targetShape which is invalid we will throw an ArgumentException.
Remarks:
This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified below. This spatial query will apply to all featureSource within this MultipleFeatureSource.
Spatial Query Types:
Disjoint - This method returns InternalFeatures where the specific Feature and the targetShape have no points in common.
Intersects - This method returns InternalFeatures where the specific Feature and the targetShape have at least one point in common.
Touches - This method returns InternalFeatures where the specific Feature and the targetShape have at least one boundary point in common, but no interior points.
Crosses - This method returns InternalFeatures where the specific Feature and the targetShape share some but not all interior points.
Within - This method returns InternalFeatures where the specific Feature lies within the interior of the targetShape.
Contains - This method returns InternalFeatures where the specific Feature lies within the interior of the current shape.
Overlaps - This method returns InternalFeatures where the specific Feature and the targetShape share some but not all points in common.
TopologicalEqual - This method returns InternalFeatures where the specific Feature and the target Shape are topologically equal.
The default implementation of SpatialQueryCore uses the GetFeaturesInsideBoundingBoxCore method to pre-filter the spatial query. We strongly recommend that you provide your own implementation for this method that will be more efficient. We recommend when you override that method that you use any spatial indexes you have at your disposal to make this method as fast as possible.
Events¶
DrawingProgressChanged¶
public event EventHandler<DrawingProgressChangedEventArgs> DrawingProgressChanged;
GettingColumns¶
public event EventHandler<GettingColumnsFeatureSourceEventArgs> GettingColumns;
GottenColumns¶
public event EventHandler<GottenColumnsFeatureSourceEventArgs> GottenColumns;
GettingFeaturesByIds¶
public event EventHandler<GettingFeaturesByIdsFeatureSourceEventArgs> GettingFeaturesByIds;
GettingFeaturesForDrawing¶
public event EventHandler<GettingFeaturesForDrawingFeatureSourceEventArgs> GettingFeaturesForDrawing;
CustomColumnFetch¶
This event is raised when fields are requested in a feature source method that do not exist in the feature source. It allows you to supplement the data from any outside source you have.
public event EventHandler<CustomColumnFetchEventArgs> CustomColumnFetch;
Remarks:
This event is raised when fields are requested in a feature source method that do not exist in the feature source. It allows you to supplement the data from any outside source you have.
It is used primarily when you have data relating to a particular feature or set of features that is not within source of the data. For example, you may have a shape file of the world whose .dbf component describes the area and population of each country. Additionally, in an outside SQL Server table, you may also have data about the countries, and it is this data that you wish to use for determining how you want to color each country.
To integrate this SQL data, you simply create a file name that does not exist in the .dbf file. Whenever Map Suite is queried to return records that specifically require this field, the FeatureSource will raise this event and allow you the developer to supply the data. In this way, you can query the SQL table and store the data in some sort of collection, and then when the event is raised, simply supply that data.
As this is an event, it will raise for each feature and field combination requested. This means that the event can be raised quite often, and we suggest that you cache the data you wish to supply in memory. We recommend against sending out a new SQL query each time this event is raised. Image that you are supplementing two columns and your query returns 2,000 rows. This means that if you requested those fields, the event would be raised 4,000 times.
CommittingTransaction¶
This event is raised after the CommitTransaction method is called, but before the CommitTransactionCore is called. This allows you access to the TransactionBuffer before the transaction is committed. It also allows you to cancel the pending commit of the transaction.
public event EventHandler<CommittingTransactionEventArgs> CommittingTransaction;
Remarks:
This event is raised before the CommitTransactionCore is called and allows you access to the TransactionBuffer before the transaction is committed. It also allows you to cancel the pending transaction. The TransactionBuffer is the object that stores all of the pending transactions and is accessible through this event to allow you to either add, remove or modify transactions.
In the event that you cancel the CommitTransaction method, the transaction remains intact and you will still be editing. This makes it a nice place to possibly check for connectivity before the TransactionCore code is run, which is where the records are actually committed. Calling the RollBackTransaction method is the only way to permanently cancel a pending transaction without committing it.
CommittedTransaction¶
This event is raised after the CommitTransaction and the CommitTransactionCore are called and allows you access to the TransactionBuffer and the TransactionResults object before CommitTransaction method is returned.
public event EventHandler<CommittedTransactionEventArgs> CommittedTransaction;
Remarks:
This event is raised after the CommitTransactionCore is called and allows you access to the TransactionBuffer and the TransactionResults object before CommitTransaction method is returned.
With this event, you can analyse the results of the transaction and do any cleanup code necessary. In the event some of the records did not commit, you can handle those items here. The TransactionResults object is passed out of the CommitTransaction method so you could analyze it then; however, this is the only place where you have access to both the TransactionResults object and the TransactionBuffer object at the same time. These are useful together to try and determine what went wrong and possibly try and re-commit them.
At the time of this event you will technically be out of the current transaction.
OpeningFeatureSource¶
This event is called before the opening of the FeatureSource.
public event EventHandler<OpeningFeatureSourceEventArgs> OpeningFeatureSource;
Remarks:
This event is called before the opening of the FeatureSource. Technically, this event is called after the calling of the Open method on the FeatureSource, but before the protected OpenCore method.
It is typical that the FeatureSource may be opened and closed may times during the life cycle of your application. The type of control the MapEngine is embedded in will dictate how often this happens. For example, in the case of the Web Edition, each time a FeatureSource is in the Ajax or Post Back part of the page cycle, it will close the FeatureSource before returning back to the client. This is to conserve resources, as the web is a connection-less environment. In the case of the Desktop Edition, we can keep the FeaureSources open, knowing that we can maintain a persistent connection.
OpenedFeatureSource¶
This event is called after the opening of the FeatureSource.
public event EventHandler<OpenedFeatureSourceEventArgs> OpenedFeatureSource;
Remarks:
This event is called after the opening of the FeatureSource. Technically, this event is called after the calling of the Open method on the FeatureSource and after the protected OpenCore method is called.
It is typical that the FeatureSource may be opened and closed may times during the life cycle of your application. The type of control the MapEngine is embedded in will dictate how often this happens. For example, in the case of the Web Edition, each time a FeatureSource is in the Ajax or Post Back part of the page cycle, it will close the FeatureSource before returning back to the client. This is to conserve resources, as the web is a connection-less environment. In the case of the Desktop Edition, we can keep the FeaureSources open, knowing that we can maintain a persistent connection.
ClosingFeatureSource¶
This event is called before the closing of the FeatureSource.
public event EventHandler<ClosingFeatureSourceEventArgs> ClosingFeatureSource;
Remarks:
This event is called before the closing of the FeatureSource. Technically, this event is called after the calling of the Close method on the FeatureSource, but before the protected CloseCore method.
It is typical that the FeatureSource may be opened and closed may times during the life cycle of your application. The type of control the MapEngine is embedded in will dictate how often this happens. For example, in the case of the Web Edition, each time a FeatureSource is in the Ajax or Post Back part of the page cycle, it will close the FeatureSource before returning back to the client. This is to conserve resources, as the web is a connection-less environment. In the case of the Desktop Edition, we can keep the FeaureSources open, knowing that we can maintain a persistent connection.
ClosedFeatureSource¶
This event is called after the closing of the FeatureSource.
public event EventHandler<ClosedFeatureSourceEventArgs> ClosedFeatureSource;
Remarks:
This event is called after the closing of the FeatureSource. Technically, this event is called after the calling of the Close method on the FeatureSource and after the protected CloseCore method.
It is typical that the FeatureSource may be opened and closed may times during the life cycle of your application. The type of control the MapEngine is embedded in will dictate how often this happens. For example, in the case of the Web Edition, each time a FeatureSource is in the Ajax or Post Back part of the page cycle, it will close the FeatureSource before returning back to the client. This is to conserve resources, as the web is a connection-less environment. In the case of the Desktop Edition, we can keep the FeaureSources open, knowing that we can maintain a persistent connection.